Tag: Anthropic

Claude Enterprise Compliance: SOC 2, HIPAA & Security

Last verified: June 13, 2026

Anthropic publishes a defined compliance posture for Claude: it holds SOC 2 Type I and Type II, ISO 27001:2022, and ISO/IEC 42001:2023 credentials; it will sign a Business Associate Agreement (BAA) covering HIPAA-ready services such as the first-party API and Enterprise plans; by default it does not train models on data sent under its commercial terms; and it offers a zero-data-retention (ZDR) arrangement on the Messages and Token Counting APIs. The hard part for buyers is the per-surface boundary â€” what the BAA covers, which features are blocked under ZDR or HIPAA, how long data is kept, and where it can be processed. Every figure below is drawn from Anthropic’s own trust, privacy, and developer documentation, with sources at the bottom. Eligibility, feature lists, and durations change; treat your signed contract and the live Trust Center as the controlling sources.

Certifications and attestations

Five security domains: identity, data, code governance, audit, agents — Certifications and attestations overview.

Anthropic’s help center lists the following compliance credentials for its commercial products (Claude for Work and the Anthropic API). It directs customers to the Trust Portal at trust.anthropic.com to request copies of the underlying reports and certificates.

Credential	Status as described by Anthropic	Scope
SOC 2 Type I & Type II	Listed as held	Commercial products (Claude for Work, Anthropic API)
ISO 27001:2022	Certified	Information Security Management
ISO/IEC 42001:2023	Certified (issued by Schellman Compliance, LLC, accredited by the ANSI National Accreditation Board)	AI Management Systems
HIPAA	“HIPAA-ready configuration (BAA available)”	See BAA section

Anthropic describes itself as “one of the first frontier AI labs” to achieve ISO/IEC 42001:2023 certification, in an announcement dated January 13, 2025. The help-center certifications list does not mention ISO 27017, ISO 27018, FedRAMP, or CSA STAR; those are left out here rather than asserted. GDPR and CCPA are handled through Anthropic’s privacy program and customer agreements rather than as line-item “certifications” (see GDPR section).

HIPAA and the BAA: covered by product surface

Five-step path: account, API keys, billing, usage, workspaces — HIPAA and the BAA by product surface.

Anthropic states it “provides a Business Associate Agreement (BAA) covering our HIPAA-ready services, such as use of our first-party API or Enterprise plans.” HIPAA readiness is enforced at the organization level: Anthropic provisions a dedicated HIPAA-enabled organization that automatically blocks non-eligible features. To process protected health information (PHI) on the API, an administrator must sign the BAA and contact sales to enable it; for Enterprise, an admin activates HIPAA compliance in the Claude Enterprise admin settings under “Data & Privacy” and signs the BAA there.

Surface	BAA / HIPAA-ready coverage
First-party Claude API (Messages API)	Covered as an Eligible Service (admin signs BAA, then contact sales)
Claude Enterprise	Covered once an admin activates HIPAA compliance and signs the BAA
Workbench and Console	Not covered
Claude Free, Pro, Max, Team	Not covered
Cowork	Not covered
Claude Code	Not covered under HIPAA readiness
Amazon Bedrock / Vertex AI	Not covered (cloud provider is the data processor; see those platforms)
Claude Platform on AWS / Microsoft Foundry	HIPAA readiness not available
Beta features (e.g., Claude in Office, Claude Design)	Generally not covered unless explicitly listed as eligible

Within the API, only a subset of features is HIPAA-eligible. Anthropic enforces this in code: a HIPAA-enabled organization that sends a non-eligible feature gets a 400 invalid_request_error naming the blocked feature. Anthropic states your signed BAA is the official source of truth for what is covered.

API feature	HIPAA-eligible
Messages API (`/v1/messages`)	Yes
Token counting	Yes
Web search	Yes (dynamic filtering not eligible)
Prompt caching, structured outputs, extended/adaptive thinking, citations, 1M context, PDF (inline), data residency, effort, fast mode, bash & text-editor tools, memory tool	Yes
Web fetch, computer use, advisor tool, context management (compaction / editing), tool search, cache diagnostics	No
Code execution, programmatic tool calling	No
Batch API, Files API, Agent Skills, MCP connector, Claude Managed Agents, MCP tunnels	No

PHI must appear only in message content, attached files, or related file names/metadata â€” never in JSON schema definitions (property names, enum/const values, or pattern regexes), because compiled schemas are cached separately and do not receive the same PHI protections. Anthropic notes workspace names, user contact details, billing data, and support tickets are not expected to contain PHI under the BAA.

Data retention (commercial default)

Under Anthropic’s commercial data retention policy, conversation content is not retained by default for the API, and API inputs and outputs are automatically deleted on the backend within 30 days of receipt or generation. For interface products such as Claude for Work, data persists until you delete it, after which it is removed from backend storage within 30 days. Two exceptions extend retention regardless of arrangement.

Data type / event	Retention
API inputs and outputs (default)	Auto-deleted within 30 days
Deleted conversation content (Claude for Work)	Removed from backend within 30 days
Inputs/outputs for a chat flagged as a Usage Policy violation	Up to 2 years
Trust & safety classification scores (flagged chat)	Up to 7 years
Data tied to feedback you submit (thumbs up/down, bug report)	5 years

Zero data retention (ZDR)

Desk with laptop, checklist notebook, and billing card ready before creating an Anthropic API key — Zero data retention (ZDR).

With a ZDR arrangement, customer data is not stored at rest after the API response is returned, except where needed to comply with law or combat misuse. ZDR is requested through Anthropic sales and enabled per organization â€” it does not carry over automatically to new organizations under the same account. Even under ZDR, Anthropic retains User Safety classifier results, and may retain inputs and outputs for up to 2 years if a chat or session is flagged for a Usage Policy violation. CORS is not supported for ZDR organizations, so browser apps must call through a backend proxy.

Surface	ZDR coverage
Claude Messages API & Token Counting API	Eligible
Claude Code (Commercial org API keys, or via Claude Enterprise with ZDR enabled)	Eligible
Console and Workbench	Not eligible
Claude Teams & Claude Enterprise interfaces	Not eligible (except Claude Code via Enterprise with ZDR on)
Claude Free, Pro, Max	Not eligible
Claude Managed Agents	Not eligible (stateful; delete transcripts manually)
Batch API, Files API, code execution, Agent Skills, MCP connector	Not eligible
Third-party integrations	Not eligible

A handful of ZDR-eligible features are marked “Yes (qualified)” â€” structured outputs and cache diagnostics â€” meaning Anthropic retains a narrow, documented set of technical data (for example, a cached JSON schema for up to 24 hours since last use) rather than your prompts or Claude’s outputs.

Model-training policy and Covered Models

Anthropic’s Privacy Policy states it does not apply to content processed on behalf of business customers; that data is governed by the customer agreement. For the API specifically, Anthropic states retained data is never used for model training without your express permission. Anthropic’s consumer-terms update confirms the data-use changes “do not apply to services under our Commercial Terms,” including Claude for Work, Claude for Government, Claude for Education, and API use (including via Amazon Bedrock and Google Cloud’s Vertex AI). Training on commercial data happens only if a customer explicitly opts in (for example, the Development Partner Program).

One model-specific exception affects retention, not training: Claude Fable 5 and Claude Mythos 5 are designated Covered Models and require 30-day data retention. ZDR is not available for these two models; a request to either from an organization whose retention configuration doesn’t meet the requirement returns a 400 invalid_request_error. Organizations with ZDR can turn on 30-day retention for a single workspace (Console > Settings > Workspaces > Privacy controls) to use those models there while keeping ZDR elsewhere. On Bedrock, Vertex AI, and Microsoft Foundry, retention requirements for these models are set by each platform.

GDPR, data residency, and international transfers

For users in the EEA, UK, or Switzerland, the data controller is Anthropic Ireland, Limited; elsewhere it is Anthropic PBC. Where the EU or UK GDPR applies, Anthropic responds to verifiable data-subject requests within one calendar month. For transfers to countries without an adequacy decision, Anthropic relies on standard contractual clauses, and publishes its subprocessors at anthropic.com/subprocessors.

On data residency, the Claude API exposes two independent controls. inference_geo sets where inference runs per request â€” values are "global" (default) or "us" â€” and is supported on Claude Opus 4.6, Sonnet 4.6, and later (older models return a 400). Workspace geo controls where data is stored at rest and where endpoint processing happens; it is set at workspace creation and cannot be changed afterward. Per Anthropic’s documentation, "us" is currently the only available workspace geo, and only "us" and "global" inference geos are available â€” so there is currently no EU-resident storage option at the workspace level. US-only inference is priced at 1.1x the standard rate on supported models. Data residency is available on the Claude API (first-party) and Claude Platform on AWS; on Bedrock and Vertex AI the region is set by the endpoint or inference profile.

Does Anthropic train its models on my API or commercial data?

No, not by default. Anthropic’s Privacy Policy excludes business-customer content (governed by your customer agreement), and for the API it states retained data is never used for training without your express permission. The consumer data-use changes explicitly do not apply to Commercial Terms services. Training on commercial data requires an explicit opt-in.

Will Anthropic sign a BAA, and for what?

Yes. Anthropic signs a BAA covering HIPAA-ready services such as the first-party API and Enterprise plans. The Messages API is covered as an Eligible Service. It does not cover Workbench/Console, Free/Pro/Max/Team, Cowork, Claude Code, or beta features unless explicitly listed. An admin must sign the BAA and enable HIPAA readiness; the organization then auto-blocks non-eligible features.

What’s the difference between ZDR and HIPAA readiness?

Per Anthropic, ZDR prevents customer data from being stored at rest after the API response. HIPAA readiness is a broader set of safeguards (encryption, access controls, audit logging) that protect PHI throughout its lifecycle and lets data be retained with safeguards rather than deleted immediately. Anthropic states you do not also need ZDR if you have HIPAA readiness.

How long does Anthropic keep my data?

By default, API inputs and outputs are auto-deleted within 30 days. If a chat is flagged as a Usage Policy violation, inputs/outputs may be retained up to 2 years and trust & safety classification scores up to 7 years. Data tied to feedback you submit is kept 5 years. ZDR removes the default at-rest storage but does not remove the law/misuse exceptions.

Can I keep Claude inference and data in the EU?

Not at rest currently. The API’s inference_geo can pin inference to "us" or run "global", but Anthropic’s documentation lists "us" as the only available workspace geo (storage region). EU/UK data-subject rights and standard contractual clauses apply regardless, but an EU storage-residency option is not currently offered at the workspace level per the docs verified here.

Related on Tygart Media: is Claude safe · Anthropic safety.

June 13, 2026

Claude Agent SDK Migration: Package Renames an (2026)

Last verified: June 13, 2026

The Claude Code SDK has been renamed to the Claude Agent SDK. Migrating is three mechanical edits plus two behavioral changes you have to opt back into: rename the package, rename the imports, rename ClaudeCodeOptions to ClaudeAgentOptions, then decide whether you want the old Claude Code system prompt and filesystem settings back. The breaking changes landed in v0.1.0. Everything below is taken from Anthropic’s official Agent SDK migration guide and the live package registries, verified June 13, 2026.

The renames at a glance

Side-by-side when to use a script versus an agent — The Agent SDK renames at a glance.

Two packages and one Python type changed names. The documentation also moved out of the Claude Code docs into the API Guide’s Agent SDK section.

Aspect	Old	New
Package (TS/JS)	`@anthropic-ai/claude-code`	`@anthropic-ai/claude-agent-sdk`
Package (Python)	`claude-code-sdk`	`claude-agent-sdk`
Python import	`claude_code_sdk`	`claude_agent_sdk`
Python options type	`ClaudeCodeOptions`	`ClaudeAgentOptions`
Docs location	Claude Code docs	API Guide â†’ Agent SDK

Current published versions

These are the latest versions on the public registries as fetched on June 13, 2026. The migration guide itself uses ^0.0.42 as the example old TypeScript version and ^0.2.0 as the example new one; pin to whatever is current when you install.

Registry	Package	Latest version
npm	`@anthropic-ai/claude-agent-sdk`	`0.3.177`
PyPI	`claude-agent-sdk`	`0.2.101`

TypeScript migration

Side-by-side cards defining what Claude Code is and is not — TypeScript migration path.

Swap the package, then update every import. The exported names (query, tool, createSdkMcpServer) are unchanged â€” only the module specifier moves.

npm uninstall @anthropic-ai/claude-code
npm install @anthropic-ai/claude-agent-sdk

// Before
import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-code";

// After
import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";

Update package.json as well, replacing the dependency key from @anthropic-ai/claude-code to @anthropic-ai/claude-agent-sdk.

Python migration

Five stacked panels of daily Claude Code command habits — Python migration path.

Swap the package, update the import path, and rename the options type. The import name changes from underscore-claude_code_sdk to underscore-claude_agent_sdk.

pip uninstall claude-code-sdk
pip install claude-agent-sdk

# Before (claude-code-sdk)
from claude_code_sdk import query, ClaudeCodeOptions

options = ClaudeCodeOptions(model="claude-opus-4-7", permission_mode="acceptEdits")

# After (claude-agent-sdk)
from claude_agent_sdk import query, ClaudeAgentOptions

options = ClaudeAgentOptions(model="claude-opus-4-7", permission_mode="acceptEdits")

The rename is the only change to the type â€” its fields and constructor signature are otherwise the same. Per Anthropic, the new name matches the “Claude Agent SDK” branding.

Breaking change: the system prompt is no longer default

This is the change most likely to silently alter your agent’s behavior. In v0.0.x, the SDK used Claude Code’s system prompt by default. As of v0.1.0, query() uses a minimal system prompt instead. To get the old behavior, explicitly request the claude_code preset.

Goal	systemPrompt value
Restore Claude Code’s prompt	`{ type: "preset", preset: "claude_code" }`
Use your own instructions	a plain string
Minimal prompt (new default)	omit the option

// TypeScript â€” restore the old default
const result = query({
  prompt: "Hello",
  options: {
    systemPrompt: { type: "preset", preset: "claude_code" }
  }
});

// Or a custom system prompt:
const custom = query({
  prompt: "Hello",
  options: { systemPrompt: "You are a helpful coding assistant" }
});

# Python â€” restore the old default
from claude_agent_sdk import query, ClaudeAgentOptions

async for message in query(
    prompt="Hello",
    options=ClaudeAgentOptions(
        system_prompt={"type": "preset", "preset": "claude_code"}
    ),
):
    print(message)

# Or a custom system prompt:
async for message in query(
    prompt="Hello",
    options=ClaudeAgentOptions(system_prompt="You are a helpful coding assistant"),
):
    print(message)

settingSources: changed, then reverted

This one is widely mis-reported, so read it carefully. v0.1.0 briefly defaulted to loading no filesystem settings â€” and that default was reverted in subsequent releases. Anthropic’s current guidance is that no migration action is needed for setting sources.

Current behavior: omitting settingSources on query() loads user, project, and local filesystem settings, matching the CLI â€” equivalent to ["user", "project", "local"]. That includes ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, CLAUDE.md files, and custom commands. The accepted values are below.

Source	Loads from
`"user"`	`~/.claude/` â€” user CLAUDE.md, rules, skills, settings
`"project"`	`<cwd>/.claude/` â€” project CLAUDE.md, rules, skills, hooks, `settings.json`
`"local"`	CLAUDE.local.md and `.claude/settings.local.json`

To run isolated from filesystem settings, pass an empty array. This matters for CI/CD, deployed apps, test environments, and multi-tenant systems where local customizations should not leak in.

// TypeScript â€” no filesystem settings
const isolated = query({
  prompt: "Hello",
  options: { settingSources: [] }
});

// Only project settings
const projectOnly = query({
  prompt: "Hello",
  options: { settingSources: ["project"] }
});

# Python â€” no filesystem settings
from claude_agent_sdk import query, ClaudeAgentOptions

async for message in query(
    prompt="Hello",
    options=ClaudeAgentOptions(setting_sources=[]),
):
    print(message)

Two caveats Anthropic documents explicitly. First, Python SDK 0.1.59 and earlier treated an empty list the same as omitting the option â€” upgrade before relying on setting_sources=[]. Second, some inputs are read regardless of settingSources: managed policy settings, the global ~/.claude.json config, auto-memory, and claude.ai MCP connectors. For true multi-tenant isolation, the docs recommend running each tenant in its own filesystem and setting settingSources: [] plus CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

The full checklist

Work top to bottom; the first three are required, the last two are behavioral decisions.

Step	Action
1	Uninstall old package, install `@anthropic-ai/claude-agent-sdk` / `claude-agent-sdk`
2	Update all imports to the new module / package name
3	Python only: rename `ClaudeCodeOptions` â†’ `ClaudeAgentOptions`
4	If you relied on Claude Code’s prompt, set `systemPrompt` to the `claude_code` preset
5	Decide on `settingSources`: omit for CLI parity, or `[]` to isolate

Do I have to change settingSources when I migrate?

No. Anthropic states no migration action is needed for setting sources. The v0.1.0 change to “load nothing by default” was reverted; omitting settingSources again loads user, project, and local settings, matching the CLI.

What is the new default system prompt?

A minimal system prompt. Before v0.1.0 the SDK inherited Claude Code’s full system prompt by default. To restore it, pass systemPrompt as { type: "preset", preset: "claude_code" } (TypeScript) or system_prompt={"type": "preset", "preset": "claude_code"} (Python).

Did the exported function names change in TypeScript?

No. query, tool, and createSdkMcpServer are unchanged. Only the import path moves from @anthropic-ai/claude-code to @anthropic-ai/claude-agent-sdk.

Which version introduced the breaking changes?

Claude Agent SDK v0.1.0, introduced “to improve isolation and explicit configuration,” per the official guide. The latest published versions as of June 13, 2026 are 0.3.177 on npm and 0.2.101 on PyPI.

Does settingSources: [] fully isolate my agent?

Not by itself. Managed policy settings, the global ~/.claude.json config, auto-memory, and claude.ai MCP connectors are read regardless. For multi-tenant isolation, also run each tenant in its own filesystem and set CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

Related on Tygart Media: Claude Code getting started · Cowork vs Code vs Agent SDK · model migration.

June 13, 2026

Claude vs GPT-5 vs Gemini: 2026 Coding Benchmarks

Last verified: June 13, 2026

As of June 13, 2026, the four models most often compared for coding work are Claude Fable 5 and Claude Opus 4.8 from Anthropic, GPT-5.5 from OpenAI, and Gemini 3.1 Pro from Google. This page is a leaderboard built on one rule: every score below is taken from a vendor’s own page or the benchmark’s official model card that we fetched on the verification date, or it is marked as not published. Several vendors publish their benchmark tables as images rather than machine-readable text; where we could not read an official figure directly, we list the metric as not machine-verifiable and link to the source document instead of estimating. The result is a smaller table than most roundups, but every number in it is one you can click through and check.

Models and pricing (verified specs)

Three cards: coding depth, latency first, agent reliability — Models compared — verified specs without sticky dollars.

These columns are confirmed from each vendor’s official model documentation. Claude prices, context windows, and cutoffs come from Anthropic’s models overview and the AWS Bedrock model card; GPT-5.5 from OpenAI’s developer docs; Gemini 3.1 Pro from Google’s DeepMind model card and the Gemini API pricing page.

Model	API ID	Input / Output (per Mtok)	Context	Max output	Knowledge cutoff
Claude Fable 5	`claude-fable-5`	$10 / $50	1M	128K	Not stated on overview*
Claude Opus 4.8	`claude-opus-4-8`	$5 / $25	1M	128K	Jan 2026
GPT-5.5	`gpt-5.5`	$5 / $30	1,050,000	128K	Dec 1, 2025
Gemini 3.1 Pro	`gemini-3.1-pro-preview`	$2 / $12 (â‰¤200K)**	1M	64K	Not stated on model card

*Anthropic’s models overview lists Fable 5’s specs and price but does not publish a knowledge-cutoff date for it in the table we fetched. **Gemini 3.1 Pro uses tiered pricing: $2 / $12 per Mtok for prompts up to 200K tokens, rising to $4 / $18 for prompts above 200K tokens (Google AI pricing page). GPT-5.5 pricing rises to 2x input / 1.5x output above 272K input tokens (OpenAI developer docs). Claude Opus 4.8 offers an optional fast mode at $10 / $50 per Mtok (Anthropic).

Coding benchmark scores (primary-source only)

Three abstract product cards on a desk comparing Claude with other chat API offerings — Coding benchmark scores — primary-source only.

Each cell is either a figure we read directly from a primary source on June 13, 2026, or marked “not machine-verifiable” with the source you should consult. A blank-equivalent entry never means zero â€” it means the official figure was not available in readable form during verification. Note the harness and version differences called out in the footnotes: they make cross-vendor cells not strictly comparable.

Benchmark	Claude Fable 5	Claude Opus 4.8	GPT-5.5	Gemini 3.1 Pro
SWE-bench Verified	Not machine-verifiable (see system card)	Not machine-verifiable (see system card)	Not published in retrievable primary source	80.6%
SWE-bench Pro (Public)	Not machine-verifiable (see system card)	Not machine-verifiable (see system card)	Not published in retrievable primary source	54.2%
Terminal-Bench	Not machine-verifiable (see system card)	Not machine-verifiable (see system card)	83.4% (v2.1, Codex CLI harness)â€	68.5% (v2.0, Terminus-2 harness)
LiveCodeBench Pro	Not published in retrievable primary source	Not published in retrievable primary source	Not published in retrievable primary source	2887 Elo

â€ GPT-5.5’s Terminal-Bench 2.1 figure of 83.4% is the score Anthropic attributes to GPT-5.5 “with the Codex CLI harness” in a footnote on its Claude Opus 4.8 announcement page. It is a competitor-reported comparison, not a number we read from OpenAI directly. Google reports Gemini 3.1 Pro on Terminal-Bench 2.0 under the Terminus-2 harness (68.5%); because the version and harness differ, the Gemini and GPT-5.5 Terminal-Bench cells are not directly comparable. Gemini’s SWE-bench Verified (80.6%), SWE-bench Pro Public (54.2%), and LiveCodeBench Pro (2887 Elo) are single-attempt figures from Google’s official Gemini 3.1 Pro model card.

What we could not verify from a primary source

Anthropic publishes its coding comparison tables for Claude Opus 4.8 and Claude Fable 5 as images inside its announcement pages, and the full Claude Opus 4.8 System Card PDF exceeded our fetch size limit, so we could not machine-read those percentages on the verification date. OpenAI’s GPT-5.5 announcement page returned an access error to our fetcher, and its developer-docs model page lists specs and pricing but no benchmark scores. We have therefore left Claude’s and GPT-5.5’s SWE-bench figures out of the table rather than reproduce numbers we could not confirm at the source. For those figures, consult the primary documents linked in our source list: the Claude Opus 4.8 System Card, the Claude Fable 5 and Mythos 5 announcement, and OpenAI’s GPT-5.5 page. If you are choosing a model today, the verified spec table above (price, context, output, cutoff) is the part you can rely on without caveat.

How to read a coding leaderboard

Three cards for fast volume, daily workhorse, and deep flagship Claude seats — How to read a coding leaderboard.

Three cautions apply to any 2026 coding comparison. First, harness matters: the same model scores differently on Terminal-Bench depending on whether it runs under Terminus-2, a Codex CLI scaffold, or a vendor’s internal agent, which is why we annotate every Terminal-Bench cell. Second, version matters: “Terminal-Bench 2.0” and “Terminal-Bench 2.1” are different test sets, and “SWE-bench Pro” public and full splits differ â€” a single percentage with no version is close to meaningless. Third, a headline score is one slice of behavior; long-horizon agentic coding, tool-call reliability, and context handling over a long session often decide real-world usefulness more than a single pass rate. Treat the verified cells here as a starting point, then test the shortlist on your own repository.

Which model has the highest published coding benchmark score in June 2026?

We cannot crown a single winner from primary sources alone, because Anthropic and OpenAI publish their coding scores in formats we could not machine-verify on June 13, 2026. From figures we could read directly, Google’s Gemini 3.1 Pro model card reports 80.6% on SWE-bench Verified and 54.2% on SWE-bench Pro (Public). Anthropic’s and OpenAI’s comparable figures are in their system cards and announcement pages, which we link in the sources; we did not reproduce them here because they were not readable at the source during verification.

What does Claude Fable 5 cost, and how is it different from Opus 4.8?

Claude Fable 5 (claude-fable-5) is priced at $10 per million input tokens and $50 per million output tokens, with a 1M-token context window and up to 128K output tokens (Anthropic models overview). Claude Opus 4.8 (claude-opus-4-8) is the Opus-tier flagship at $5 / $25 per Mtok, also 1M context and 128K output, with a January 2026 knowledge cutoff. Fable 5 is Anthropic’s most capable widely released model; Opus 4.8 is the lower-priced model most teams will use for everyday agentic coding.

Why are some benchmark cells marked “not machine-verifiable” instead of showing a number?

Because this page only prints scores we could confirm from a primary source on the verification date. Several vendors render their benchmark tables as images, and one large system-card PDF exceeded our fetch limit, so the underlying percentages were not readable to us. Rather than copy figures from third-party trackers, we mark the cell and point you to the official document. It keeps the leaderboard honest at the cost of being shorter.

How do the context windows compare?

Claude Fable 5, Claude Opus 4.8, and Gemini 3.1 Pro each offer a 1M-token context window; GPT-5.5 offers 1,050,000 tokens. Maximum output is 128K tokens for Claude Fable 5, Claude Opus 4.8, and GPT-5.5, and 64K tokens for Gemini 3.1 Pro. Note that Claude Opus 4.8’s context window is 200K on Microsoft Foundry specifically, per Anthropic’s documentation.

Is Terminal-Bench comparable across these models?

Not cell-for-cell. Google reports Gemini 3.1 Pro on Terminal-Bench 2.0 under the Terminus-2 harness (68.5%), while the GPT-5.5 figure we show (83.4%) is Terminal-Bench 2.1 under a Codex CLI harness, as attributed by Anthropic. Different versions and different harnesses mean the two numbers should not be read as a head-to-head result.

Related on Tygart Media: Claude Code vs Cursor · Claude Code vs Codex.

June 13, 2026

Claude Skills vs MCP vs Connectors vs Plugins (2026)

Last verified: June 13, 2026

The simplest way to keep these straight: Skills teach Claude how to do a task, MCP servers and Connectors give Claude access to external systems, Plugins bundle several of these together, and Hooks and slash commands control a Claude Code session. A Skill is a folder of instructions Claude reads when relevant. MCP (the Model Context Protocol) is an open standard that connects Claude to your tools and data. A Connector is Anthropic’s packaging of a remote MCP server inside the Claude apps. A Plugin packages any combination of commands, agents, MCP servers, hooks, and skills for Claude Code. Every definition below is taken verbatim from Anthropic’s official documentation, fetched on the verification date.

The one-glance comparison

Four comparison cards for Claude skills, MCP, connectors, and plugins — One-glance comparison of the four extension surfaces.

This is the liftable summary. Each row is one mechanism; the third column is the distinction people most often get wrong — whether the thing teaches Claude how to do something or gives Claude access to something.

Type	What it is	Teaches-HOW or gives-ACCESS	Where it runs	How you install / enable it
Skill	A modular capability that packages instructions, metadata, and optional resources (scripts, templates) in a `SKILL.md` file that Claude uses automatically when relevant.	Teaches HOW. Provides domain-specific expertise: workflows, context, and best practices (procedural knowledge).	In Claude’s code execution environment / VM, where Claude has filesystem access, bash, and code execution.	claude.ai: upload a zip under Settings > Features. API: upload via the Skills API (`/v1/skills`) with the required beta headers (`code-execution-2025-08-25`, `skills-2025-10-02`, `files-api-2025-04-14`). Claude Code: a `SKILL.md` directory under `~/.claude/skills/` or `.claude/skills/`.
MCP server	An implementation of the Model Context Protocol — “an open-source standard for connecting AI applications to external systems.” Described as “a USB-C port for AI applications.”	Gives ACCESS. Connects Claude to data sources, tools, and workflows so it can access information and perform tasks.	Local (stdio) servers run as processes on your machine; remote servers run over HTTP (recommended) or SSE (deprecated).	In Claude Code: `claude mcp add`, at local, project, or user scope. Also configurable in `.mcp.json` or imported from Claude Desktop / claude.ai.
Connector	A feature that “let[s] Claude access your apps and services, retrieve your data, and take actions within connected services.” Custom connectors use remote MCP.	Gives ACCESS. Same access role as MCP — a Connector is the in-app packaging of a remote MCP server.	Custom connectors are reached from Anthropic’s cloud infrastructure, not from your local machine.	In the Claude apps under Customize > Connectors (or the in-chat “+” menu). Add a directory connector, or “Add custom connector” by URL.
Plugin	“A lightweight way to package and share any combination of” Claude Code customizations.	Both — it’s a container. Bundles things that teach HOW (commands, skills) and things that give ACCESS (MCP servers), plus hooks and subagents.	In Claude Code — “they’ll work across your terminal and VS Code.”	The `/plugin` command (public beta). For a marketplace: `/plugin marketplace add user-or-org/repo-name`, then install from the `/plugin` menu.
Hook	“User-defined shell commands, HTTP endpoints, or LLM prompts that execute automatically at specific points in Claude Code’s lifecycle.”	Controls behavior. Provides deterministic control rather than relying on the LLM to decide.	In Claude Code, firing at lifecycle events (e.g. `PreToolUse`, `PostToolUse`, `UserPromptSubmit`, `SessionStart`, `Stop`).	Configured in JSON settings files such as `~/.claude/settings.json` or `.claude/settings.json`, or bundled in a plugin.
Slash command	A command starting with `/` that controls a Claude Code session. Includes built-ins (e.g. `/help`, `/compact`) and custom commands.	Teaches HOW (custom) / controls session (built-in). Custom commands have been merged into Skills.	In the Claude Code session (terminal or VS Code).	Built-ins ship with Claude Code. Custom: a Markdown file under `.claude/commands/` (project) or `~/.claude/commands/` (personal); a `.claude/skills/<name>/SKILL.md` does the same.

Skills: teaching Claude a procedure

An Agent Skill is “a directory containing a SKILL.md file” with YAML frontmatter plus instructions, and optionally additional markdown files, executable scripts, and reference resources. The point is procedural knowledge — it turns “general-purpose agents into specialists” by giving Claude the workflows and best practices for a task, the way you’d write an onboarding guide for a new teammate. Anthropic ships pre-built Skills for PowerPoint, Excel, Word, and PDF, and you can author your own.

What makes Skills cheap to install in bulk is progressive disclosure: Claude loads information in stages instead of all at once. The numbers below come straight from Anthropic’s Skills overview.

Loading level	When loaded	Token cost (per Anthropic docs)	Content
Level 1: Metadata	Always, at startup	~100 tokens per Skill	`name` and `description` from the YAML frontmatter
Level 2: Instructions	When the Skill is triggered	Under 5k tokens	The `SKILL.md` body — workflows and guidance
Level 3+: Resources	As needed	Effectively unlimited	Bundled files read or executed via bash without loading their contents into context

The name field is capped at 64 characters (lowercase letters, numbers, hyphens; it cannot contain the reserved words “anthropic” or “claude”), and the description is capped at 1,024 characters. One important constraint: custom Skills do not sync across surfaces — a Skill uploaded to claude.ai is not automatically available via the API, and Claude Code Skills are filesystem-based and separate from both.

MCP: the open standard for access

Flow from app/IDE through MCP to servers and data APIs — MCP: the open standard for access.

The Model Context Protocol is, in Anthropic’s words, “an open-source standard for connecting AI applications to external systems.” The canonical analogy: “Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.” Using MCP, “AI applications like Claude or ChatGPT can connect to data sources (e.g. local files, databases), tools (e.g. search engines, calculators) and workflows (e.g. specialized prompts).”

An MCP server can expose three kinds of building block — tools, resources, and prompts. In Claude Code, resources are referenced with @server:protocol://resource/path and prompts surface as commands in the form /mcp__servername__promptname. You connect a server with claude mcp add, choosing a transport and a scope:

Scope	Loads in	Shared with team	Stored in
Local (default)	Current project only	No	`~/.claude.json`
Project	Current project only	Yes, via version control	`.mcp.json` in project root
User	All your projects	No	`~/.claude.json`

For transports, HTTP is “the recommended option for connecting to remote MCP servers,” local stdio servers “run as local processes on your machine,” and SSE is explicitly marked deprecated in favor of HTTP.

Connectors: MCP, packaged for the apps

A Connector is how the Claude apps surface MCP. Per Anthropic’s help center, “Connectors let Claude access your apps and services, retrieve your data, and take actions within connected services,” and “Custom connectors using remote MCP are available on Claude, Cowork, and Claude Desktop.” So a Connector is not a different technology from MCP — a custom connector is a remote MCP server wired into the Claude UI.

The most consequential detail is where the connection originates: “Custom connectors (remote MCP servers) are reached from Anthropic’s cloud infrastructure, not from your local machine.” That means a custom-connector MCP server must be reachable over the public internet — one hosted only on a private network, behind a VPN, or blocked by a firewall will not connect even if you can reach it yourself.

Aspect	Directory (pre-built) connector	Custom connector
Source	Pre-built integrations in the Connectors Directory	Added by you via a remote MCP server URL
Plan availability	Available across Claude plans	Free, Pro, Max, Team, and Enterprise
Free-plan limit	Per directory	“Free users are limited to one custom connector.”
Where to add it	Customize > Connectors, or the in-chat “+” > Connectors > Manage connectors

Plugins: a bundle, not a single thing

A Plugin is “a lightweight way to package and share any combination of” Claude Code customizations. The official announcement lists four bundle components, and the Claude Code documentation adds skills as a fifth thing a plugin can carry:

Component	What it adds
Slash commands	Custom shortcuts for frequently-used operations
Subagents	Purpose-built agents for specialized development tasks
MCP servers	Connections to tools and data sources through MCP
Hooks	Customizations of Claude Code’s behavior at key workflow points
Skills	Per the Claude Code docs, a plugin can include a `skills/` directory; plugin skills use a `plugin-name:skill-name` namespace

You install a plugin “directly within Claude Code using the /plugin command.” To pull from a marketplace — “curated collections where other developers can discover and install plugins” — you run /plugin marketplace add user-or-org/repo-name and then install from the /plugin menu. Plugins “work across your terminal and VS Code.” Plugins were announced on October 9, 2025, as a public beta for all Claude Code users.

Hooks and slash commands: controlling the session

The last two mechanisms aren’t about adding capability — they’re about controlling a Claude Code session. Hooks are “user-defined shell commands, HTTP endpoints, or LLM prompts that execute automatically at specific points in Claude Code’s lifecycle.” Their defining property is determinism: they provide deterministic control rather than relying on the LLM to make decisions. A PreToolUse hook can, for example, block a destructive rm -rf command regardless of what Claude intended. Hooks are configured in JSON settings files (such as ~/.claude/settings.json or a project’s .claude/settings.json) and fire at events including SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop.

Slash commands start with / and control the session. Built-in commands like /help and /compact ship with Claude Code. Custom commands are Markdown files — a project command lives at .claude/commands/<name>.md and a personal one at ~/.claude/commands/<name>.md, with the file name becoming the command. As of the 2026 Claude Code docs, custom commands have been merged into Skills: a file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md “both create /deploy and work the same way,” and existing .claude/commands/ files keep working.

Is a Connector the same as an MCP server?

Effectively yes, for custom connectors. Anthropic states “Custom connectors using remote MCP are available on Claude, Cowork, and Claude Desktop,” and that they “are reached from Anthropic’s cloud infrastructure.” A Connector is the Claude-app packaging of a remote MCP server; MCP is the underlying open standard.

What’s the difference between a Skill and an MCP server?

A Skill teaches Claude how to do a task — it “provide[s] Claude with domain-specific expertise: workflows, context, and best practices.” An MCP server gives Claude access to external systems — it connects Claude “to data sources, tools and workflows.” One is procedural knowledge; the other is a connection.

Do Skills cost a lot of context tokens?

Not until used. Per Anthropic’s docs, Level 1 metadata costs about 100 tokens per Skill and is always loaded; the full SKILL.md body (under 5k tokens) only loads when the Skill is triggered; and bundled resources are read on demand with effectively no upfront cost. This is the “progressive disclosure” design.

What can a Claude Code plugin contain?

“Any combination of” slash commands, subagents, MCP servers, and hooks, per the announcement; the Claude Code documentation adds that a plugin can also bundle a skills/ directory. You install one with the /plugin command, optionally from a marketplace added via /plugin marketplace add.

Are custom slash commands still a thing?

They still work, but they’ve been folded into Skills. The Claude Code docs state custom commands “have been merged into skills,” that existing .claude/commands/ files keep working, and that a command file and an equivalent SKILL.md both produce the same / command. Skills add optional extras like supporting files and automatic invocation.

Related on Tygart Media: what is MCP · Claude MCP guide.

June 13, 2026

Migrating Off Retired Claude Models: The Breaking-Chang (2026)

Last verified: June 13, 2026

Claude Opus 4 (claude-opus-4-20250514) and Claude Sonnet 4 (claude-sonnet-4-20250514) are deprecated and retire on June 15, 2026, after which requests to them return a 404. The official replacements are claude-opus-4-8 and claude-sonnet-4-6. But swapping the model string alone will break a working integration: depending on which target you choose, several request parameters that were valid on the May 2025 models now return a 400 error, and two changes alter behavior silently. This page maps each removed or changed parameter to the exact failure and the fix.

One distinction governs the whole migration. The Opus path (to claude-opus-4-8) is the strict one: it removes temperature/top_p/top_k and manual thinking budgets entirely. The Sonnet path (to claude-sonnet-4-6) is gentler: it keeps sampling parameters (with the older “one of temperature or top_p, not both” rule) and still accepts budget_tokens as deprecated-but-functional. The one rule both paths share: assistant-turn prefills now return 400.

The breaking-change matrix

Side-by-side panels contrasting old model IDs still in code with a migrate checklist — The breaking-change matrix.

Each row is a change that breaks on at least one migration target. “Error” means the API rejects the request server-side (HTTP 400) even though the SDK request type still type-checks. “Silent” means no error — the behavior simply differs.

Change	On Opus 4.8	On Sonnet 4.6	Symptom	Fix
`thinking: {type:"enabled", budget_tokens:N}`	400 error (removed)	Deprecated, still works	400 on Opus; cost/latency drift on Sonnet	`thinking: {type:"adaptive"}` + `output_config.effort`
`temperature` / `top_p` / `top_k`	400 error (removed)	Keep only one of `temperature` or `top_p`	400 on Opus if any set; 400 on Sonnet if both set	Remove on Opus; steer via prompt. Keep one on Sonnet
Assistant-turn prefill (last message `role:"assistant"`)	400 error	400 error	Request rejected on both	`output_config.format` (structured outputs) or system-prompt instruction
`thinking.display` default	Defaults to `"omitted"`	Returns summarized text	Reasoning text empty on Opus (silent)	Set `display: "summarized"` on Opus
Tokenizer	New tokenizer (more tokens)	Unchanged tokenizer	Same text counts higher on Opus; `max_tokens` too tight	Re-baseline with `count_tokens`; add headroom
`output_format` (top-level)	Deprecated API-wide	Deprecated API-wide	Works, but slated for removal	Move to `output_config: {format: {...}}`

Model ID swaps and retirement dates

Flow from Family to Seat to Generation to API id — Model ID swaps and retirement dates.

Retiring model	Model ID	Retires	Replacement
Claude Opus 4	`claude-opus-4-20250514` (alias `claude-opus-4-0`)	June 15, 2026	`claude-opus-4-8`
Claude Sonnet 4	`claude-sonnet-4-20250514` (alias `claude-sonnet-4-0`)	June 15, 2026	`claude-sonnet-4-6`

These are the original May 2025 models, not the later Opus 4.6 or Sonnet 4.5 releases. Use the exact replacement strings above — do not append a date suffix to claude-opus-4-8 or claude-sonnet-4-6 (they are dateless pinned snapshots).

budget_tokens to adaptive thinking

The Opus path removes the fixed thinking budget. thinking: {type:"enabled", budget_tokens:N} returns a 400 on claude-opus-4-8. The replacement is adaptive thinking — the model decides how much to think per request — with overall depth controlled by the effort parameter (low | medium | high | xhigh | max). There is no direct token-count equivalent; effort is an output-level control, not a thinking budget.

# Before (Claude Opus 4 / Sonnet 4)
client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    messages=[{"role": "user", "content": "..."}],
)

# After (Claude Opus 4.8)
client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # or "max", "xhigh", "medium", "low"
    messages=[{"role": "user", "content": "..."}],
)

On the Sonnet path, budget_tokens is deprecated but still functional on claude-sonnet-4-6, so it will not 400 — but you should still migrate to adaptive thinking. Note also that Sonnet 4.6 defaults to effort: "high" where Sonnet 4 had no effort parameter at all; if you do not set it explicitly you may see higher latency and token use after the swap.

Sampling parameters: removed vs. restricted

This is where the two paths diverge most. On claude-opus-4-8, setting temperature, top_p, or top_k to any non-default value returns a 400. Remove them entirely and steer behavior through prompting instead. (If you used temperature=0 for determinism, note it never guaranteed identical outputs on prior models either.)

# Opus path — sampling params 400 on claude-opus-4-8
# Before
client.messages.create(
    model="claude-opus-4-20250514",
    temperature=0.7,
    top_p=0.9,
    messages=[...],
)

# After — remove them
client.messages.create(
    model="claude-opus-4-8",
    messages=[...],
)

On claude-sonnet-4-6 the older Claude 4.x rule still applies: you may pass one of temperature or top_p, but passing both returns a 400. So a Sonnet 4 to Sonnet 4.6 move only requires dropping one of the two if you were setting both.

Assistant-turn prefills to structured outputs

Prefilling the final assistant turn — ending your messages array with a role: "assistant" message to force a response shape — returns a 400 on both claude-opus-4-8 and claude-sonnet-4-6. This is the one breaking change you cannot dodge by choosing the gentler target. The replacement depends on what the prefill was doing.

Prefill was used for	Replacement
Forcing JSON / YAML / schema output	`output_config.format` with a `json_schema`
Forcing a classification label	A tool with an `enum` field, or structured outputs
Skipping preambles (“Here is…”)	System-prompt instruction: respond directly, no preamble
Continuing an interrupted response	Move continuation into the user turn
Steering around bad refusals	Usually unnecessary now — plain user-turn prompting suffices

# Before (fails on both targets) — prefill forcing JSON shape
messages=[
    {"role": "user", "content": "Extract the name."},
    {"role": "assistant", "content": "{\"name\": \""},
]

# After — structured outputs replace the prefill
client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    output_config={"format": {"type": "json_schema", "schema": SCHEMA}},
    messages=[{"role": "user", "content": "Extract the name."}],
)

Thinking display: the silent one

On claude-opus-4-8, thinking blocks still stream, but their thinking text field is empty unless you opt in — the default is display: "omitted". There is no error; if your UI rendered the summarized reasoning, it now shows a long pause before output. Restore it by setting the display mode:

thinking = {
    "type": "adaptive",
    "display": "summarized",  # default is "omitted" on Opus 4.8/4.7
}

The block-field name is unchanged — it is still block.thinking on a thinking-type block. The fix is the request parameter, not the response-handling code. (Sonnet 4.6 is not affected by this default change.)

The new tokenizer: re-baseline max_tokens

This change is Opus-only and easy to miss because it produces no error. claude-opus-4-8 uses the tokenizer introduced with Opus 4.7, under which the same text tokenizes to roughly 1x–1.35x as many tokens — up to about 35% more, around 30% on typical content, varying by workload. Three consequences:

What to check	Why
`max_tokens` ceilings and compaction triggers	The same output now consumes more tokens; tight limits truncate mid-thought
Client-side token estimators (e.g. fixed char-to-token ratios)	Calibrated against the old tokenizer; now undercount
Cost and rate-limit dashboards	`count_tokens` returns higher numbers; re-baseline before reacting

Re-run client.messages.count_tokens(model="claude-opus-4-8", ...) on a representative sample of your prompts. Do not apply a blanket multiplier. Sonnet 4.6 keeps the older tokenizer, so a Sonnet 4 to Sonnet 4.6 move has no tokenizer re-baseline to do.

The full checklist

Step	Opus 4 to 4.8	Sonnet 4 to 4.6
Update model ID string	Required	Required
Replace `budget_tokens` with adaptive thinking	Required (400)	Recommended (deprecated)
Sampling params	Remove all (400)	Keep only one (both 400)
Remove assistant-turn prefills	Required (400)	Required (400)
Set `display: "summarized"` if showing reasoning	Required for visible thinking	Not applicable
Re-baseline `max_tokens` for new tokenizer	Required	Not applicable
Set `effort` explicitly	Defaults to `high`	Defaults to `high`
Move `output_format` to `output_config.format`	Recommended	Recommended
Verify tool inputs parsed with a JSON parser	Recommended	Recommended
Spot-check one request, then roll out	Required	Required

If you run Claude Code, /claude-api migrate applies the model swap, breaking-parameter changes, prefill replacement, and effort calibration across a codebase, then produces a verify-it-yourself checklist. It asks you to confirm scope before editing any files.

Is migrating off Claude Opus 4 really not just a model-string change?

No. Moving to claude-opus-4-8 also requires removing temperature/top_p/top_k and any budget_tokens (all now return 400), removing assistant-turn prefills (400), opting back into summarized thinking if your UI shows it, and re-baselining max_tokens for the new tokenizer. Only the Sonnet 4 to Sonnet 4.6 move is close to a drop-in — and even that requires removing prefills.

When exactly do Claude Opus 4 and Sonnet 4 stop working?

June 15, 2026. After that date, requests to claude-opus-4-20250514 and claude-sonnet-4-20250514 return a 404. These are the original May 2025 models, not Opus 4.6 or Sonnet 4.5.

What replaces budget_tokens now that it errors on Opus?

Adaptive thinking (thinking: {type:"adaptive"}) plus the effort parameter inside output_config. There is no exact token-count equivalent: the model decides how much to think per request, and effort (low through max) tunes overall depth and spend. On Sonnet 4.6, budget_tokens still works but is deprecated.

Why does the same prompt cost more tokens on Opus 4.8?

Opus 4.8 uses the tokenizer introduced with Opus 4.7, under which the same text produces roughly 1x–1.35x as many tokens (about 30% more on typical content, up to ~35%). Re-run the count_tokens endpoint against claude-opus-4-8 and give max_tokens and compaction triggers extra headroom. Sonnet 4.6 keeps the older tokenizer, so it is unaffected.

My thinking summaries disappeared after migrating to Opus — is that a bug?

No. On Opus 4.8 (and 4.7), thinking.display defaults to "omitted", so thinking blocks stream with an empty text field. Set display: "summarized" in your thinking config to restore visible reasoning. The field name is unchanged; only the default flipped.

Related on Tygart Media: Claude Fable 5 guide · API quickstart.

June 13, 2026

Claude Code Billing & Monthly Credit Pools (2026)

Last verified: June 13, 2026

Claude Code has two billing models, and which one applies depends on how you run it, not just which plan you hold. When you use Claude Code interactively in the terminal or IDE on a Pro or Max plan, it draws from the same subscription usage limits as your Claude.ai chats. But starting June 15, 2026, Anthropic separates out programmatic usage: the Claude Agent SDK, the claude -p headless command, the Claude Code GitHub Actions integration, and third-party apps that authenticate through the Agent SDK will no longer count against your interactive subscription pool. Instead they draw from a new, separate monthly Agent SDK credit, billed at standard API rates. This page documents both models, the exact credit amounts per plan, and the SDK package rename you may also need to handle.

The two billing models at a glance

Workshop fuel gauge and metal tokens pouring into an API hopper, metaphor for pay-per-token pricing — Two billing models at a glance — no sticky dollar stickers.

The dividing line is interactive vs. programmatic. One number to remember: setting an ANTHROPIC_API_KEY environment variable overrides your subscription entirely — Claude Code then authenticates with that key and bills as pay-as-you-go API usage, regardless of plan.

Usage type	How it runs	Billed against
Interactive Claude Code	Terminal or IDE, human at the keyboard	Pro/Max subscription usage limits
Claude.ai chat	Web, desktop, mobile	Pro/Max subscription usage limits
Agent SDK (Python/TypeScript)	Your own programmatic projects	Separate Agent SDK credit (from June 15, 2026)
`claude -p` (non-interactive)	Headless / scripted Claude Code	Separate Agent SDK credit (from June 15, 2026)
Claude Code GitHub Actions	CI/CD automation	Separate Agent SDK credit (from June 15, 2026)
Any usage with `ANTHROPIC_API_KEY` set	API-key auth instead of subscription	Standard API rates (pay-as-you-go)

What changes on June 15, 2026

Per Anthropic’s support documentation: “Starting June 15, 2026, Claude Agent SDK and claude -p usage no longer counts toward your Claude plan’s usage limits.” Each subscription tier instead receives a fixed monthly Agent SDK credit. When that credit runs out, additional Agent SDK usage flows to usage credits at standard API rates — but only if you have enabled usage credits. If you have not, “Agent SDK requests stop until your credit refreshes.” Unused credits do not roll over to the next billing cycle, and there is no automatic fallback to the interactive pool.

Plan	Monthly Agent SDK credit
Pro	$20
Max 5x	$100
Max 20x	$200
Team (Standard seats)	$20
Team (Premium seats)	$100
Enterprise (seat-based Premium)	$200

What stays on the interactive subscription pool, unchanged: Claude conversations on web, desktop, and mobile; and interactive Claude Code in the terminal or IDE. The change is scoped strictly to programmatic execution.

How each pool is metered and priced

Infographic with three panels: protect the service, fair share, and cost control explaining rate limits — How each pool is metered.

Claude Code “charges by API token consumption” — the underlying meter is input/output tokens, including thinking tokens billed as output. On a subscription, that token consumption is what counts against your plan limits (interactive) or your Agent SDK credit (programmatic). The Agent SDK credit and any overflow are billed at standard API list rates; the per-model API token prices below are the verified current rates.

Pool	Meter	Price basis
Interactive (Pro/Max)	Tokens, against plan usage limits	Included in subscription
Agent SDK credit	Tokens, against monthly credit	Standard API rates
Overflow past the credit	Tokens, usage credits	Standard API rates (only if usage credits enabled)
API key (`ANTHROPIC_API_KEY`)	Tokens, pay-as-you-go	Standard API rates

Verified current API token prices (per million tokens) for models commonly used in Claude Code:

Model	Model ID	Input $/Mtok	Output $/Mtok
Claude Opus 4.8	`claude-opus-4-8`	$5.00	$25.00
Claude Sonnet 4.6	`claude-sonnet-4-6`	$3.00	$15.00
Claude Haiku 4.5	`claude-haiku-4-5`	$1.00	$5.00

Subscription plan prices

These are the published Claude plan prices the Agent SDK credits attach to. The Max 5x plan starts at $100/month; the $200 figure for Max 20x is documented as the matching Agent SDK credit amount for that tier.

Plan	Price
Free	$0
Pro	$20/month, or $17/month billed annually ($200 up front)
Max 5x	From $100/month
Team (Standard seat)	$25/seat/month, or $20/seat/month billed annually

The SDK rename: claude-code-sdk to claude-agent-sdk

Separate from billing, the SDK itself was renamed. Anthropic’s migration guide states: “The Claude Code SDK has been renamed to the Claude Agent SDK.” If you have code on the old package, you must update the package name, imports, and one Python type. The headless CLI command name is unchanged — it is still claude -p.

Aspect	Old	New
npm package (TS/JS)	`@anthropic-ai/claude-code`	`@anthropic-ai/claude-agent-sdk`
Python package	`claude-code-sdk`	`claude-agent-sdk`
Python options type	`ClaudeCodeOptions`	`ClaudeAgentOptions`
Default system prompt	Claude Code’s preset	Minimal (opt back in via `preset: "claude_code"`)

# TypeScript
npm uninstall @anthropic-ai/claude-code
npm install @anthropic-ai/claude-agent-sdk

# Python
pip uninstall claude-code-sdk
pip install claude-agent-sdk

Decision: which billing path applies to your work

If you are…	Billing path
A developer coding interactively in the terminal	Subscription usage limits (unchanged)
Running `claude -p` in a script or cron job	Agent SDK credit (from June 15, 2026)
Running Claude Code in GitHub Actions	Agent SDK credit (from June 15, 2026)
Building an app on the Agent SDK with subscription auth	Agent SDK credit (from June 15, 2026)
A team or service account wanting budgets + usage reports	Set `ANTHROPIC_API_KEY` → standard API billing

Does interactive Claude Code billing change on June 15, 2026?

No. Anthropic’s documentation confirms interactive Claude Code in the terminal or IDE, and Claude conversations on web, desktop, and mobile, continue using subscription usage limits as before. Only programmatic usage — the Agent SDK, claude -p, GitHub Actions, and third-party Agent SDK apps — moves to the separate Agent SDK credit.

How much is the separate Agent SDK credit?

$20/month on Pro, $100 on Max 5x, $200 on Max 20x, $20 on Team Standard seats, $100 on Team Premium seats, and $200 on Enterprise seat-based Premium. The credit is billed at standard API rates, does not roll over, and refreshes monthly.

What happens when the Agent SDK credit runs out?

Additional Agent SDK usage flows to usage credits at standard API rates — but only if you have enabled usage credits. If you have not enabled them, Agent SDK requests stop until your credit refreshes. There is no automatic fallback to your interactive subscription pool.

How do I avoid the credit pool entirely?

Set an ANTHROPIC_API_KEY environment variable. Claude Code and the Agent SDK then authenticate with that key and bill as standard pay-as-you-go API usage, separate from any subscription. This is Anthropic’s recommended path for apps, CI jobs, service accounts, and team-owned projects that need budgets and usage reporting.

Was the Claude Code SDK renamed?

Yes. It is now the Claude Agent SDK. The npm package @anthropic-ai/claude-code became @anthropic-ai/claude-agent-sdk, the Python package claude-code-sdk became claude-agent-sdk, and the Python type ClaudeCodeOptions became ClaudeAgentOptions. The claude -p CLI command name is unchanged.

Related on Tygart Media: Claude Code getting started · Claude pricing · Pro vs Max.

June 13, 2026

I Actually Used Claude Fable 5 Before the Government Pu (2026)

Three days. That’s how long Claude Fable 5 existed in the wild before the US government killed it.

On Monday, June 9, Anthropic launched Fable 5 and Mythos 5. On Thursday, June 12, Commerce Secretary Howard Lutnick issued an export control directive ordering Anthropic to suspend access for any foreign national. Since Anthropic can’t verify nationality in real time, they shut it down for everyone. Globally. Immediately. The stated reason was a narrow jailbreak vulnerability — one Anthropic says exists in other publicly deployed models too.

I’m not writing this to debate export controls. I’m writing this because I spent those three days running Fable 5 in production — not benchmarking it, not kicking the tires, actually building with it — and I have something most people writing about this don’t have: receipts.

Day One: The Model Dropped and I Put It to Work

Day one — the model dropped and I put it to work.

Fable 5 launched June 9. By that afternoon, I had it running a Batch 8 sprint across my Tygart Media site — refreshing 10 pages of Claude content that needed updating. Fable 5 updated comparison tables, corrected model names across the lineup, added FAQPage schema, injected internal links, and expanded word counts. Post 4787 went from 750 words to 1,602. Post 9821 went from 1,782 to 2,543. Five posts refreshed with full SEO treatment — schema, FAQs, RankMath meta, silo links — in a single session.

That same day, I had Fable 5 write a complete guide to itself. Not a press release rewrite — a 2,100-word article with an interactive cost calculator, a model picker tool, and a section called “How We Actually Use Each Model” that mapped my real production workflows to each tier: Haiku for the daily 25-post SEO sweeps, Sonnet for desk articles, Opus for deep refreshes, Fable for portfolio-wide audits and strategy. The draft landed in Notion with scoped CSS and JS, ready to paste into WordPress as a single Custom HTML block.

Day Two: Fable 5 Ran My Entire SEO Audit

Day two — Fable 5 ran the SEO audit.

June 10. I ran a full SEO audit of tygartmedia.com through Fable 5. It identified that Fable 5 itself was the top content gap — a model launched 24 hours ago with zero dedicated coverage and peak search intent. So it wrote the article to fill its own gap. It drafted the piece, tagged the slug, assigned the category, and queued internal links to five existing posts.

That same day, Fable 5 wrote and published “The Signal: AI Just Split Into Two Lanes” — a 1,400-word field notes piece that wove together Fable 5’s launch, OpenAI’s S-1, Chrome WebMCP, and the emerging thesis that AI was splitting into a product lane and an infrastructure lane. The article went through the full pipeline: SEO optimization, AEO with 8 FAQ Q&As, GEO entity enrichment, Article + FAQPage schema, taxonomy assignment, internal linking, quality gate — then published via REST API. It even created the LinkedIn draft in Metricool and scheduled it for 2:30 PM Pacific.

That article exists right now at tygartmedia.com. I didn’t write it. Fable 5 did, with me directing the strategy and approving the output. The quality bar was real journalism, not AI slop.

Day Three: Building the Infrastructure Layer

June 11. While the Fable 5 Complete Guide sat in Notion waiting for a featured image, I was using Fable 5 to build the systems that would keep my content operation running. I had it update the Claude Intelligence Desk — my Notion page that serves as the authoritative source of truth for every Claude model name, API string, and price across my entire content operation. Every article gets verified against that desk before publishing. Fable 5 updated it with its own pricing: $10 input, $50 output per million tokens.

I also had Fable 5 design my Pricing Freshness Engine — a WordPress mu-plugin that shadow-checks Anthropic’s live pricing against what’s displayed on my site. The engine had been running in shadow mode since June 2, catching drift before it reaches readers. Fable 5 added itself to the canonical pricing store.

Meanwhile, my 6 scheduled email agent tasks — morning triage, midday check, afternoon wrap, newsletter extraction, weekly prep, and weekly self-audit — were running on the same Claude infrastructure, handling my inbox while I focused on building. The whole system runs on my Max plan. No extra API charges.

What Fable 5 Actually Felt Like

Here’s what the benchmarks don’t tell you: Fable 5 understood intent, not just instructions.

When I told it to run a page refresh, it didn’t just update the text — it checked model names against my Intelligence Desk, verified pricing against live documentation, added schema markup, expanded FAQs, injected internal links, and updated the dateline. It treated each task as a system, not a checklist.

When I asked it to write the Complete Guide, it included a section about how we actually use each model tier in production — because it knew from context that an article about Claude models on a site that runs on Claude models should demonstrate firsthand expertise, not just recite specs. It even built interactive JavaScript widgets inline — a cost calculator and a model picker — without being asked, because it understood the article needed to be useful, not just informative.

The gap between Fable 5 and what came before it was the largest single-model jump I’ve experienced since I started building on Claude in 2024.

What Most Commentators Are Missing

What most commentators are missing.

Most people writing about the shutdown never used Fable 5. They’re debating precedent, policy, the implications for AI regulation. All valid. But the conversation is incomplete without understanding what was actually deployed.

This is the first time the US government has aimed export controls at a deployed commercial AI model rather than at chips or hardware. That’s unprecedented. Anthropic complied but publicly disagreed, calling it a likely misunderstanding based on a narrow jailbreak that exists in other models too.

Every other Claude model — Opus, Sonnet, Haiku — remains fully available and unaffected.

What I Lost

Here’s what the government took from me specifically:

My Fable 5 Complete Guide is sitting in Notion, ready to publish, with the proxy fix queued. The pricing pages need Fable 5 rows added. The Freshness Engine needs Fable 5 in its canonical store. The WordPress proxy’s ALLOWED_DOMAINS needs a one-line gcloud update. All of it was queued up. All of it was dependent on a model that no longer exists.

The infrastructure I built this week — the Intelligence Desk, the Pricing Freshness Engine, the content pipeline that ran “The Signal” from draft to published with schema and social scheduling in a single session — all of that still works with Opus and Sonnet. But the ceiling is lower. The tasks that Fable 5 handled in one pass will take two or three with the models that remain.

What Happens Now

Anthropic says this isn’t permanent. They’re working to restore access.

For people like me who build businesses on top of these tools, the uncertainty is the real cost. Three days is long enough to build production workflows, deploy infrastructure, and write articles that reference a model’s existence — and short enough that all of it gets yanked before you can publish.

But I’m not pulling back. This week confirmed the trajectory. AI at this level isn’t a nice-to-have — it’s the infrastructure of how modern knowledge work gets done. Whether it’s Fable 5 or whatever comes after it, this capability exists now. You can’t un-ring that bell.

I know because I rang it. For three days, I built real things with a model the government decided the world shouldn’t have. And the work is still there in my Notion, waiting.

Will Tygart is the founder of Tygart Media, where he builds AI-native content operations across a portfolio of WordPress sites. He has been building production workflows on Claude since 2024. His Claude Intelligence Desk, Pricing Freshness Engine, and content pipeline systems were all built or upgraded using Claude Fable 5 during its three-day window.

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

June 13, 2026

Latest Claude Models — June 2026 (Current Lineup, Prici (2026)

Updated June 12, 2026. Fable 5 is the current top-tier model, released June 9, 2026. The full lineup: Fable 5 → Opus 4.8 → Sonnet 5 → Haiku 4.5. Pricing and availability verified against Anthropic’s official docs.

Direct Answer (August 2026): The latest available Anthropic Claude models are Claude Sonnet 4.6, Claude Opus 4.8, Claude Haiku 4.5, and Claude Fable 5. All models support 200k–1M context windows, vision multimodal inputs, structured tool calling (MCP), and server-side prompt caching.

Current Claude Models — Quick Reference

Three-column board mapping Claude model seats to flagship thinking, production workhorse, and fast volume jobs — Current Claude models — quick reference by job.

Model	API ID	Input $/MTok	Output $/MTok	Context	Best For
Claude Fable 5 🆕	`claude-fable-5`	$10.00	$50.00	1M tokens	Complex engineering, long-horizon agentic work
Claude Opus 4.8	`claude-opus-4-8`	$5.00	$25.00	1M tokens	Everyday advanced work, high-volume pipelines
Claude Sonnet 5	`claude-sonnet-5`	$3.00	$15.00	1M tokens	Balanced capability and speed
Claude Haiku 4.5	`claude-haiku-4-5-20251001`	$1.00	$5.00	200K tokens	High-speed, cost-sensitive tasks

All four models support vision, tool use/function calling, and batch processing. Fable 5 and Opus 4.8 are available on AWS Bedrock, Google Cloud Vertex AI, and Microsoft Azure AI Foundry in addition to the direct Anthropic API.

Claude Fable 5 (June 9, 2026)

Fable 5 is Anthropic’s first publicly available Mythos-class model — a capability tier previously restricted to research and select enterprise partners. It’s the most capable model Anthropic has released to date.

What makes Fable 5 different:

SWE-bench Verified: 95.0% (vs 88.6% for Opus 4.8)
SWE-bench Pro: 80.0% (vs 69.2%)
Senior Engineer benchmark: 91/100 (vs ~63/100)
Adaptive extended thinking (always on, not a mode switch)

Important limitations:

2x the cost of Opus 4.8 ($10/$50 vs $5/$25)
Mandatory 30-day data retention — not available under zero data retention (ZDR)
Safety classifiers route cybersecurity, biology, chemistry, and distillation prompts to an Opus 4.8 fallback — you pay Fable 5 rates for Opus 4.8 output in those domains
Higher latency on complex tasks (60 seconds to several minutes vs 3–15 seconds for Opus 4.8)

Free through June 22, 2026: Claude Pro, Max 5x, Max 20x, Team, and Enterprise subscription plans include Fable 5 at no extra charge during the launch window.

Claude Opus 4.8

Opus 4.8 is Anthropic’s current workhorse for serious work — the right default for most API applications and Claude Code use. It supports zero data retention (ZDR), which Fable 5 does not.

Key specs:

Context: 1M tokens
Max output: 32K tokens per request
Extended thinking: Available (opt-in mode)
ZDR: Yes
Batch API: Yes (50% discount on batch processing)

Use Opus 4.8 as your default model unless you have a specific reason to go up to Fable 5 or down to Sonnet/Haiku. It hits the best balance of capability, speed, cost, and data policy flexibility.

Claude Sonnet 5

Sonnet 5 targets use cases where response speed matters and you don’t need Opus-level reasoning. It’s the model Anthropic’s own infrastructure runs Claude.ai on for Pro subscribers doing day-to-day chat work.

Key specs:

Context: 1M tokens
Max output: 64K tokens per request
Extended thinking: Available
ZDR: Yes
Typical latency: 1–5 seconds for most tasks

Good for: content generation pipelines, customer-facing chat, document analysis at volume, anything where sub-5-second response time matters.

Claude Haiku 4.5

Haiku 4.5 is Anthropic’s fastest and cheapest model. At $1 input / $5 output per million tokens, it’s 10x cheaper than Fable 5.

Key specs:

Context: 200K tokens (smaller than the Opus/Sonnet/Fable 1M window)
Max output: 16K tokens per request
Latency: Sub-second for most tasks
ZDR: Yes

The 200K context window is the main limitation. For tasks that fit within that window — classification, short-form generation, routing, extraction — Haiku 4.5 is the cost-optimal choice. For longer documents or conversations, step up to Sonnet or Opus.

How to Choose the Right Claude Model

Pyramid diagram of Claude tiers: fast volume base, production workhorse middle, deep flagship peak — How to choose the right Claude model.

The decision framework I use:

Does the task require multi-step reasoning, complex coding, or long-horizon autonomy? → Fable 5 (if cost and latency are acceptable) or Opus 4.8
Is this a routine task at reasonable volume? → Opus 4.8 as the default
Does latency matter more than maximum reasoning depth? → Sonnet 5
Is this high-volume, short-context, cost-sensitive work? → Haiku 4.5
Does your use case require zero data retention? → Any model except Fable 5

Most production applications use a routing strategy: Fable 5 or Opus 4.8 for the hard jobs, Haiku 4.5 for classification and pre-processing, Sonnet 5 for user-facing response generation.

Claude Subscription Plans and Model Access (June 2026)

Infographic ladder of Claude plans: Free, Pro, Max, Team, and Enterprise — Subscription plans and model access — stale-proof.

Plan	Price	Models Included
Free	$0	Limited Sonnet 5 access
Pro	$20/mo ($17 annual)	Sonnet 5, Opus 4.8, Fable 5 (through June 22)
Max 5x	$100/mo	All models, 5x usage vs Pro
Max 20x	$200/mo	All models, 20x usage vs Pro
Team Standard	$20/seat/mo (annual), $25 month-to-month	All models + admin features
Team Premium	$100/seat/mo (annual), $125 month-to-month	All models + priority + advanced admin
Enterprise	$20/seat + usage at API rates (contact sales)	All models + ZDR + custom retention + SSO

Claude Code (the CLI tool) is included in all paid subscription plans. API access for building your own applications is separate — billed per token via the Anthropic Console regardless of subscription status.

Legacy Models (Still Available, No Longer Latest)

These models are still available via the API but are not Anthropic’s current recommended versions:

Claude Opus 4.7 (claude-opus-4-7) — prior Opus tier, succeeded by 4.8
Claude Opus 4.6 (claude-opus-4-6) — two generations back
Claude Sonnet 4.5 (claude-sonnet-4-5) — prior Sonnet tier
Claude 3.5 Haiku / Sonnet / Opus — Claude 3.x generation, still functional for legacy integrations

If you’re building a new application, start with the current lineup. Legacy model IDs are useful for maintaining compatibility in existing applications that haven’t been updated.

Platform Availability

Platform	Fable 5	Opus 4.8	Sonnet 5	Haiku 4.5
Anthropic API (direct)	✓	✓	✓	✓
AWS Bedrock	✓	✓	✓	✓
Google Cloud Vertex AI	✓	✓	✓	✓
Microsoft Azure AI Foundry	✓	✓	✓	✓
GitHub Copilot	✓ (via Foundry)	✓	✓	—

Frequently Asked Questions

What is the newest Claude model?
As of June 2026, Claude Fable 5 is the newest and most capable model Anthropic has released. It launched June 9, 2026. The API model ID is claude-fable-5.

Is Claude Fable 5 the same as Claude 5?
No. Anthropic changed the naming convention — there is no “Claude 5.” The Fable series is a new tier above the Opus/Sonnet/Haiku hierarchy. Fable 5 is Anthropic’s first Mythos-class model released for general availability.

What is the most powerful Claude model?
Claude Fable 5 is currently the most powerful. For tasks where Fable 5’s safety classifier routing applies (cybersecurity, biology, chemistry, distillation), or where zero data retention is required, Claude Opus 4.8 is the appropriate top-tier choice.

What Claude model does Claude.ai use by default?
Depends on your plan. Free tier uses a limited version of Sonnet. Pro and Max subscribers access Opus 4.8 as the default with Fable 5 available (through June 22, 2026 included, after that plan-dependent). Claude.ai routes to the appropriate model for your plan automatically.

How do I use the latest Claude model in the API?
Set the model parameter in your API request to the model ID. For Fable 5: "model": "claude-fable-5". For Opus 4.8: "model": "claude-opus-4-8". See the full API reference at console.anthropic.com.

What’s the difference between Claude Opus 4.8 and Fable 5?
Fable 5 is significantly stronger on complex engineering tasks — SWE-bench Pro: 80% vs 69.2%, and Senior Engineer benchmark: 91 vs ~63 out of 100. The trade-off: Fable 5 costs 2x more ($10/$50 vs $5/$25 per MTok), has higher latency, and requires 30-day data retention. For most work, Opus 4.8 is the right choice. Full Fable 5 vs Opus 4.8 breakdown here.

Changelog

June 12, 2026 — Added Claude Fable 5 (released June 9). Updated pricing table. Added platform availability table.
May 2026 — Claude Opus 4.8 and Sonnet 4.6 were the current top-tier models.

This page is updated as Anthropic releases new models. Last verified: August 26, 2026 (Pacific Time) For API pricing, check console.anthropic.com — the canonical source.

💼 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 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. 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

Three stacked layers: chat UI, tools, agent runtime — How MCP works as a layer between tools and agents.

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

Five red warning rows of MCP limitations — What MCP cannot do — permissions and review still matter.

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:

Search the web for a library’s current API (Brave Search)
Read your existing code to understand the integration point (filesystem)
Write the updated code (filesystem write)
Run tests (bash)
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

Tag: Anthropic

Certifications and attestations

HIPAA and the BAA: covered by product surface

Data retention (commercial default)

Zero data retention (ZDR)

Model-training policy and Covered Models

GDPR, data residency, and international transfers

Does Anthropic train its models on my API or commercial data?

Will Anthropic sign a BAA, and for what?

What’s the difference between ZDR and HIPAA readiness?

How long does Anthropic keep my data?

Can I keep Claude inference and data in the EU?

The renames at a glance

Current published versions

TypeScript migration

Python migration

Breaking change: the system prompt is no longer default

settingSources: changed, then reverted

The full checklist

Do I have to change settingSources when I migrate?

What is the new default system prompt?

Did the exported function names change in TypeScript?

Which version introduced the breaking changes?

Does settingSources: [] fully isolate my agent?

Models and pricing (verified specs)

Coding benchmark scores (primary-source only)

What we could not verify from a primary source

How to read a coding leaderboard

Which model has the highest published coding benchmark score in June 2026?

What does Claude Fable 5 cost, and how is it different from Opus 4.8?

Why are some benchmark cells marked “not machine-verifiable” instead of showing a number?

How do the context windows compare?

Is Terminal-Bench comparable across these models?

The one-glance comparison

Skills: teaching Claude a procedure

MCP: the open standard for access

Connectors: MCP, packaged for the apps

Plugins: a bundle, not a single thing

Hooks and slash commands: controlling the session

Is a Connector the same as an MCP server?

What’s the difference between a Skill and an MCP server?

Do Skills cost a lot of context tokens?

What can a Claude Code plugin contain?

Are custom slash commands still a thing?

The breaking-change matrix

Model ID swaps and retirement dates

budget_tokens to adaptive thinking

Sampling parameters: removed vs. restricted

Assistant-turn prefills to structured outputs

Thinking display: the silent one

The new tokenizer: re-baseline max_tokens

The full checklist

Is migrating off Claude Opus 4 really not just a model-string change?

When exactly do Claude Opus 4 and Sonnet 4 stop working?

What replaces budget_tokens now that it errors on Opus?

Why does the same prompt cost more tokens on Opus 4.8?

My thinking summaries disappeared after migrating to Opus — is that a bug?

The two billing models at a glance

What changes on June 15, 2026

How each pool is metered and priced

Subscription plan prices

The SDK rename: claude-code-sdk to claude-agent-sdk

Decision: which billing path applies to your work

Does interactive Claude Code billing change on June 15, 2026?

How much is the separate Agent SDK credit?

What happens when the Agent SDK credit runs out?

How do I avoid the credit pool entirely?

Was the Claude Code SDK renamed?

Day One: The Model Dropped and I Put It to Work

Day Two: Fable 5 Ran My Entire SEO Audit

Day Three: Building the Infrastructure Layer

What Fable 5 Actually Felt Like

What Most Commentators Are Missing

What I Lost

What Happens Now

Current Claude Models — Quick Reference

Claude Fable 5 (June 9, 2026)

Claude Opus 4.8

Claude Sonnet 5

Claude Haiku 4.5

1. `claude` — Start an interactive session

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

3. `claude mcp add` — Connect an external tool

4. `claude -c` — Continue the last conversation

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