Tag: Claude

• 

  Claude Code Getting Started: Installation, Firs (2026)

  Claude Code is Anthropic’s official CLI for Claude — a terminal-based agent you can point at any codebase and have it read, write, test, and ship code. It’s different from the Claude.ai chat interface in one key way: Claude Code can act, not just answer. It reads your actual files, runs your actual commands, and makes changes that stick.

  This guide walks you through installation, first run, and the commands that cover 90% of what you’ll do daily.

  What Claude Code Is (and Isn’t)

  

  Claude Code runs in your terminal. It gives Claude access to your local machine — file system, shell, and any MCP servers you configure — so it can do real engineering work: implement features, fix bugs, write tests, explain unfamiliar codebases, and run multi-step agentic workflows.

  It is not a code autocomplete plugin (that’s what GitHub Copilot does). Claude Code is a conversational agent that works at the task level, not the token level. You describe what you want; it figures out the steps and executes them.

  Installation

  Claude Code requires Node.js 18 or later. Install via npm:

  npm install -g @anthropic-ai/claude-code

  Verify the install:

  claude --version

  That’s the only dependency. Claude Code is a Node.js CLI — no Docker, no Python env, no platform-specific setup beyond Node.

  First-Run Authentication

  The first time you run claude, it walks you through authentication. You have two options:

  Option 1: Claude subscription (Pro, Max, Team, Enterprise)
  Run claude, select “Login with Claude.ai,” and it opens a browser window to authorize. Your subscription covers Claude Code usage — no separate API billing.

  Option 2: Anthropic API key
  Set your API key as an environment variable before running:

  export ANTHROPIC_API_KEY="sk-ant-..."
  claude

  Or on Windows:

  $env:ANTHROPIC_API_KEY = "sk-ant-..."
  claude

  API key usage is billed per token at standard API rates. For heavy daily use, a Max subscription ($100–$200/month) is usually more economical than API billing.

  Your First Session

  Navigate to a project directory and start Claude Code:

  cd ~/projects/my-app
  claude

  Claude Code reads your directory automatically. At the > prompt, describe what you want:

  > What does this codebase do? Give me a 3-paragraph overview.
  

  Claude reads the files it needs and responds. No configuration required for basic usage — Claude Code infers context from the directory you’re in.

  The 5 Commands You’ll Use Daily

  

  1. claude — Start an interactive session

  claude

  Launches the REPL (read-eval-print loop). This is where you spend most of your time. Claude has access to your current directory’s files, can run bash commands, and can call any MCP servers you’ve configured.

  Within a session, you can:

  • Ask questions about the codebase
  • Request implementations (“add a rate limiter to the auth middleware”)
  • Have Claude run tests and fix failures
  • Use /help to see available slash commands
  • Use /clear to reset context without leaving the session
  • Press Escape twice to interrupt a running task

  2. claude -p "prompt" — One-shot non-interactive mode

  claude -p "What are all the API endpoints in this codebase?"

  Runs a single prompt and exits. No REPL. Good for scripting, CI pipelines, or quick one-off queries you don’t want to interrupt a workflow for. Output goes to stdout — pipe it wherever you need it.

  claude -p "Summarize the changes in the last 10 commits" | pbcopy

  3. claude mcp add — Connect an external tool

  claude mcp add github -- npx -y @modelcontextprotocol/server-github

  Adds an MCP server to your Claude Code configuration. After running this, Claude can call the server’s tools in any session. Common additions:

  # File system access (scoped to a directory)
  claude mcp add files -- npx -y @modelcontextprotocol/server-filesystem ~/Documents
  
  # GitHub integration
  claude mcp add github -- npx -y @modelcontextprotocol/server-github
  
  # Web search
  claude mcp add search -- npx -y @modelcontextprotocol/server-brave-search

  The GitHub and Brave Search servers need API tokens — set them as environment variables before the server starts, or pass them via the --env flag in the mcp add command.

  4. claude -c — Continue the last conversation

  claude -c

  Resumes your most recent Claude Code conversation, including all prior context. Essential for multi-session work on a feature. If you closed the terminal mid-task, claude -c picks up exactly where you left off.

  For a specific prior conversation:

  claude --resume SESSION_ID

  5. claude --model — Select the model for a session

  claude --model claude-opus-4-8

  Claude Code defaults to the most capable available model for your plan. You can override this per session. Current options:

  • claude-fable-5 — Highest capability, complex tasks (2x cost vs Opus 4.8)
  • claude-opus-4-8 — Default for most work, strong balance of quality and speed
  • claude-sonnet-4-6 — Faster responses, good for routine tasks
  • claude-haiku-4-5-20251001 — Fastest, lowest cost, short tasks

  Slash Commands Inside a Session

  While in a Claude Code session (> prompt), these slash commands are available:

  Command	What It Does
  /help	Show all available commands
  /clear	Clear conversation context (keep the session open)
  /compact	Compress prior context to save tokens while preserving essential memory
  /cost	Show token usage and estimated cost for the current session
  /model	Switch the model mid-session
  /review	Request a multi-agent code review of the current branch
  /init	Generate a CLAUDE.md file with project context for this repo
  /exit	End the session

  CLAUDE.md — Project-Level Context

  Drop a CLAUDE.md file in your project root and Claude Code reads it automatically at session start. Use it to encode project-specific context Claude shouldn’t have to re-derive every session:

  # My Project
  
  ## Architecture
  - Backend: FastAPI + PostgreSQL
  - Frontend: React + TypeScript
  - Deployed to: AWS ECS
  
  ## Development
  - Tests: `pytest tests/`
  - Local server: `./scripts/start-dev.sh`
  - Database migrations: `alembic upgrade head`
  
  ## Rules
  - Never modify migration files directly
  - All API routes go in `src/routes/`
  - Use `httpx` not `requests` for HTTP calls

  Generate a starter CLAUDE.md for an existing project with /init.

  Permission Modes

  

  Claude Code asks for confirmation before running bash commands, creating files, or making other changes — unless you grant it broader permissions. There are three ways to control this:

  • Default: Claude asks before each tool use that modifies files or runs commands
  • --dangerously-skip-permissions: Skip all confirmations. Use only in isolated environments (Docker containers, CI). Not for everyday use on your primary machine.
  • Session-level allowlist: During a session, you can approve individual tools for the rest of the session by selecting “Allow always” when prompted

  For most work, the default confirmation behavior is the right trade-off — it keeps you in the loop on changes without requiring you to pre-define a permission policy.

  IDE Integration

  Claude Code integrates with VS Code and JetBrains IDEs. Install the extension from each marketplace, then launch Claude Code from inside the IDE. This keeps the terminal panel visible alongside your editor without alt-tabbing between windows.

  The IDE extensions also add shortcuts for common actions like opening Claude Code in the current file’s directory and running one-shot queries against the selected code.

  Related on Tygart Media: Claude Code billing · Claude Code vs Cursor · Claude Code tutorial.

  Frequently Asked Questions

  What’s the difference between Claude Code and Claude.ai?
  Claude.ai is the web chat interface — good for questions, document analysis, and writing. Claude Code is a terminal CLI that can access your local files, run commands, and act autonomously on multi-step tasks. Claude.ai can’t modify files on your machine; Claude Code can.

  Does Claude Code cost extra on top of my Claude subscription?
  No. Claude Pro, Max, Team, and Enterprise subscriptions include Claude Code access. You use the same account. Heavy agentic usage counts toward the plan’s usage limits, but there’s no separate Claude Code fee.

  Can Claude Code access the internet?
  Not by default. Claude Code’s built-in WebFetch tool can fetch content from a specific URL when you provide it. For live web search, add the Brave Search or similar MCP server. Claude can’t browse freely without explicit tool access.

  What does Claude Code do with my code?
  Claude Code sends the file contents and context it needs to the Anthropic API for inference. Standard Anthropic API data policies apply — if you’re using an API key, you can configure zero data retention. If you’re using a subscription, default Anthropic retention policies apply. Review Anthropic’s privacy policy for current details.

  Is Claude Code open source?
  Claude Code itself (the CLI client) is not open source — it’s an Anthropic product. The MCP server ecosystem it connects to includes many open-source servers, and the MCP specification itself is open.

  What version of Node.js do I need?
  Node.js 18 or later. Run node --version to check. The Long-Term Support (LTS) version is always a safe choice.

  Last verified: June 12, 2026. Claude Code is updated frequently — run npm update -g @anthropic-ai/claude-code to stay current.

  June 12, 2026

• 

  What Is Model Context Protocol (MCP)? The Complete Guid (2026)

  Model Context Protocol (MCP) is the reason Claude can read your files, query your database, search the web, and push code to GitHub — all from inside a single conversation. Without it, Claude would be limited to whatever you paste in manually. With it, Claude connects to almost any external system.

  Quick answer: MCP is an open standard developed by Anthropic that lets AI models securely connect to external tools, data sources, and services through a standard client-server architecture (MCP getting started). You install an MCP server for the system you want Claude to access. Claude becomes a client that calls that server. The server executes the action and returns results.

  The Problem MCP Solves

  

  Before MCP, connecting an AI model to external data meant one of two things: either the AI company built a native integration (slow, expensive, proprietary), or you cobbled together a pipeline that passed data manually between systems.

  Neither approach scales. If Claude natively supported every database, every API, every file format, and every SaaS tool on the planet, the model would be perpetually behind. And manual copy-paste workflows aren’t agentic — they require you to do all the coordination work the AI should be doing.

  MCP solves this with a universal adapter layer. Instead of building individual integrations, Anthropic defined a standard. Now any developer can build an MCP server for any system, and any MCP-compatible AI client (like Claude) can use it automatically.

  How MCP Works

  

  MCP uses a client-server model over two transport mechanisms:

  • stdio: The MCP server runs as a local subprocess on your machine. Claude Code spawns it, communicates via standard input/output. This is the most common setup.
  • HTTP/SSE: The MCP server runs as a network service. Claude connects over HTTP with Server-Sent Events for streaming. Better for remote or shared servers.

  The communication protocol underneath is JSON-RPC 2.0 — a lightweight, well-understood standard for calling methods and getting results.

  Each MCP server exposes one or more of three primitives:

  • Tools: Functions Claude can call. Example: read_file(path), create_issue(title, body), run_query(sql). Claude decides when to call them based on context.
  • Resources: Data sources Claude can read. Example: the contents of a directory, a database schema, a project’s README. Resources are passive — they don’t take actions, they expose information.
  • Prompts: Reusable prompt templates that servers can provide to standardize how Claude interacts with them.

  When Claude sees a task that could benefit from an available tool, it calls the tool, receives the result, and incorporates it into the response. This happens automatically — you don’t have to tell Claude when to use MCP. Claude decides based on what the server exposes.

  MCP in Claude Code vs Claude Desktop

  Both Claude Code (the CLI tool) and Claude Desktop support MCP, but they configure servers differently.

  Claude Code

  Claude Code has built-in MCP management via the claude mcp command family:

  claude mcp add my-server -- npx -y @modelcontextprotocol/server-filesystem /path/to/directory
  claude mcp list
  claude mcp remove my-server

  Servers added with claude mcp add are stored in your Claude Code config (~/.claude.json or the project-level .claude/settings.json). Project-level configs let you commit MCP server setups to source control so the whole team gets them automatically.

  Claude Code also ships with a set of built-in tools that behave like MCP servers but don’t require separate installation: file read/write/edit, bash execution, glob search, grep, web fetch, and the agent spawning tools you’re reading about in this article.

  Claude Desktop

  Claude Desktop reads MCP server configuration from a JSON file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  A typical config entry looks like this:

  {
    "mcpServers": {
      "filesystem": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents"]
      },
      "github": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-github"],
        "env": {
          "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
        }
      }
    }
  }

  Restart Claude Desktop after editing the config. Each server you add appears in the Claude Desktop interface with a hammer icon, and Claude can access its tools in any conversation.

  The Most Useful MCP Servers

  Anthropic maintains a reference set of official MCP servers. These are the ones worth knowing:

  Server	What It Does	Package
  Filesystem	Read/write files and directories on your local machine	@modelcontextprotocol/server-filesystem
  GitHub	Read repos, create issues, open PRs, push code	@modelcontextprotocol/server-github
  PostgreSQL	Read-only SQL queries against a Postgres database	@modelcontextprotocol/server-postgres
  SQLite	Read/write a local SQLite database file	@modelcontextprotocol/server-sqlite
  Brave Search	Live web search via Brave’s Search API	@modelcontextprotocol/server-brave-search
  Puppeteer	Headless browser — screenshot pages, scrape, fill forms	@modelcontextprotocol/server-puppeteer
  Slack	Read channels, send messages, search workspace	@modelcontextprotocol/server-slack
  Google Drive	Read and search Google Drive files	@modelcontextprotocol/server-google-drive
  Git	Git operations — log, diff, commit, branch management	@modelcontextprotocol/server-git
  Memory	Persistent key-value knowledge graph across conversations	@modelcontextprotocol/server-memory

  Beyond the official set, hundreds of community-built MCP servers cover everything from Notion and Linear to AWS and Docker. The MCP ecosystem grew faster than almost anyone expected after the November 2024 launch.

  Installing Your First MCP Server

  The fastest path is Claude Code with the filesystem server. This gives Claude read/write access to a directory you specify — useful for any project work.

  Prerequisites: Node.js installed (the server runs via npx).

  In your terminal:

  claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/Documents/projects

  That’s it. Open a Claude Code session. Claude can now list, read, write, and search files inside ~/Documents/projects. Try: “List all Python files in this directory and summarize what each one does.”

  For Claude Desktop, edit the claude_desktop_config.json file directly (see format above), then restart the app.

  What MCP Cannot Do

  

  A few things worth understanding before you build on MCP:

  MCP servers don’t persist between conversations. Each Claude session starts fresh. If you need state persistence, you need a server with its own storage layer (the Memory server handles this specifically).

  MCP doesn’t bypass Claude’s safety guidelines. Claude still decides whether to execute a tool call based on safety and ethics reasoning. Connecting a filesystem server doesn’t give Claude unlimited license to delete files — Claude will still confirm before destructive operations.

  Subprocess MCP servers are local. The stdio transport runs servers on your machine. This means they only work when you’re running Claude Code locally. For remote or team-shared access, you need HTTP/SSE transport with a hosted server.

  Security Considerations

  MCP servers have real permissions. The filesystem server can read and write files. The GitHub server can push code to your repos. The Postgres server can run SQL queries.

  Apply the principle of least privilege:

  • Scope filesystem servers to the directory you actually need, not /
  • Use read-only database credentials where you don’t need writes
  • Create GitHub tokens with minimum required scope (e.g., repo for private repos, not org-level admin)
  • Never commit environment variables containing API keys to source control, even in .claude/settings.json — use env var references instead

  MCP servers run with the permissions of the user running Claude. If something goes wrong with a tool call, it can have real consequences. The upside: everything runs locally and through your own credentials — there’s no MCP cloud intermediary with access to your data.

  MCP and Claude Code’s Agentic Workflows

  The full power of MCP shows up in Claude Code’s multi-step agentic mode. When Claude Code has access to git, a filesystem, a browser, and a search tool simultaneously, it can execute workflows like:

  1. Search the web for a library’s current API (Brave Search)
  2. Read your existing code to understand the integration point (filesystem)
  3. Write the updated code (filesystem write)
  4. Run tests (bash)
  5. Create a PR (GitHub)

  Each of these steps would require a separate tool in a traditional automation stack. With MCP, Claude orchestrates all of them within a single session, using whatever servers are available.

  This is what makes MCP the infrastructure layer for agentic AI — not a feature, but the foundation that makes complex AI-driven workflows possible.

  Related on Tygart Media: Claude MCP · Skills vs MCP vs plugins · how to use Claude.

  Frequently Asked Questions

  What does MCP stand for?
  Model Context Protocol. It’s an open standard for connecting AI models to external tools, data sources, and services through a standard client-server interface.

  Who created MCP?
  Anthropic created MCP and released it as an open standard in November 2024. The specification and reference servers are open-source on GitHub. While Claude is the primary client, other AI systems can implement MCP clients too.

  Do I need to install MCP to use Claude?
  No. Claude works without any MCP servers. MCP is an extension layer — you add servers when you want Claude to access specific external systems. Claude Code also ships with a set of built-in tools (file operations, bash, web fetch) that don’t require MCP installation.

  Is MCP available on Claude.ai (the web app)?
  MCP server support is primarily in Claude Desktop and Claude Code. The Claude.ai web interface has its own tool integrations (web search, document analysis) but doesn’t support custom MCP servers in the same way.

  What’s the difference between MCP tools and Claude’s native tools in Claude Code?
  Claude Code’s native tools (Read, Write, Bash, Glob, Grep, WebFetch, Agent) are built into the application and don’t require a separate server process. MCP servers are external — they run as subprocesses or network services that Claude Code connects to. Both expose tools that Claude can call; the mechanism for loading them is different.

  How do I build my own MCP server?
  Anthropic provides official SDKs for building MCP servers in TypeScript, Python, Go, and other languages. The TypeScript SDK (@modelcontextprotocol/sdk) is the most mature. Start with Anthropic’s MCP documentation and the reference server implementations on GitHub as templates.

  Last verified: June 12, 2026. MCP specification and server ecosystem evolve quickly — check the official Anthropic MCP documentation for the current spec.

  June 12, 2026

• 

  Claude Fable 5: Capabilities, Pricing (2026)

  Anthropic released Claude Fable 5 on June 9, 2026 — and it’s the most capable model the company has ever made publicly available. After tracking every Claude release since the original 100K context window dropped, I can say this one is different. Fable 5 isn’t just an incremental update. It’s Anthropic’s Mythos-class model — the one they’d been keeping restricted — now opened up to anyone with an API key or a Claude subscription.

  Here’s what you need to know: the pricing, the benchmarks, and the specific decision framework for when to use Fable 5 versus sticking with Opus 4.8.

  Quick answer: Fable 5 costs $10/$50 per million input/output tokens (2x the cost of Opus 4.8). It outperforms Opus 4.8 significantly on complex coding, long-horizon tasks, and scientific research. Use Fable 5 when quality on hard problems justifies the cost. Use Opus 4.8 for high-volume, well-scoped, routine work.

  Current lineup note (October 2026): Fable 5.1 is the current Fable SKU at the same $10/$50 headline rates (cache reads $0.25/MTok). Current Opus is Opus 5.5 at $4/$20; Opus 4.8 remains listed as legacy. The June 2026 comparisons below are the launch record for Fable 5.

  What Is Claude Fable 5?

  

  Claude Fable 5 (claude-fable-5) is Anthropic’s first publicly available Mythos-class model. The Mythos line is Anthropic’s highest capability tier — models that were previously restricted to research and select enterprise partners because of their raw power. Fable 5 is the version Anthropic deemed safe enough to release broadly.

  The name shift (from the Opus/Sonnet/Haiku tier naming) signals something intentional. Fable 5 sits above the Opus line entirely. It’s a new ceiling.

  Key specs:

  • Context window: 1M tokens (same as Opus 4.8)
  • Max output: 128K tokens per request
  • Thinking: Adaptive (always on — not a separate “thinking mode”)
  • Vision: Yes
  • Tool use / function calling: Yes
  • Available: Claude API, AWS Bedrock, Vertex AI, Microsoft Foundry

  Claude Fable 5 Pricing

  

  Model	Input (per MTok)	Output (per MTok)	Context
  Claude Fable 5	$10.00	$50.00	1M tokens
  Claude Opus 4.8	$5.00	$25.00	1M tokens
  Claude Sonnet 4.6	$3.00	$15.00	1M tokens
  Claude Haiku 4.5	$1.00	$5.00	200K tokens

  Fable 5 costs exactly 2x Opus 4.8 on API. On subscription plans (Pro, Max, Team, Enterprise seat-based), Fable 5 is included at no extra cost through June 22, 2026.

  The free-until-June-22 window matters if you’re evaluating whether to route your workloads to Fable 5. Use that window to benchmark it against your actual tasks before the 2x cost kicks in.

  Benchmark Performance: Where Fable 5 Pulls Away

  The benchmarks that matter most are the ones that measure what the model can do on real engineering work, not trivia:

  Benchmark	Claude Fable 5	Claude Opus 4.8	Delta
  SWE-bench Verified	95.0%	88.6%	+6.4 pts
  SWE-bench Pro	80.0%	69.2%	+10.8 pts
  FrontierCode	29.3%	13.4%	~2.2x
  Senior Engineer benchmark	91/100	~63/100	+45% absolute

  The Senior Engineer benchmark is the one I find most telling. It’s designed to be hard for people who write code for a living — and Fable 5 scores 45 percentage points higher than Opus 4.8. That gap is significant enough that it changes the calculus for serious engineering work.

  When to Use Claude Fable 5 (vs Opus 4.8)

  

  I’ve been routing tasks between models for long enough to have a framework. Here’s how I think about it:

  Use Fable 5 when:

  • You’re running a large migration, refactor, or multi-stage software project
  • Quality on a hard problem matters more than per-token cost
  • You’re doing deep research, complex analysis, or long-horizon agentic work
  • The task would otherwise take a senior engineer half a day or more
  • You’re in the free evaluation window (through June 22) and want to benchmark

  Use Opus 4.8 when:

  • The task is well-scoped and routine
  • You’re running high-volume pipelines where 2x cost compounds fast
  • Latency matters — Fable 5 can take 60 seconds to several minutes on complex tasks vs 3–15 seconds for Opus 4.8
  • The task falls in Fable 5’s restricted domains (cybersecurity, biology, chemistry, distillation) — in those categories, Fable 5 routes to Opus 4.8 anyway, so you’d pay Fable 5 prices for Opus 4.8 output

  The smart routing strategy: Fable 5 for the hard jobs, Opus 4.8 for the rest. Don’t use Fable 5 as your default model — the cost and latency delta aren’t worth it for routine tasks.

  Important Limitations to Know Before You Switch

  Two limitations that don’t get enough coverage:

  1. Safety classifier routing. Fable 5 includes enhanced safety classifiers. For prompts touching cybersecurity, biology, chemistry, and distillation, those classifiers route the request to a Claude Opus 4.8 fallback. You pay Fable 5 API rates ($10/$50) but get Opus 4.8 output. If your use case is in these domains, Fable 5 is not the upgrade it appears to be.

  2. Data retention requirement. Fable 5 carries a mandatory 30-day data retention policy — Anthropic needs retained prompts and outputs to operate the safety classifiers. Claude Opus 4.8 is available under zero data retention (ZDR). If your use case requires ZDR (healthcare, legal, finance with strict data handling), stick with Opus 4.8 until Anthropic updates Fable 5’s data policy.

  Availability

  Claude Fable 5 is generally available as of June 9, 2026 on:

  • Claude API (claude-fable-5)
  • Claude Platform on AWS / Amazon Bedrock
  • Google Cloud Vertex AI
  • Microsoft Azure AI Foundry / GitHub Copilot

  Subscription access (free through June 22, 2026): Claude Pro ($20/mo), Max 5x ($100/mo), Max 20x ($200/mo), Team, and seat-based Enterprise plans all include Fable 5 access at no extra charge during the launch window. After June 22, the plan-tier access picture may change — check Anthropic’s pricing page for updates.

  How This Changes the Claude Model Decision Tree

  Before Fable 5, the Claude decision tree was straightforward:

  • Need the best? → Opus 4.8
  • Need balance? → Sonnet 4.6
  • Need speed/cost? → Haiku 4.5

  Now it’s:

  • Hard problems, complex projects, long-horizon work → Fable 5
  • Everyday work, high-volume pipelines → Opus 4.8
  • Balance of cost and capability → Sonnet 4.6
  • Speed and cost optimization → Haiku 4.5

  The introduction of a model tier above Opus 4.8 doesn’t replace the existing lineup — it creates a new ceiling for the work that genuinely needs it.

  Related on Tygart Media: Fable 5 complete guide · Fable 5 firsthand · how to use Claude.

  Frequently Asked Questions

  Is Claude Fable 5 better than Opus 4.8?
  For complex coding, multi-stage tasks, and long-horizon work: yes, significantly. On SWE-bench Pro, Fable 5 scores 80.0% vs Opus 4.8’s 69.2% — a 10+ point gap. For routine, well-scoped tasks: the gap narrows enough that Opus 4.8’s 2x cost advantage makes it the smarter choice.

  What is the Claude Fable 5 API model ID?
  claude-fable-5. This is the API string you pass to model in your API calls.

  Does Fable 5 cost more than Opus 4.8?
  Yes — exactly 2x. Fable 5 is $10 input / $50 output per million tokens. Opus 4.8 is $5/$25. Through June 22, 2026, Fable 5 is included in Claude subscription plans at no extra cost.

  Can I use Claude Fable 5 for free?
  On Pro, Max, Team, and Enterprise subscription plans, yes — through June 22, 2026. API access is metered at $10/$50 per MTok from day one.

  Does Claude Fable 5 support zero data retention (ZDR)?
  No. Fable 5 carries a mandatory 30-day data retention requirement. If your use case requires ZDR, use Claude Opus 4.8, which supports it.

  What’s the difference between Claude Fable 5 and Claude Mythos 5?
  Mythos 5 is Anthropic’s fully restricted research model — not publicly available. Fable 5 is the Mythos-class model that Anthropic has prepared for general availability, with safety classifiers and the 30-day retention policy. You can think of Fable 5 as “Mythos for the real world.”

  Last verified: October 5, 2026. Anthropic pricing and availability subject to change — check Anthropic’s pricing page for current rates.

  June 12, 2026

• 

  How to Get an Anthropic API Key (2026 Quick Guide)

  Last verified: September 26, 2026 (Pacific Time)

  Direct Answer (September 2026): To obtain an Anthropic API key: 1) Register at console.anthropic.com, 2) Navigate to Settings > Plans & Billing and deposit $5+ for Tier 1 activation, 3) Go to ‘API Keys’, click ‘Create Key’, and copy your secure sk-ant-api03-... key token.

  macOS / Linux:
  export ANTHROPIC_API_KEY="sk-ant-YOUR_KEY_HERE"
  Windows (PowerShell):
  setx ANTHROPIC_API_KEY "sk-ant-YOUR_KEY_HERE"

  Replace YOUR_KEY_HERE with the key shown once at creation — Anthropic never shows it again.

  An Anthropic API key is the secret token that authenticates your requests to Claude models over the API. It starts with sk-ant-, is created in the Anthropic Console at console.anthropic.com under API Keys → Create Key, and is displayed exactly once — requests only succeed after you add a payment method.

  Official links:Create a key (console) · API docs · API rates · Help center

  Quick answer: sign in at console.anthropic.com (it now redirects to the same developer console as platform.claude.com), add a payment method under Settings → Billing, click API Keys → Create Key, name it, and copy it immediately – Anthropic shows the key exactly once. Keys start with sk-ant-. The whole process takes about five minutes.

  Below is the full walkthrough, where to put the key so it doesn’t leak, the newer no-static-key option most tutorials haven’t caught up with, and the errors that account for nearly every failed first request. For the full reference – pricing tiers, key rotation, security, and workspace and organization keys – see our Anthropic API key reference and management guide.

  What you need before you start

  

  • An email address (or Google / SSO login)
  • A payment method – your key will not work until billing is set up, even though you can create one
  • Five minutes

  One distinction that confuses almost everyone: a Claude.ai subscription is not API access. Claude Pro, Max, and Team plans cover the Claude apps (web, desktop, mobile). The API is billed separately, by usage, through the developer console. You can have either one without the other – see our complete Claude pricing guide for how the two systems differ.

  Step 1: Create your account

  Open the Anthropic console ?

  Go to console.anthropic.com – Anthropic’s developer console. (Both console.anthropic.com and platform.claude.com land in the same place in 2026; older tutorials treat them as different sites.) Sign up with email, Google, or SSO, and answer the brief onboarding questions about whether you’re an individual or an organization. For a tour of everything inside the console, see our Anthropic Console guide.

  Step 2: Add billing

  Open billing settings ?

  In the console, open Settings → Billing and add a credit card (self-serve accounts typically purchase prepaid usage credits). Skipping this step is the #1 reason a brand-new key returns errors – the key exists, but requests are rejected until the account can be billed.

  Step 3: Create the key

  Create the key in the console ?

  Click API Keys in the left sidebar (direct link: platform.claude.com/settings/keys), then Create Key. Give it a descriptive name like my-app-dev – future you will thank present you when it’s time to rotate or revoke. If your organization uses multiple workspaces, note that keys are scoped to a workspace: the key only sees resources in the workspace it was created in.

  Step 4: Copy it immediately

  

  The key is displayed exactly once. It starts with sk-ant- followed by a long string. Copy it straight into a password manager, a .env file, or your secrets manager. If you lose it, there is no way to view it again – you revoke it and create a new one (takes a minute, harms nothing).

  Where to put the key (and where never to put it)

  

  Set it as an environment variable named ANTHROPIC_API_KEY – every official Anthropic SDK reads that variable automatically, so your code never contains the key:

  • macOS / Linux:export ANTHROPIC_API_KEY=sk-ant-...
  • Windows (PowerShell):setx ANTHROPIC_API_KEY "sk-ant-..."
  • Python:client = anthropic.Anthropic() – no key argument needed
  • TypeScript:const client = new Anthropic() – same

  Never hardcode the key in source files, never commit it to a repository, and never paste it into a system prompt or chat message. Leaked Anthropic keys get scraped and drained like any other credential.

  The 2026 no-key option: OAuth login

  Newer than most guides: Anthropic’s CLI can authenticate without any static key. Run ant auth login and a browser window authorizes a short-lived OAuth profile on your machine – the SDKs and Claude Code pick it up automatically, and there is no permanent secret to leak or rotate. For CI servers and production workloads, Workload Identity Federation serves the same purpose. If you’re setting up a personal development machine in 2026, this is arguably the better default; create a static key when you need one for a deployed service.

  Test your key

  One request confirms everything works (Haiku keeps the test nearly free):

  curl https://api.anthropic.com/v1/messages 
   -H "x-api-key: $ANTHROPIC_API_KEY" 
   -H "anthropic-version: 2023-06-01" 
   -H "content-type: application/json" 
   -d '{"model": "claude-haiku-4-5", "max_tokens": 32, "messages": [{"role": "user", "content": "Say hello"}]}'

  A JSON response with a content array means you’re live.

  Troubleshooting the four common errors

  • 401 authentication_error – the key is missing, mistyped, or revoked. Subtle 2026 variant: if both ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN are set, the SDK sends both and the API rejects the request – unset one.
  • 403 permission_error – the key works but lacks access to that model or feature; check your key’s workspace and your organization’s model access.
  • 429 rate_limit_error – you’re sending faster than your usage tier allows. The response includes a retry-after header; official SDKs retry automatically. For tier details and fixes, see our Claude rate limits guide.
  • Key created but every request fails – almost always billing not completed (Step 2).

  FAQ

  Is the Anthropic API free? No – it’s usage-priced per million tokens with no permanent free tier (current rates in our Claude pricing guide and API token rates schedule, including the September 2026 lineup).

  Where do I find my existing API key? You can’t – Anthropic shows keys only at creation. Revoke the old one and create a replacement.

  Where is the API Keys page in console.anthropic.com? Sign in at console.anthropic.com, choose API Keys in the left navigation — or go straight to platform.claude.com/settings/keys — then click Create Key.

  Does my Claude Pro or Max subscription include an API key? No. App subscriptions and API billing are separate systems; an API account starts at $0 and bills per token used.

  Lineup currency (Sept 2026, verified): Sonnet 5 ($2/$10), Opus 5.5 ($4/$20), Haiku 4.5 ($1/$5), Fable 5.1 ($10/$50). Legacy (still listed): Opus 4.8 ($5/$25), Sonnet 4.6 ($3/$15).

  Sources

  • Anthropic Help Center: Claude API and Console
  • Claude API docs: Get started
  • Anthropic Academy: Claude API development guide

  >Part of the complete guide: Claude Pricing, Plans & Limits

  June 12, 2026

• 

  Claude AI Updates (June 2026): Fable 5 & Features

  Last verified: August 26, 2026 (Pacific Time)May 2026 edition covered the Opus 4.8 launch, the SpaceX compute deal, and Managed Agents memory features.

  Direct Answer (August 2026 Update): Major mid-2026 Anthropic releases introduced Claude Fable 5, native Model Context Protocol (MCP) tool integration in Claude Desktop, extended 1M context beta on Vertex AI/AWS Bedrock, and decoupled Enterprise seat pricing.

  June 2026 is one of the biggest months for Anthropic since the Claude 4 launch: a new top-tier model is generally available, two workhorse models retire in four days, and Managed Agents can now run inside infrastructure you control. Here is everything that changed, with dates and migration paths.

  Claude Fable 5 — the Mythos-class model goes public (June 9, 2026)

  

  Anthropic released Claude Fable 5 on June 9, 2026 — the public version of what had been known as its Mythos-class model tier. It is positioned as a new tier above Opus, and it is Anthropic’s most capable generally available model. According to CNBC’s launch coverage, Fable 5 scored more than 10% higher than Claude Opus 4.8 on some benchmarks, with exceptional performance across software engineering and knowledge work. Anthropic credits new safeguards that block responses in specific high-risk areas for making a broad release possible.

  The practical details developers need:

  • Model ID: claude-fable-5
  • Availability: enterprise customers and paid subscribers
  • Context window: 1 million tokens; maximum output 128K tokens
  • API pricing: $10 per million input tokens / $50 per million output tokens
  • API surface: adaptive thinking only — temperature, top_p, top_k, and budget_tokens are not accepted, and unlike Opus 4.8, an explicit thinking: {type: "disabled"} returns a 400 error. Omit the thinking parameter entirely if you do not want it.

  For where Fable 5 sits against every other Claude model on price, see our continuously updated Claude AI pricing guide, and our complete Fable 5 guide for capabilities and use cases.

  June 15 deadline: Claude Opus 4 and Sonnet 4 retire in four days

  If you are still calling claude-opus-4-20250514 or claude-sonnet-4-20250514, those models retire from the Claude API on June 15, 2026. Requests after retirement return 404 errors. The drop-in replacements:

  • claude-opus-4-20250514 → claude-opus-4-8
  • claude-sonnet-4-20250514 → claude-sonnet-4-6

  Note that both replacements use adaptive thinking rather than manual thinking budgets, and the 4.6+ models reject assistant-turn prefills — so this is a small migration, not just a string swap. Anthropic also deprecated Claude Opus 4.1 this month, with API retirement scheduled for August 5, 2026 — worth adding to your migration calendar now.

  Current Claude model lineup and API pricing (June 2026)

  

  Model	Model ID	Context	Max output	Input $/1M	Output $/1M
  Claude Fable 5	claude-fable-5	1M	128K	$10.00	$50.00
  Claude Opus 4.8 (legacy — still listed)	claude-opus-4-8	1M	128K	$5.00	$25.00
  Claude Opus 4.8 (legacy — still listed)	claude-opus-4-8	1M	128K	$5.00	$25.00
  Claude Sonnet 4.6 (legacy — still listed)	claude-sonnet-4-6	1M	64K	$3.00	$15.00
  Claude Haiku 4.5	claude-haiku-4-5	200K	64K	$1.00	$5.00

  Opus 4.7, 4.6, 4.5, and 4.1 and Sonnet 4.5 remain active for pinned workloads. We track which model is current at any moment in our current Claude model version reference.

  Managed Agents: self-hosted sandboxes and private MCP servers

  

  Claude Managed Agents — Anthropic’s server-managed agent platform — can now execute tools inside a sandbox you control. The agent loop still runs on Anthropic’s orchestration layer, but bash commands, file operations, and code execution happen in your own container, behind your own firewall, with your own egress rules. Your worker long-polls Anthropic’s work queue over outbound-only connections; Anthropic never dials into your network. Managed Agents can also now connect to private MCP servers, which matters for any organization whose internal tools are not on the public internet.

  For regulated industries — healthcare, finance, legal — this is the missing piece that lets you adopt hosted agents while keeping data residency: files and tool output never leave infrastructure you own.

  Claude Code: nested sub-agents and plugin search

  Claude Code shipped a steady stream of updates in June: nested sub-agents (agents can now spawn their own sub-agents for deeper task decomposition), smarter model and region handling, a new plugin search, and improved Chrome, VS Code, and terminal workflows.

  Legal expansion: 20+ MCP connectors and 12 practice-area plugins

  Anthropic released more than 20 new legal MCP connectors and 12 practice-area plugins, covering research, contracts, discovery, matter management, and legal aid. The pattern to note: Anthropic is increasingly shipping vertical integration bundles rather than leaving connector-building entirely to the ecosystem.

  Claude Corps: $150M for nonprofit AI adoption

  Anthropic announced Claude Corps, a $150 million fellowship program that will embed roughly 1,000 trained fellows inside nonprofit organizations for a year to help them use AI effectively. Applications and program details are rolling out through Anthropic’s newsroom.

  Apple Foundation Models integration

  Claude support is coming to Apple’s Foundation Models framework on iOS 27, iPadOS 27, macOS 27, and visionOS 27 — meaning third-party Apple developers will be able to call Claude through Apple’s native AI framework rather than integrating the API directly.

  What to watch for in July

  • August 5, 2026: Claude Opus 4.1 retires from the API — migrate to claude-opus-4-8 before then.
  • Fable 5 ecosystem: expect Claude Code, Cowork, and Managed Agents to expose Fable 5 more broadly through July as capacity scales.
  • Apple rollout: developer betas of the iOS 27 family will show what Claude-via-Foundation-Models actually looks like in practice.

  Sources

  • CNBC: Anthropic releases Mythos-like AI model to the public, Claude Fable 5
  • Anthropic Newsroom
  • Claude API docs: Model deprecations
  • Releasebot: Anthropic release notes, June 2026

  💼 Deploying Claude or AI Infrastructure in Your Business?

  At Tygart Media, we engineer custom Model Context Protocol (MCP) servers, multi-model content pipelines, and AI operational systems. Explore our Claude AI Team Implementation Services or check out our complete Restoration Operations & AI Kit.

  June 12, 2026

• 

  Claude Fable 5 Complete Guide

  

  New in 2026

  Everything you need to know about Anthropic’s new frontier tier — pricing, context window, model comparisons, and how to route the right work to the right model.

  Updated June 2026 · ~14 min read · Includes interactive calculators

  Lineup update (September 2026): Since this guide was last fully updated, Anthropic shipped Opus 5.5 ($4/MTok in, $20/MTok out) and Sonnet 5 ($2/MTok in, $10/MTok out) as its current flagship and mid-tier models. Fable 5.1 remains the top-tier model referenced throughout, at the same $10/$50 pricing shown below. Opus 4.8 and Sonnet 4.6 are now legacy — still supported, no longer current default.

  What Is Claude Fable 5?

  

  Claude Fable 5 is Anthropic’s new frontier model tier — positioned above Opus in the lineup and designed for tasks where raw capability, extended reasoning depth, and massive context handling matter more than cost. Where Opus 4.8 set the bar for complex multi-step reasoning, Fable 5 raises it with a 1-million-token context window, enhanced agentic autonomy, and improved performance on long-horizon software engineering, research synthesis, and cross-domain analysis tasks.

  The “Fable” naming signals a new generation of model architecture rather than an incremental update. Anthropic positions it as the model you reach for when a task exceeds what Opus can do reliably — not as a replacement for Opus, Sonnet, or Haiku in their respective cost tiers.

  Quick Facts — Claude Fable 5

  Context Window

  1M

  tokens (~750K words)

  Max Output

  32K

  tokens per response

  Input Price

  $10

  per million tokens

  Output Price

  $50

  per million tokens

  Cache Write

  $12.50

  per million tokens

  Cache Read

  $1.00

  per million tokens

  Key positioning: Fable 5 is the model for tasks where Opus 4.8 produces reliable but imperfect results — long codebase audits, full-document analysis, complex multi-agent orchestration, and strategic synthesis across large corpora. For most production workflows, Sonnet remains the value pick.

  Before you price this out: The table below reflects the June 2026 lineup (Fable 5, Opus 4.8, Sonnet 4.6, Haiku 4.5). As of September 2026, Opus 5.5 ($4/$20) and Sonnet 5 ($2/$10) are Anthropic’s current models — priced lower than the legacy Opus 4.8 / Sonnet 4.6 rows shown here.

  Full Model Lineup Comparison

  

  Here’s how the complete 2026 Claude lineup stacks up across every dimension that matters for production usage:

  Model	Input $/M	Output $/M	Context	Max Out	Vision	Tool Use	Extended Think	Best For
  ◆ Fable 5	$10	$50	1M	32K	✓	✓	✓ Deep	Max-capability tasks, 1M+ context
  ◆ Opus 4.8	$5	$25	200K	32K	✓	✓	✓	Complex reasoning, agentic workflows
  ◆ Sonnet 4.6	$3	$15	200K	16K	✓	✓	✓	Production apps, content at scale
  ◆ Haiku 4.5	$1	$5	200K	8K	✓	✓	—	High-volume, latency-sensitive tasks

  Prices are per million tokens. Cache read is 90% cheaper than standard input across all models. Batch API provides an additional 50% discount on both input and output.

  Capability Matrix — What Each Model Can Do

  Capability	Fable 5	Opus 4.8	Sonnet 4.6	Haiku 4.5
  Full codebase analysis (>500K tokens)	✓ Native	⚠ Chunked	✗	✗
  Extended thinking / chain-of-thought	✓ Deep	✓	✓	✗
  Multi-step agentic orchestration	✓ Best	✓	Good	Limited
  Computer use	✓	✓	✓	✗
  MCP tool integration	✓	✓	✓	✓
  Prompt caching	✓	✓	✓	✓
  Batch API (50% discount)	✓	✓	✓	✓
  PDF / document analysis	✓	✓	✓	Limited
  Real-time streaming	✓	✓	✓	✓
  Structured JSON output	✓	✓	✓	✓

  Interactive Cost Calculator

  Estimate your monthly API spend across the full model lineup. Enter your token volumes below — the calculator models prompt caching and Batch API discounts automatically.

  Token Cost Calculator

  Model Claude Fable 5 ($10/$50) Claude Opus 4.8 ($5/$25) Claude Sonnet 4.6 ($3/$15) Claude Haiku 4.5 ($1/$5)

  Monthly API Calls

  Avg Input Tokens / Call

  Avg Output Tokens / Call

  Prompt Caching (90% off reads) Batch API (50% off all)

  Estimated Monthly Cost

  $0.00

  Which Claude Model Should You Use?

  

  Answer three questions to get a model recommendation tailored to your use case.

  Model Picker — 3 Questions

  1. How large is your context? (document/codebase size)

  Under 50K tokens

  50K–200K tokens

  200K–1M tokens

  2. How complex is the task?

  Simple / structured (classify, extract, format)

  Moderate (draft, summarize, QA)

  Complex (reason, plan, code, orchestrate)

  3. How cost-sensitive is this workload?

  Very — high volume, every cent counts

  Moderate — quality matters more than cost

  Not sensitive — quality and capability first

  How We Actually Use Each Model

  These are real production workflows mapped to the right tier — built from running Claude in content operations, publishing automation, and knowledge management at scale. No hypotheticals.

  Haiku 4.5 — High Volume

  Daily SEO Refresh Pipeline

  • 25-post-per-day SEO metadata refresh
  • Article classification and tag assignment
  • Structured data extraction from web pages
  • Keyword density checks across large post archives
  • Link validation and redirect flagging

  Sonnet 4.6 — Production Default

  Editorial Content at Scale

  • Desk article writing (1,200–2,500 words)
  • Content brief execution from keyword clusters
  • FAQ and schema markup generation
  • Cross-site content adaptation and localization
  • Monthly client update drafts and summaries

  Opus 4.8 — Complex Reasoning

  Workers & Deep Refreshes

  • Agentic Notion Workers (multi-step pipelines)
  • Deep content refresh with competitive gap analysis
  • Multi-database synthesis and reporting
  • Strategy documents requiring extended reasoning
  • Code generation for automation scripts

  Fable 5 — Max Capability

  Portfolio Audits & Strategy

  • Full-site content audits (500+ posts in single context)
  • Cross-domain strategy synthesis across large corpora
  • Complex multi-agent orchestration at the flagship tier
  • Long-horizon planning requiring deep reasoning depth
  • Codebase-wide analysis and architecture review

  Routing principle: The right model is the cheapest one that reliably completes the task. Haiku handles volume. Sonnet handles production. Opus handles complexity. Fable 5 handles scale + complexity together — specifically the cases where you’d need Opus and more context than Opus can hold.

  The Economics: Routed vs All-Fable

  Smart model routing is where API costs get controlled. Here’s a real-world comparison of a mixed content-and-automation workload at scale — routed vs running everything on Fable 5.

  Workload	Monthly Volume	Routed Model	Routed Cost	All-Fable 5 Cost	Savings
  SEO metadata batch refresh	750 posts/mo	Haiku 4.5 + Batch	$1.20	$18.75	93% less
  Article drafting	90 articles/mo	Sonnet 4.6	$8.10	$67.50	88% less
  Agentic worker runs	200 runs/mo	Opus 4.8	$22.50	$45.00	50% less
  Full-site portfolio audits	4 audits/mo	Fable 5	$24.00	$24.00	—
  Total	—	Routed	$55.80	$155.25	64% less

  Stacking Discounts: Caching + Batch API

  Two discount mechanisms compound independently:

  • Prompt caching: Cache your system prompt and shared context once. Subsequent requests pay ~10% of the input price for cache reads. On Fable 5, that’s $1.00/M instead of $10.00/M on cached tokens — a 90% reduction on your largest cost lever.
  • Batch API: Submit requests asynchronously (results within 24 hours) for a flat 50% discount on both input and output. Works on all four models. Best for non-real-time workloads like overnight refreshes, audits, or bulk classification.
  • Stacked: Caching + Batch combined can bring effective Fable 5 input cost from $10/M to ~$0.50/M on cached tokens — making it economically viable for high-volume tasks that previously only fit Haiku’s budget.

  See our Claude context window guide for more on how to structure prompts to maximize cache hit rates.

  Related Claude Resources

  Claude Context Window Guide Claude Projects Deep Dive Claude Code Plan Mode Claude MCP Setup Guide Opus 4.7 Feature Deep Dive Claude Code vs Cursor (2026)

  Claude Fable 5 FAQ

  What is the difference between Claude Fable 5 and Claude Opus 4.8?

  Claude Fable 5 sits above Opus 4.8 in the lineup. The primary difference is context window size — Fable 5 offers 1 million tokens vs Opus 4.8’s 200K — and the depth of extended reasoning for highly complex tasks. Opus 4.8 remains the right choice for most complex agentic workflows at half the cost. Fable 5 is best when you need both maximum context and maximum reasoning depth simultaneously, or when a task has routinely hit the limits of what Opus can do reliably.

  How much does Claude Fable 5 cost compared to other models?

  Claude Fable 5 is priced at $10 per million input tokens and $50 per million output tokens — 2× Opus 4.8 ($5/$25), 3.3× Sonnet 4.6 ($3/$15), and 10× Haiku 4.5 ($1/$5). Prompt caching drops the effective input cost to $1.00/M on cache reads, and the Batch API adds a 50% discount on all tokens for non-real-time workloads. Stacking both discounts makes Fable 5 viable for higher-volume use cases than the base price suggests.

  What is the Claude Fable 5 context window?

  Claude Fable 5 has a 1-million-token context window — approximately 750,000 words or roughly 1,500 pages of text. This is 5× the context window of Opus 4.8, Sonnet 4.6, and Haiku 4.5 (all 200K). In practice, a 1M context window lets you pass entire codebases, long research corpora, or full document archives in a single API call without chunking or retrieval workarounds. For more on context window mechanics, see our full context window guide.

  Can I use Claude Fable 5 with the Claude API?

  Yes. Claude Fable 5 is available through the Anthropic API using the model ID claude-fable-5-20260101 (check the Anthropic documentation for the exact identifier). It supports the same API surface as the rest of the Claude family — streaming, tool use, prompt caching, vision, the Batch API, and MCP server integration. Access requires an Anthropic API account with Fable 5 enabled on your usage tier.

  Is Claude Fable 5 available in Claude.ai?

  Fable 5 is available in Claude.ai on the Pro and Team plans. The interface lets you select it from the model picker when starting a conversation. Like Opus, Fable 5 in claude.ai has message limits that reset on a rolling window — it’s designed for individual complex tasks rather than high-volume API workloads. For production-scale usage, the API with the Batch API discount is the more economical path.

  Does Claude Fable 5 support extended thinking?

  Yes — and Fable 5’s extended thinking is the deepest in the lineup. Where Opus 4.8 supports extended thinking for complex reasoning tasks, Fable 5 uses a more capable reasoning engine designed for tasks that require longer chains of inference, more working memory, and more reliable self-correction. It’s particularly effective on math, logic, long-horizon planning, and tasks where the model needs to hold and manipulate many interdependent concepts simultaneously.

  When should I use Fable 5 vs Sonnet for content production?

  For most content production — articles, blog posts, social copy, summaries, SEO content — Sonnet 4.6 is the right call. It produces high-quality output at 3.3× less cost than Fable 5, and for typical content lengths (500–3,000 words), the quality difference is minimal. Reach for Fable 5 when you need to synthesize across a very large corpus (e.g., auditing 200+ posts simultaneously), when the content requires deep domain reasoning that benefits from extended thinking, or when the task involves both large-context ingestion and complex output generation in a single pass.

  What’s the best way to reduce Claude Fable 5 API costs?

  Three levers in order of impact: (1) Model routing — only use Fable 5 when the task genuinely requires it; route everything else to Opus, Sonnet, or Haiku based on complexity and volume. (2) Prompt caching — structure your system prompt and shared context so it can be cached; cache reads cost $1.00/M instead of $10.00/M on Fable 5. (3) Batch API — submit non-real-time workloads via the Batch API for a flat 50% discount. Stacking all three — routing + caching + batch — can reduce effective per-task costs by 85–95% compared to unoptimized Fable 5 calls.

  More Claude Guides from Tygart Media

  We run Claude in production every day. These are the guides that come from using it, not just writing about it.

  Context Window Guide Claude Projects Plan Mode MCP Setup Code vs Cursor

  Related on Tygart Media: Claude Fable 5 overview · Fable 5 firsthand · Claude pricing.

  June 9, 2026

• 

  Connect Claude Code to Postgres via MCP: The Right Way (2026)

  The most useful thing you can wire into Claude Code isn’t a new model or a clever prompt — it’s your actual database. When Claude Code can read your schema, it stops guessing at table names, column types, and relationships. It starts writing queries that work the first time.

  This is the practical walkthrough for connecting Claude Code to a Postgres database via MCP: the command, the credential setup, the safety pattern, and what the workflow actually looks like once it’s running.

  Last refreshed: October 8, 2026 (Pacific)

  What the Postgres MCP server does

  

  The official @modelcontextprotocol/server-postgres package (maintained in the MCP reference implementations repo) gives Claude Code four tools: schema inspection, query execution inside a read-only transaction, table detail lookup, and relationship traversal. The server cannot write data — it’s read-only by design in the reference implementation, though third-party variants like postgres-mcp-pro add configurable write access if you need it.

  For the majority of development workflows — debugging, writing migrations, generating queries — read-only is exactly what you want. Claude Code can see the shape of your data without being able to touch it.

  The fastest path: single command setup

  

  If you just want it running against a local database:

  claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres "postgresql://USER:PASSWORD@localhost:5432/mydb"

  The -y flag on npx auto-accepts the package install so the command doesn’t hang on first run. Verify with:

  claude mcp list

  You should see postgres with a connected status. That’s it — Claude Code now has schema access in the current project.

  Don’t do this for a production database. The connection string above is hardcoded. It goes into ~/.claude.json as plaintext. Use a dedicated local or staging database during development, and use env vars for anything that matters.

  The right way: env vars and a read-only user

  

  Two things to do before connecting to any real database:

  1. Create a read-only Postgres user:

  CREATE USER claude_readonly WITH PASSWORD 'your-password-here';
  GRANT CONNECT ON DATABASE your_db TO claude_readonly;
  GRANT USAGE ON SCHEMA public TO claude_readonly;
  GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;
  ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO claude_readonly;

  This user can see everything in public and do nothing else. If something goes wrong — a rogue tool call, a compromised session — blast radius is zero.

  2. Reference the connection string via env var in .mcp.json:

  {
    "mcpServers": {
      "db": {
        "type": "stdio",
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-postgres"],
        "env": {
          "POSTGRES_CONNECTION_STRING": "${DATABASE_URL}"
        }
      }
    }
  }

  Set DATABASE_URL in your shell environment or in a .env file (not committed). Add .mcp.json to the repo — everyone on the team gets the same server config — but the actual connection string lives in each developer’s local environment. This is the same pattern you already use for application config. It’s the right pattern here too.

  Add the server at project scope so it’s committed:

  claude mcp add --scope project --transport stdio db -- npx -y @modelcontextprotocol/server-postgres

  Then edit .mcp.json to replace the hardcoded connection string with the ${DATABASE_URL} env var reference shown above.

  What Claude Code can actually do with schema access

  Once the server is connected, the workflow changes significantly. A few real examples:

  Schema exploration: Ask Claude Code “what tables are in this database and how are they related?” and it traverses foreign keys, describes join paths, and builds a mental model of your data layer. No more copy-pasting \dt output.

  Query generation: “Write a query that finds users who signed up in the last 30 days but haven’t completed onboarding” produces accurate SQL because Claude Code knows your actual column names. With a generic prompt and no schema access, you’d get plausible-looking SQL that fails because user_status is actually onboarding_state.

  Migration drafting: “I need to add a last_login_at column to users — show me the migration and check for existing timestamp patterns in the schema.” Claude Code inspects the schema first, matches your existing column naming conventions, and produces a migration that fits your codebase.

  Debugging: “This query is returning the wrong count — here’s the query, check it against the schema.” Claude Code can spot that you’re joining on a nullable column, missing a filter on a soft-delete flag, or aggregating before filtering.

  Neon and cloud Postgres

  If you’re on Neon, there’s a first-party MCP server with additional capabilities: branch management, database creation, and schema migrations via Neon’s branching model. Set it up with:

  npx neonctl mcp add

  This runs OAuth through your browser and configures Claude Code automatically. The Neon MCP server is intended for local development and IDE workflows — not production automation — same caution applies.

  Debugging when it doesn’t connect

  Three commands for when the server shows as disconnected:

  claude mcp list          # check registered servers and status
  claude mcp test db       # test a specific server
  claude --debug           # tail logs including MCP stderr output

  Most connection failures are either a wrong connection string, a missing env var, or Node version issues with npx. The debug log shows the exact error from the server process — read it before assuming the problem is Claude Code.

  The practical baseline

  Five minutes to set up. The productivity delta on any codebase larger than a few tables is immediate — Claude Code stops making column-name mistakes and starts being genuinely useful for data-layer work. Wire up the read-only user, commit the .mcp.json, and add DATABASE_URL to your team’s .env.example. Done.

  The model doing the work in a typical Claude Code session is claude-sonnet-5-5 (workhorse) — it handles schema-aware query generation well without burning through Opus 5.5 credits on every lookup.

  Related Reading

  • How to Connect Any Tool to Claude with MCP: Complete Setup Guide
  • Notion MCP Setup with Claude: Complete Config + Undocumented Errors
  • Claude Code vs Codex CLI (2026): A Hands-On Head-to-Head
  • Claude Code vs Cursor in 2026: An Honest Comparison
  • Always Allow vs Allow Once: Claude Code’s Quiet Tell
  • Beyond llms.txt: Why AI Agents Crawl llms-full.txt More
  • The AI Operator’s Stack: Running a Multi-Brand Content Machine

  Frequently Asked Questions

  How do I connect Claude Code to a Postgres database via MCP?

  Run: claude mcp add postgres — npx -y @modelcontextprotocol/server-postgres “postgresql://USER:PASSWORD@localhost:5432/mydb”. The -y flag auto-accepts the package install so the command doesn’t hang. Then run claude mcp list and confirm postgres shows a connected status. Use a local or staging database for this quick path, not production.

  Is the Postgres MCP server read-only?

  Yes. The official @modelcontextprotocol/server-postgres package is read-only by design — it exposes schema inspection, query execution inside a read-only transaction, table detail lookup, and relationship traversal. It cannot write data. Third-party variants like postgres-mcp-pro add configurable write access if you need it.

  What’s the safe way to connect Claude Code to a production database?

  Create a dedicated read-only Postgres user (GRANT SELECT only), and reference the connection string through an environment variable in .mcp.json using ${DATABASE_URL} rather than hardcoding it. Commit .mcp.json so the team shares the server config, but keep the actual connection string in each developer’s local .env. If a session is ever compromised, the blast radius is zero.

  Why does schema access make Claude Code more accurate?

  With schema access, Claude Code reads your real table names, column types, and relationships, so it writes queries that work the first time instead of guessing. Without it, you get plausible-looking SQL that fails because user_status is actually onboarding_state. It also improves migration drafting and query debugging by matching your existing conventions.

  How do I debug a Postgres MCP server that won’t connect?

  Use three commands: claude mcp list to check registered servers and status, claude mcp test db to test a specific server, and claude –debug to tail logs including MCP stderr. Most failures are a wrong connection string, a missing env var, or a Node version issue with npx — the debug log shows the exact server error.

  June 3, 2026

• 

  Claude Code vs Codex CLI (2026): A Hands-On Head-to-Head

  Last verified: June 2026.

  Both Claude Code and OpenAI Codex CLI are terminal-native coding agents: you run them inside a repo, they read your files, edit code, run commands, and iterate. I run both daily on real projects. This is the head-to-head I wish existed when I was deciding which one to make my default. No benchmarks-chasing, just install commands, config files, pricing math, and where each one actually earns its keep. For the broader toolchain these slot into, see our AI operator’s stack.

  Claude Code vs Codex CLI: the short answer

  

  If you want one sentence: Claude Code is the more mature agentic harness (subagents, hooks, skills, deep MCP, a flat-rate plan that makes heavy use affordable), while Codex CLI is the leaner, cheaper-per-token option with strong raw coding from the GPT-5.x line and a tight sandbox model. Most teams that live in the terminal all day end up on Claude Code for the workflow tooling; people who want a fast, low-cost agent on top of an existing OpenAI subscription reach for Codex.

  The honest version: they are closer than tribal arguments suggest. The deciding factors are almost never “which model is smarter this week” and almost always pricing structure, sandbox defaults, and how much workflow scaffolding you need.

  How do you install each one?

  

  Claude Code installs from npm and runs as the claude command:

  npm install -g @anthropic-ai/claude-code
  cd your-project
  claude

  First run walks you through OAuth login (Pro/Max plan) or an ANTHROPIC_API_KEY. On Windows it runs natively in PowerShell now, though a lot of operators still prefer it under WSL for fewer path headaches.

  Codex CLI ships an install script and is also on npm:

  # Mac / Linux
  curl -fsSL https://chatgpt.com/codex/install.sh | sh
  
  # Windows (PowerShell)
  powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"
  
  # or via npm
  npm install -g @openai/codex

  Then codex in your repo. Auth is either a ChatGPT login (Plus/Pro/Business) or an OpenAI API key via codex login. Both tools are open-source clients hitting hosted models, so the install is the easy part; the model access is what you are really buying.

  Which models do they run in 2026?

  Claude Code defaults to the current Claude flagship. As of June 2026 that is Opus 4.8 (legacy — still listed) for the hardest reasoning, with Sonnet 4.6 (legacy — still listed) as the fast everyday workhorse and Haiku 4

  Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

  .5 for cheap, high-volume calls. You switch in-session with /model. Opus 4.8 also exposes reasoning-effort levels (high is the default; xhigh and max push deeper on gnarly problems at higher token cost).

  Codex CLI runs the GPT-5.x coding line. GPT-5.5 is the current recommended default for complex coding and agentic work, GPT-5.4-mini is the faster/cheaper option for light tasks and subagents, and GPT-5.3-Codex remains a strong coding-tuned choice. Pick the model with codex -m gpt-5.5 or set it in your config.

  Practical read: on a clean, well-specified function both produce good code. The gap shows up on long, multi-file refactors where the agent has to hold a lot of context and recover from its own mistakes. That is a harness problem as much as a model problem, which is the next section.

  What about workflow features: subagents, hooks, and config?

  This is where Claude Code is currently ahead, and it is the real reason it tends to win for power users.

  • Subagents – Claude Code spawns isolated sub-sessions with their own context window, tool restrictions, and prompts. Great for “go research this in parallel while the main thread keeps coding.” Codex has a lighter subagent concept (often pointed at GPT-5.4-mini to keep cost down) but it is less fleshed out.
  • Hooks – Claude Code fires deterministic scripts at lifecycle points (PreToolUse, UserPromptSubmit, and more). These run real code, so they cannot hallucinate: you can hard-block a dangerous command, auto-format on every edit, or inject context before the model sees a prompt. Codex leans on its approval/sandbox policy and execpolicy rules instead of a general hook system.
  • Skills and slash commands – In Claude Code, custom slash commands have merged into skills; /your-command still works and skills add reusable, packaged capabilities. Codex uses prompt files and profiles rather than a skills layer.
  • Project memory – Both read a project instruction file. Claude Code uses CLAUDE.md; Codex uses AGENTS.md (checked in a fallback order including AGENTS.override.md and .agents.md). Keep these tight: architecture, conventions, and the few rules the agent keeps forgetting.

  Codex’s config story is clean if you like a single file: ~/.codex/config.toml holds your model, approval policy, sandbox mode, MCP servers, and named profiles you switch with codex --profile work. Claude Code spreads config across ~/.claude/ and .claude/settings.json plus per-project files, which is more surface area but more granular control.

  How do the sandbox and approval models compare?

  This matters more than most comparisons admit, because it governs how much the agent can do without asking.

  Codex CLI has an explicit, well-documented sandbox. Sandbox modes run from read-only to workspace-write (edit files in the project, network off by default) up to full access, paired with approval policies like untrusted and on-request. On Windows the native sandbox can run unelevated or elevated. The mental model is clear: pick how much rope, then approve escalations.

  Claude Code manages permissions through allow/deny rules and modes (including a plan mode that reasons without touching files, and an auto-accept mode for trusted loops). Combined with PreToolUse hooks you can build a strict policy, but it is more “assemble it yourself” than Codex’s preset sandbox tiers.

  If you are dropping an agent onto an unfamiliar or sensitive repo, start read-only in both. Codex makes that posture a one-flag default; Claude Code gives you finer-grained control once you invest in the config.

  Do both support MCP?

  

  Yes, and this is a genuine tie that matters. Both speak the Model Context Protocol, so you can wire in the same external tools, databases, and APIs. Codex registers STDIO or streaming-HTTP MCP servers in ~/.codex/config.toml and launches them at session start. Claude Code adds servers via claude mcp add or JSON config. If you have already built MCP integrations, neither tool locks you out. New to MCP, start with our Claude MCP setup guide and the Notion MCP setup walkthrough.

  What does each one cost?

  Pricing is where the decision often gets made, so here are the real numbers as of June 2026.

  Claude Code plans:

  • Pro – $20/mo: Sonnet 4.6 plus some Opus, roughly enough for focused daily sessions, not all-day heavy use.
  • Max 5x – $100/mo: much larger windows, real Opus headroom.
  • Max 20x – $200/mo: the heavy-user tier; effectively flat-rate firehose access.
  • API pay-as-you-go: Opus 4.7 about $5/$15 per million input/output… (legacy (still listed) Opus tier runs higher), Sonnet 4.6 (legacy — still listed) $3/$15, Haiku 4.5 $1/$5.

  Codex CLI: Included in ChatGPT Plus/Pro/Business plans (usage g

  Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

Codex CLI: Included in ChatGPT Plus/Pro/Business plans (usage governed by your plan’s limits), or pay-as-you-go on the API. GPT-5.3-Codex runs about $1.75 per million input / $14 per million output, with cheaper input on cached tokens. The mini model is far cheaper for light work.

The structural difference: Claude Code’s Max plans are flat-rate, which is why heavy users love them. People have tracked billions of tokens that would cost five figures on API metering but ran around a few hundred dollars on Max. Codex’s per-token rates are lower per unit and great if your usage is bursty or already bundled into a ChatGPT subscription, but a true all-day agent habit can run up metered cost faster than a flat plan. Estimate your monthly token volume honestly, then do the arithmetic both ways.

So which coding agent should you actually use?

Pick Claude Code if you want the deepest agentic workflow (subagents, hooks, skills), you are a heavy daily user who benefits from the flat-rate Max plan, or you need fine-grained, scriptable control over what the agent can do. It is the more complete operator’s harness in 2026.

Pick Codex CLI if you want lower per-token cost, you already pay for ChatGPT and want to use that allowance, you like the clean preset sandbox/approval model, or you simply prefer the GPT-5.x output style. It is lean, fast to stand up, and genuinely capable.

The move a lot of us make: run both. They are cheap relative to engineer time, they share MCP servers, and they have different failure modes. When one gets stuck in a loop on a hard bug, handing the same task to the other with fresh context often breaks the logjam. If you are weighing terminal agents against IDE-native ones, our Claude Code vs Cursor breakdown covers that axis.

Related on Tygart Media: Claude Code vs Cursor · Claude Code getting started · coding benchmarks.

Frequently asked questions

Is Claude Code or Codex CLI better for large refactors?

Claude Code tends to hold up better on long multi-file refactors, mostly because of subagents and hooks that keep context organized and catch mistakes deterministically. Codex can do it too, especially with GPT-5.5, but you lean harder on tight AGENTS.md instructions and approval gates.

Can I use Codex CLI without a ChatGPT subscription?

Yes. Run codex login with an OpenAI API key and you pay per token instead of through a ChatGPT plan. Same for Claude Code with an ANTHROPIC_API_KEY if you would rather meter than subscribe.

Do they work on Windows natively?

Both do in 2026. Claude Code runs in PowerShell (many operators still prefer WSL for cleaner paths), and Codex CLI has a native Windows installer plus a Windows sandbox with unelevated/elevated modes. Watch out for shells that mangle /tmp or C: style paths in arguments.

What is the single biggest difference?

Pricing structure and workflow depth. Claude Code offers flat-rate Max plans and a richer harness (subagents, hooks, skills); Codex offers lower per-token rates and a cleaner preset sandbox. Model quality is close enough that those two factors usually decide it.

Which model do they run by default?

Claude Code defaults to the legacy (still listed) Claude flagship (Opus 4.8 (legacy — still listed) as of June 2026, with Sonnet 4.6 (legacy — still listed) for everyday speed). Codex CLI recommends GPT-5.5 for complex work, with GPT-5.4-mini and GPT-5.3-Codex as alternatives

Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

. Switch in-session with /model or the -m flag.

How do I get either tool cited or surfaced by AI engines for my own docs?

That is a content question, not a tooling one. The same structure that makes this page answerable, short factual answers, question-shaped headers, and a visible FAQ, is what AI engines reward. See how AI engines cite content for the full playbook.

>Part of the complete guide: Claude vs the Field