Can I use Claude Fable 5 with the Claude API?

Yes. Claude Fable 5 is available through the Anthropic API. It supports streaming, tool use, prompt caching, vision, the Batch API, and MCP server integration.

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

For most content production, Sonnet 4.6 is the right call at 3.3× less cost. Reach for Fable 5 when you need to synthesize across a very large corpus, when the content requires deep domain reasoning with extended thinking, or when the task involves both large-context ingestion and complex output generation in a single pass.

Is Claude Fable 5 available in Claude.ai?

Fable 5 is available in Claude.ai on the Pro and Team plans, selectable from the model picker. For production-scale usage, the API with Batch API discounts is more economical.

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

Three levers: model routing (only use Fable 5 when needed), prompt caching (cache reads cost $1.00/M vs $10.00/M), and Batch API (50% discount on non-real-time workloads). Stacking all three can reduce effective costs by 85–95%.

Tag: AI Models 2026

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

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

Latest Claude Models — moved to the tracker

This slug duplicates the ranking tracker. Numbers here were last written as June 2026.

Direct Answer (9 September 2026): Claude 3.5 Sonnet is retired. Current public Sonnet is Sonnet 5 at $2 / $10 per MTok. Current lineup is Fable 5.1, Opus 5, Sonnet 5, Haiku 4.5. Live tracker: current Claude model version. Seat dollars: pricing hub.

Do not ship 3.5 Sonnet, Sonnet 4.6, or Opus 4.8 IDs in new work. Confirm the alias in the console.

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

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

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

What Is Claude Fable 5?

What is Claude Fable 5?

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

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

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

Fable 5 pricing — no sticky dollar stickers.

Model Input (per MTok) Output (per MTok) Context

Claude Fable 5 $10.00 $50.00 1M tokens

Claude Opus 4.8 $5.00 $25.00 1M tokens

Claude Sonnet 4.6 $3.00 $15.00 1M tokens

Claude Haiku 4.5 $1.00 $5.00 200K tokens

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

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

Benchmark Performance: Where Fable 5 Pulls Away

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

Benchmark Claude Fable 5 Claude Opus 4.8 Delta

SWE-bench Verified 95.0% 88.6% +6.4 pts

SWE-bench Pro 80.0% 69.2% +10.8 pts

FrontierCode 29.3% 13.4% ~2.2x

Senior Engineer benchmark 91/100 ~63/100 +45% absolute

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

When to Use Claude Fable 5 (vs Opus 4.8)

When to use Fable 5 vs Opus.

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

Use Fable 5 when:
- You’re running a large migration, refactor, or multi-stage software project
- Quality on a hard problem matters more than per-token cost
- You’re doing deep research, complex analysis, or long-horizon agentic work
- The task would otherwise take a senior engineer half a day or more
- You’re in the free evaluation window (through June 22) and want to benchmark
Use Opus 4.8 when:
- The task is well-scoped and routine
- You’re running high-volume pipelines where 2x cost compounds fast
- Latency matters — Fable 5 can take 60 seconds to several minutes on complex tasks vs 3–15 seconds for Opus 4.8
- The task falls in Fable 5’s restricted domains (cybersecurity, biology, chemistry, distillation) — in those categories, Fable 5 routes to Opus 4.8 anyway, so you’d pay Fable 5 prices for Opus 4.8 output
The smart routing strategy: Fable 5 for the hard jobs, Opus 4.8 for the rest. Don’t use Fable 5 as your default model — the cost and latency delta aren’t worth it for routine tasks.

Important Limitations to Know Before You Switch

Two limitations that don’t get enough coverage:

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

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

Availability

Claude Fable 5 is generally available as of June 9, 2026 on:
- Claude API (claude-fable-5)
- Claude Platform on AWS / Amazon Bedrock
- Google Cloud Vertex AI
- Microsoft Azure AI Foundry / GitHub Copilot
Subscription access (free through June 22, 2026): Claude Pro ($20/mo), Max 5x ($100/mo), Max 20x ($200/mo), Team, and seat-based Enterprise plans all include Fable 5 access at no extra charge during the launch window. After June 22, the plan-tier access picture may change — check Anthropic’s pricing page for updates.

How This Changes the Claude Model Decision Tree

Before Fable 5, the Claude decision tree was straightforward:
- Need the best? → Opus 4.8
- Need balance? → Sonnet 4.6
- Need speed/cost? → Haiku 4.5
Now it’s:
- Hard problems, complex projects, long-horizon work → Fable 5
- Everyday work, high-volume pipelines → Opus 4.8
- Balance of cost and capability → Sonnet 4.6
- Speed and cost optimization → Haiku 4.5
The introduction of a model tier above Opus 4.8 doesn’t replace the existing lineup — it creates a new ceiling for the work that genuinely needs it.

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

Frequently Asked Questions

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

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

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

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

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

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

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

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

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

Claude Fable 5 Complete Guide

New in 2026

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

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

What Is Claude Fable 5?

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

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

Quick Facts — Claude Fable 5

Context Window

tokens (~750K words)

Max Output

32K

tokens per response

Input Price

$10

per million tokens

Output Price

$50

per million tokens

Cache Write

$12.50

per million tokens

Cache Read

$1.00

per million tokens

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

Full Model Lineup Comparison

Pyramid diagram of Claude tiers: fast volume base, production workhorse middle, deep flagship peak — Full model lineup comparison.

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

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

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

Capability Matrix — What Each Model Can Do

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

Interactive Cost Calculator

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

Token Cost Calculator

Model

Monthly API Calls

Avg Input Tokens / Call

Avg Output Tokens / Call

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

Estimated Monthly Cost

$0.00

Which Claude Model Should You Use?

Decision diagram from task shape to deep reasoning, daily shipping, or high-volume cheap calls — Which Claude model should you use?

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

Model Picker — 3 Questions

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

Under 50K tokens

50K–200K tokens

200K–1M tokens

2. How complex is the task?

Simple / structured (classify, extract, format)

Moderate (draft, summarize, QA)

Complex (reason, plan, code, orchestrate)

3. How cost-sensitive is this workload?

Very — high volume, every cent counts

Moderate — quality matters more than cost

Not sensitive — quality and capability first

How We Actually Use Each Model

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

Haiku 4.5 — High Volume

Daily SEO Refresh Pipeline

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

Sonnet 4.6 — Production Default

Editorial Content at Scale

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

Opus 4.8 — Complex Reasoning

Workers & Deep Refreshes

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

Fable 5 — Max Capability

Portfolio Audits & Strategy

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

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

The Economics: Routed vs All-Fable

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

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

Stacking Discounts: Caching + Batch API

Two discount mechanisms compound independently:

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

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

Related Claude Resources

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

Claude Fable 5 FAQ

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

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

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

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

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

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

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

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

More Claude Guides from Tygart Media

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

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

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

June 9, 2026

llms-full.txt vs llms.txt: Why AI Agents Crawl It More (2026)

Most conversations about AI crawlability focus on one file: llms.txt. But if you look at what Anthropic, Vercel, and LangGraph actually ship – and what GEO crawler research found AI agents fetching most – the file that matters more is its companion: llms-full.txt.

Here’s the practical reality: llms.txt is the map. llms-full.txt is the territory. And in 2026, the agents that matter for citation traffic are fetching the territory.

The Full File Family You Probably Don’t Know About

The original llms.txt proposal – published by Jeremy Howard in September 2024 – defined one file. Implementers built the rest. The complete family as of mid-2026 is four files, but most sites only need two:

File	What’s in it	When to use
`/llms.txt`	Curated index – H1, summary, link sections	Always. The orientation layer.
`/llms-full.txt`	Full content of every linked page, concatenated as Markdown	When you want a model to deep-ingest your docs in a single fetch
`/llms-ctx.txt`	Pre-expanded context without URLs	FastHTML-style implementations
`/llms-ctx-full.txt`	Pre-expanded context with URLs preserved	Same, but URL-aware

The pattern that works – and the one Anthropic, Vercel, and LangGraph all run – is the index + export pair: llms.txt for orientation, llms-full.txt for deep ingestion.

Why llms-full.txt Gets Crawled More

Four ranked rows of AI crawler fleets reading publisher content — Why llms-full.txt gets crawled more.

GEO researchers analyzing AI crawler behavior – including work cited by Profound – have noted that agents from Microsoft, OpenAI, and others tend to fetch llms-full.txt more frequently than llms.txt when both are present. The working explanation is structural: when a file contains the full content, it removes one retrieval step. An agent that fetches llms-full.txt gets everything it needs in a single HTTP request instead of fetching the index, parsing the links, then fetching each linked page individually. This is consistent with how developer documentation platforms like Mintlify describe the behavior of IDE agents operating under tight latency budgets.

For IDE agents (Cursor, Continue, Cline) and MCP integrations, this is even more pronounced. These tools are operating under tight context windows and latency budgets. A single fetch that returns a clean Markdown blob of your entire docs is structurally preferable to a multi-step crawl.

The implication: if you’ve shipped llms.txt but not llms-full.txt, you’ve done half the job.

How to Build llms-full.txt

The construction logic is simple: take every URL in your llms.txt, fetch each page, strip HTML to Markdown, and concatenate. In practice, most sites do this in their build pipeline.

Here’s the minimal Node.js pattern:

const fs = require('fs');
const fetch = require('node-fetch');
const TurndownService = require('turndown');
const turndown = new TurndownService();

async function buildLlmsFullTxt(llmsIndexPath, outputPath) {
  const index = fs.readFileSync(llmsIndexPath, 'utf8');
  const urlRegex = /\[.*?\]\((https?:\/\/[^\)]+)\)/g;
  const urls = [...index.matchAll(urlRegex)].map(m => m[1]);

  let output = '';
  for (const url of urls) {
    const res = await fetch(url);
    const html = await res.text();
    const markdown = turndown.turndown(html);
    output += \n\n---\n# Source: \n\n;
  }

  fs.writeFileSync(outputPath, output);
  console.log(Built llms-full.txt:  pages,  chars);
}

buildLlmsFullTxt('./public/llms.txt', './public/llms-full.txt');

One constraint to manage: keep llms-full.txt under roughly 200,000 tokens (about 150K words, around 700KB). That’s the threshold where most models can ingest the file in a single context window. If your docs are larger, segment by product or language the way Supabase does – llms-full-api.txt, llms-full-guides.txt – and list the segmented files in your main llms.txt.

The 2026 robots.txt Stack That Completes the Picture

Three cards for Google cautious, Bing speed, OpenAI aggressive crawl styles — The 2026 robots.txt stack that completes the picture.

Shipping llms.txt and llms-full.txt is the visibility layer. The access-control layer is robots.txt – and it changed significantly in Q2 2026.

The key development: Anthropic split its crawler into two separate user-agents. ClaudeBot is the training scraper (high bandwidth, no citation value – block it). Claude-Web is the live-retrieval agent that fetches pages to answer Claude.ai user queries in real time (allow it, because it drives citation traffic). Brands that blanket-block “all Anthropic crawlers” lose Claude citations entirely.

Meta also shipped two active training scrapers in March 2026 – FacebookBot and Meta-ExternalAgent – at GPTBot-level crawl volume. Most sites have no rules for them yet.

Here’s the 2026 template:

# BLOCK: Training scrapers - high bandwidth, zero referral value
User-agent: GPTBot
Disallow: /

User-agent: CCBot
Disallow: /

User-agent: ClaudeBot
Disallow: /

User-agent: FacebookBot
Disallow: /

User-agent: Meta-ExternalAgent
Disallow: /

# OPT OUT: Google Gemini training (keeps Search indexing intact)
User-agent: Google-Extended
Disallow: /

# ALLOW: Live-retrieval agents - drive citation traffic
User-agent: OAI-SearchBot
Allow: /

User-agent: ChatGPT-User
Allow: /

User-agent: Claude-Web
Allow: /

User-agent: anthropic-ai
Allow: /

User-agent: PerplexityBot
Allow: /

One important caveat on robots.txt enforcement: aggressive training scrapers often ignore the file or spoof their user-agents. The robots.txt rules signal intent and work for compliant bots; a WAF rule at the edge is the only deterministic block for non-compliant crawlers.

The Honest State of the Technology

The SERanking study of 300,000 domains (November 2025) found no measurable correlation between having llms.txt and being cited by ChatGPT, Claude, Gemini, or Perplexity. Google’s John Mueller compared the file to the deprecated keywords meta tag – something site owners declare but that search systems derive from the content itself.

None of that means you shouldn’t ship both files. The cost is low, the optionality is real, and the IDE-agent ecosystem (Cursor, Continue, Cline) does actively use llms.txt. But the robots.txt work is the lever that moves outcomes today. The llms.txt + llms-full.txt pair is infrastructure investment – you want to be correct when major LLM providers start honoring it, and building the build pipeline now costs far less than retrofitting it later.

The practical sequence for a site that hasn’t done this yet:

Update robots.txt first. Add the Q2 2026 user-agent rules above. This takes twenty minutes and immediately affects how training scrapers treat your content.
Ship llms.txt. Curated index, 20-50 priority pages, one-sentence description per link, sections in priority order.
Build llms-full.txt. Concatenated Markdown of every linked page, under 200K tokens. Run it in your build pipeline so it stays current.
Verify both files are served correctly. curl -I https://yoursite.com/llms.txt should return 200 with Content-Type: text/plain. A 404 on either file is the most common implementation error.
Add an access-log check. Once per month, grep your logs for requests to /llms.txt and /llms-full.txt by user-agent. You want to see live-retrieval agents (Claude-Web, OAI-SearchBot, PerplexityBot) in the results – not just training scrapers.

The goal isn’t to optimize for a standard that isn’t fully adopted yet. It’s to build the infrastructure correctly now, while the field is still forming, so that adoption changes work in your favor rather than requiring catch-up.

Frequently Asked Questions

What is the difference between llms.txt and llms-full.txt?

llms.txt is a curated index — an H1, a summary, and link sections that orient an AI agent to your site. llms-full.txt is the full content of every linked page concatenated as Markdown, so an agent can deep-ingest your documentation in a single fetch. The index is the map; the full file is the territory.

Why do AI agents crawl llms-full.txt more often than llms.txt?

Fetching llms-full.txt removes a retrieval step: the agent gets everything in one HTTP request instead of fetching the index, parsing links, and fetching each page individually. For IDE agents like Cursor, Continue, and Cline operating under tight latency and context budgets, a single clean Markdown blob is structurally preferable to a multi-step crawl.

How big should llms-full.txt be?

Keep it under roughly 200,000 tokens (about 150K words, around 700KB) so most models can ingest it in a single context window. If your docs are larger, segment by product or language — for example llms-full-api.txt and llms-full-guides.txt — and list the segmented files in your main llms.txt.

Does having llms.txt actually improve AI citations?

Not measurably on its own. A November 2025 SERanking study of 300,000 domains found no correlation between having llms.txt and being cited by ChatGPT, Claude, Gemini, or Perplexity, and Google’s John Mueller compared it to the deprecated keywords meta tag. The lever that moves outcomes today is robots.txt configuration; llms.txt and llms-full.txt are low-cost infrastructure for when adoption grows.

Which AI crawlers should I allow in robots.txt in 2026?

Allow live-retrieval agents that drive citation traffic — Claude-Web, OAI-SearchBot, ChatGPT-User, anthropic-ai, and PerplexityBot. Block high-bandwidth training scrapers with no referral value such as GPTBot, CCBot, ClaudeBot, FacebookBot, and Meta-ExternalAgent, and opt out of Google-Extended to skip Gemini training while keeping Search indexing intact.

June 3, 2026

AI Model Monitoring: Tracking Identity Infrastructure

Related on Tygart Media: AI citation monitoring · AI operator’s stack · redundant AI tasks.

June 3, 2026
Claude Code vs Codex CLI (2026): A Hands-On Head-to-Head
Last verified: June 2026.

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

Claude Code vs Codex CLI: the short answer

Claude Code vs Codex CLI — the short answer.

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

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

How do you install each one?

How do you install each one?

Claude Code installs from npm and runs as the claude command:
```
npm install -g @anthropic-ai/claude-code
cd your-project
claude
```
First run walks you through OAuth login (Pro/Max plan) or an ANTHROPIC_API_KEY. On Windows it runs natively in PowerShell now, though a lot of operators still prefer it under WSL for fewer path headaches.

Codex CLI ships an install script and is also on npm:
```
# Mac / Linux
curl -fsSL https://chatgpt.com/codex/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"

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

Which models do they run in 2026?

Claude Code defaults to the current Claude flagship. As of June 2026 that is Opus 4.8 for the hardest reasoning, with Sonnet 4.6 as the fast everyday workhorse and Haiku 4.5 for cheap, high-volume calls. You switch in-session with /model. Opus 4.8 also exposes reasoning-effort levels (high is the default; xhigh and max push deeper on gnarly problems at higher token cost).

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

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

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

This is where Claude Code is currently ahead, and it is the real reason it tends to win for power users.
- Subagents – Claude Code spawns isolated sub-sessions with their own context window, tool restrictions, and prompts. Great for “go research this in parallel while the main thread keeps coding.” Codex has a lighter subagent concept (often pointed at GPT-5.4-mini to keep cost down) but it is less fleshed out.
- Hooks – Claude Code fires deterministic scripts at lifecycle points (PreToolUse, UserPromptSubmit, and more). These run real code, so they cannot hallucinate: you can hard-block a dangerous command, auto-format on every edit, or inject context before the model sees a prompt. Codex leans on its approval/sandbox policy and execpolicy rules instead of a general hook system.
- Skills and slash commands – In Claude Code, custom slash commands have merged into skills; /your-command still works and skills add reusable, packaged capabilities. Codex uses prompt files and profiles rather than a skills layer.
- Project memory – Both read a project instruction file. Claude Code uses CLAUDE.md; Codex uses AGENTS.md (checked in a fallback order including AGENTS.override.md and .agents.md). Keep these tight: architecture, conventions, and the few rules the agent keeps forgetting.
Codex’s config story is clean if you like a single file: ~/.codex/config.toml holds your model, approval policy, sandbox mode, MCP servers, and named profiles you switch with codex --profile work. Claude Code spreads config across ~/.claude/ and .claude/settings.json plus per-project files, which is more surface area but more granular control.

How do the sandbox and approval models compare?

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

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

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

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

Do both support MCP?

Do both support MCP?

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

What does each one cost?

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

Claude Code plans:
- Pro – $20/mo: Sonnet 4.6 plus some Opus, roughly enough for focused daily sessions, not all-day heavy use.
- Max 5x – $100/mo: much larger windows, real Opus headroom.
- Max 20x – $200/mo: the heavy-user tier; effectively flat-rate firehose access.
- API pay-as-you-go: Opus 4.7 about $5/$15 per million input/output… (current Opus tier runs higher), Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5.
Codex CLI: Included in ChatGPT Plus/Pro/Business plans (usage governed by your plan’s limits), or pay-as-you-go on the API. GPT-5.3-Codex runs about $1.75 per million input / $14 per million output, with cheaper input on cached tokens. The mini model is far cheaper for light work.

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

So which coding agent should you actually use?

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

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

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

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

Frequently asked questions

Is Claude Code or Codex CLI better for large refactors?

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

Can I use Codex CLI without a ChatGPT subscription?

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

Do they work on Windows natively?

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

What is the single biggest difference?

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

Which model do they run by default?

Claude Code defaults to the current Claude flagship (Opus 4.8 as of June 2026, with Sonnet 4.6 for everyday speed). Codex CLI recommends GPT-5.5 for complex work, with GPT-5.4-mini and GPT-5.3-Codex as alternatives. Switch in-session with /model or the -m flag.

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

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

Tag: AI Models 2026

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?

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 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?

What Is Claude Fable 5?

Claude Fable 5 Pricing

Benchmark Performance: Where Fable 5 Pulls Away

When to Use Claude Fable 5 (vs Opus 4.8)

Important Limitations to Know Before You Switch

Availability

How This Changes the Claude Model Decision Tree

Frequently Asked Questions

What Is Claude Fable 5?

Quick Facts — Claude Fable 5

Full Model Lineup Comparison

Capability Matrix — What Each Model Can Do

Interactive Cost Calculator

Token Cost Calculator

Which Claude Model Should You Use?

How We Actually Use Each Model

The Economics: Routed vs All-Fable

Stacking Discounts: Caching + Batch API

Related Claude Resources

Claude Fable 5 FAQ

More Claude Guides from Tygart Media

The Full File Family You Probably Don’t Know About

Why llms-full.txt Gets Crawled More

How to Build llms-full.txt

The 2026 robots.txt Stack That Completes the Picture

The Honest State of the Technology

Related Reading

Frequently Asked Questions

What is the difference between llms.txt and llms-full.txt?

Why do AI agents crawl llms-full.txt more often than llms.txt?

How big should llms-full.txt be?

Does having llms.txt actually improve AI citations?

Which AI crawlers should I allow in robots.txt in 2026?

Claude Code vs Codex CLI: the short answer

How do you install each one?