Anthropic launched Claude Haiku 5.5 on October 7, 2026. Seat prices on claude.com did not move. The operator event is a new SKU at a lower unit price, plus a cache-read cut on Sonnet 5.5.
Haiku 5.5 is a new SKU. It is not a rename of Haiku 4.5. Haiku 4.5 remains on the list at $1 / $5. Anthropic says about 90% of prior Haiku requests were under 100,000 tokens, which is the cheaper band.
Haiku 4.5
Haiku 5.5 ≤100k
Haiku 5.5 >100k
Input / MTok
$1
$0.10
$0.50
Output / MTok
$5
$0.50
$2.50
Cache write (5-minute)
$1.25
$0.125
$0.625
Cache read
$0.10
$0.01
$0.05
Batch input / output
$0.50 / $2.50
$0.05 / $0.25
$0.25 / $1.25
Sonnet 5.5 input and output did not move. Cache reads did: $0.20 to $0.10 per million tokens. Anthropic says that is about 20% cheaper on most agentic work because cache reads are a large share of the bill. Sonnet 5 cache reads stay $0.20. Opus 5.5 stays $4 / $20 with cache reads at $0.20.
Do not average the two Haiku 5.5 bands. A prompt over 100,000 tokens pays the higher line. Haiku 5.5 also uses the newer tokenizer, so the same text can be more tokens than Haiku 4.5. The posted rate is not the whole bill.
What did not change
Free $0. Pro $20 monthly / $17 annual. Max 5x $100 and Max 20x $200 on the web Help Center. Team Standard $20 annual / $25 monthly per seat. Team Premium $100 annual / $125 monthly. Enterprise $20/seat plus usage at API rates. Cursor Pro stays $20; Pro+ $60; Ultra $200; Teams $40/user on cursor.com/pricing, with Teams Premium $120 on the docs page.
Anthropic said it will roll out monthly Claude Platform credits this week: Max 5x $100, Max 20x $200, Team up to $500 pooled. That is an announced credit, not a seat-price cut. Confirm in the Help Center article before you book it.
Operator note
If a loop is pinned to Haiku 4.5, it is still on the $1 / $5 meter. Move it to Haiku 5.5 only if the workload can take the new model and you watch the 100k prompt line. Cursor on-demand that bills Anthropic list will pick up the new SKU when Cursor exposes it. Cursor seat prices did not move with this launch.
Direct answer: Anthropic moved Claude Code cloud sessions from research preview to general availability on September 23, 2026. Existing Pro subscribers can claim a one-time $100 credit and Max subscribers a one-time $250 credit — but only for cloud-session usage, and only if you claim by 11:59 PM Pacific on October 7, 2026. Unclaimed credit disappears. Claimed credit that goes unused expires November 4, 2026.
What a cloud session actually is
Claude Code running on Anthropic's machines instead of yours. You hand it a task and a GitHub repository; it keeps working after you close the laptop, lose Wi-Fi, or leave the room. Anthropic's pitch: "Cloud sessions run on Anthropic-hosted infrastructure, so the work keeps going even without your computer running."
The practical differences from a local session:
Your laptop is not the bottleneck. No sleep, no battery, no VPN drop killing a long task.
Isolation. The agent works in a hosted environment, not on your machine's files — which limits blast radius.
Accessible everywhere. Start on desktop, check on mobile.
It draws from credit, not just plan limits. The one-time credit applies automatically when you start a session, and it is separate from your weekly usage limits. Anthropic's framing: "If you hit a limit locally, keep going in the cloud until your credit runs out."
The credit, precisely
Pro
Max
One-time credit
$100
$250
Claim deadline
11:59 PM PT, Oct 7, 2026
11:59 PM PT, Oct 7, 2026
Unused credit expires
11:59 PM PT, Nov 4, 2026
11:59 PM PT, Nov 4, 2026
Eligibility
Individual subscriber active Sept 23, 2026
Individual subscriber active Sept 23, 2026
One credit per account. The credit covers cloud sessions only — not chat, not API calls, not local Claude Code. It applies before your regular plan usage, and once it's gone, cloud sessions count against your normal plan limits. There is no separate charge for the cloud container itself.
What you need: a connected GitHub account, because every cloud session works against a repository. No GitHub, no session, no credit use.
How to claim it
1. Confirm your plan. Pro or Max, individual subscription, active on September 23.
2. Connect GitHub. Required before a cloud session will start.
3. Claim. Open claude.ai/code and use the Claim credit prompt, or run /claim-credit inside the Claude Code CLI.
4. Start a session. From claude.ai/code, the Code tab in the Claude mobile app, the desktop app, or claude --cloud in the terminal. Anthropic also lists Routines as a starting point.
5. Watch the dates. Claim by October 7; spend it by November 4. Last call as of today, October 6: the claim window closes 11:59 PM Pacific tomorrow, October 7, 2026. Claim it now — unclaimed credit disappears.
Team and Enterprise users get cloud-session access through premium seats, but the $100/$250 promotional credit is the Pro/Max subscriber offer — evaluate the feature on its own merits if you're outside the promo.
Under the hood
Anthropic runs cloud sessions on fresh Ubuntu 24.04 virtual machines — roughly 4 vCPUs, 16 GB of RAM, 30 GB of disk, per published reports. Organizations that can't let source code run on a vendor's VMs can route sessions to self-hosted environments instead — a separate path from the consumer credit.
Note the contrast with Remote Control: Remote Control connects a web or mobile interface to a Claude Code session running on *your own computer*, so that machine has to stay awake. Cloud sessions remove the machine entirely.
Should you use it?
Treat the credit as a trial budget. Point it at work that's easy to verify: bug fixes with test coverage, dependency updates, questions about a codebase. Check the branch and the pull request the agent produces before merging anything. Anthropic even describes auto-fix of pull requests directly in the cloud as a feature — still check the diff yourself.
For occasional or non-technical users, be honest with yourself: the credit may go unused, because cloud sessions require a GitHub-connected coding workflow to begin with. That's worth knowing before you count on redeeming the full amount.
Anthropic launched Claude Sonnet 5.5 on September 28, 2026. Seat prices on claude.com did not move. The operator event is a new SKU, not a unit-price cut: Sonnet 5.5 lists at $2 per million input tokens and $10 per million output tokens — the same pair as Sonnet 5.
Sonnet 5.5 is a new SKU, not a rename of Sonnet 5. Anthropic says it runs 30%+ faster than Sonnet 5 and costs up to 30% less per task because it uses fewer tokens, not because the published rate fell.
Sonnet 5
Sonnet 5.5
Input / MTok
$2
$2
Output / MTok
$10
$10
5-minute cache write
$2.50
$2.50
1-hour cache write
$4
$4
Cache read
$0.20
$0.20
Batch
$1 / $5
$1 / $5
Do not treat “30% less per task” as a 30% list-price cut. The meter is still $2 / $10. US-only inference stays 1.1x on Claude 4.6 and later models.
What did not change
Free $0. Pro $20 monthly / $17 annual. Max from $100 (5x) and $200 (20x). Team Standard $20 annual / $25 monthly per seat. Team Premium $100 annual / $125 monthly. Enterprise $20/seat plus usage at API rates. Opus 5.5 remains $4 / $20. Haiku 4.5 remains $1 / $5. Fable 5.1 remains $10 / $50 with $0.25 cache reads. Cursor Individual stays $20; Cursor Teams stays $40/user on cursor.com/pricing.
Operator note
If you are pinned to claude-sonnet-5, you are still on the $2 / $10 meter. Switch to claude-sonnet-5-5 if the workload can move and you want the newer model. Cursor on-demand that routes to Anthropic list will pick up the new SKU when Cursor exposes it — Cursor seat prices did not move with this launch.
Anthropic launched Claude Opus 5.5 on September 22, 2026. Seat prices on claude.com did not move. The operator event is the unit price: Opus 5.5 lists at $4 per million input tokens and $20 per million output tokens — 20% below Opus 5 at $5 / $25.
Opus 5.5 is a new SKU, not a rename of Opus 5. Anthropic says it performs at the level of Fable 5.1 on most work and costs about 40% less than Opus 5 on typical token-billed workloads because cache reads fell more than the headline rate.
Opus 5
Opus 5.5
Input / MTok
$5
$4
Output / MTok
$25
$20
5-minute cache write
$6.25
$5
1-hour cache write
$10
$8
Cache read
$0.50
$0.20
Fast mode
$10 / $50
$8 / $40
Batch
$2.50 / $12.50
$2 / $10
Cache reads on Opus 5.5 are 0.05x input ($0.20), not the 0.1x used on Opus 5. That is the line that moves agent and Claude Code bills. US-only inference stays 1.1x on both SKUs.
What did not change
Free $0. Pro $20 monthly / $17 annual. Max from $100 (5x) and $200 (20x). Team Standard $20 annual / $25 monthly per seat. Team Premium $100 annual / $125 monthly. Enterprise $20/seat plus usage at API rates. Sonnet 5.5 remains $2 / $10. Haiku 4.5 remains $1 / $5. Fable 5.1 remains $10 / $50 with $0.25 cache reads.
Opus 5.5 is available on Pro, Max, Team, and Enterprise. Anthropic also said five-hour usage limits on those plans increased with the launch. Confirm the live window in Settings > Usage. Do not treat a help-center message count as a hard cap.
Operator note
If you are pinned to claude-opus-5, you are still on the $5 / $25 meter. Switch to claude-opus-5-5 if the workload can move. Fast mode is first-party Claude API only at $8 / $40. Cursor on-demand that routes to Anthropic list will pick up the new SKU when Cursor exposes it — Cursor seat prices on cursor.com ($20 Individual, $40 Teams) did not move with this launch.
Correction — October 2, 2026: Anthropic reversed course. Sonnet 5 did not move to $3 / $15 on September 1 — it remains $2 / $10 on the first-party API table (batch $1 / $5), and Sonnet 5.5 is the current Sonnet at the same $2 / $10. The September 17 operator note below is preserved as the record of what the card showed then.
Sonnet 5 is no longer $2 / $10 on the first-party API table. Anthropic published introductory pricing through August 31, 2026, then the standard rate: $3 per million input tokens and $15 per million output tokens starting September 1, 2026.
That is a 50% unit-price move on input and output versus the intro card. Sonnet 4.6 was already $3 / $15. The two mid-tier SKUs now share the same list. Cache writes follow the new input rate ($3.75 / MTok for 5-minute writes; $0.30 / MTok cache reads). Batch stays 50% off that list.
What did not move on this check:
Claude Pro $20/mo or $17/mo annual ($200 prepaid)
Max 5x $100/mo, Max 20x $200/mo
Team Standard $25 monthly / $20 annual; Premium $125 / $100
Lineup currency (Oct 2026): Current API list (Oct 2026, verified): Sonnet 5.5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.
Cursor Hobby free, Pro $20, Pro+ $60, Ultra $200, Teams $40/user
If a workflow was budgeted during the September scare, the meter is back to $2 / $10 — the same as Sonnet 5.5. Haiku 4.5 is still the cheap public list. Live desks: API rates, seats.
The Claude Agent SDK tutorial starts here — the SDK (formerly the Claude Code SDK, renamed late 2025) eliminates the boilerplate of building agentic loops by hand, shipping the same tool execution, context management, and permission system that powers Claude Code into a Python or TypeScript library you can embed in any product, pipeline, or internal tool.
This is a practical build guide. It covers when to use an agent versus a script, what the SDK actually does, how to set one up with working code, and what to watch for in production.
When to Use an Agent vs. a Script
Agent vs script — choose deliberately.
Use an agent when the number of steps to complete the task is unpredictable. If the workflow can be hardcoded, a linear script is faster, cheaper, and easier to debug.
This is Anthropic’s own guidance in Building Effective Agents, and it’s the right frame. The common mistake is reaching for agents because agents are fashionable — not because the problem requires them.
Agents fit:
Open-ended research tasks where the number of searches needed varies
Code debugging where the error chain isn’t known in advance
Multi-step data pipelines where decisions at each step depend on prior outputs
Any workflow where the model needs to try, observe, and adjust
Scripts fit:
Known sequences of steps that always run in the same order
Simple data transformation with no conditional branching
Any task where the output of each step is fully predictable
The cost implication matters too: a 15-step agentic research task can hit 200K+ tokens without optimization. Agents are expensive when you don’t need them.
How the Claude Agent SDK Works
How the Agent SDK loop behaves in practice.
The SDK automates the ReAct loop — Reason, Act, Observe, repeat — so you define the tools and instructions and the SDK handles the rest. You never write the prompt → check stop_reason → execute tool → loop boilerplate yourself.
The core loop the SDK manages:
Send the task to Claude with available tool definitions
Claude reasons and produces a tool call (or a final answer)
The SDK executes the tool in the local environment
The SDK sends the result back to Claude
Claude observes and decides: call another tool or produce final output
Loop until done
This continues until Claude produces a response with no tool calls. The SDK handles conversation history, token tracking, error handling, and session management across the entire loop.
A working agent requires three things: a task, tool definitions, and a Runner call. Everything else is configuration.
from claude_agent_sdk import ClaudeAgentOptions, Runner
import subprocess
import json
# Define tools the agent can use
tools = [
{
"name": "run_command",
"description": "Run a shell command and return its output",
"input_schema": {
"type": "object",
"properties": {
"command": {
"type": "string",
"description": "The shell command to execute"
}
},
"required": ["command"]
}
},
{
"name": "read_file",
"description": "Read the contents of a file",
"input_schema": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "File path to read"
}
},
"required": ["path"]
}
}
]
# Tool execution handlers
def execute_tool(tool_name: str, tool_input: dict) -> str:
if tool_name == "run_command":
result = subprocess.run(
tool_input["command"],
shell=True,
capture_output=True,
text=True
)
return result.stdout or result.stderr
elif tool_name == "read_file":
with open(tool_input["path"], "r") as f:
return f.read()
return f"Unknown tool: {tool_name}"
# Configure and run the agent
options = ClaudeAgentOptions(
model="claude-sonnet-4-6",
max_turns=20, # safety ceiling
tools=tools,
tool_executor=execute_tool
)
result = Runner.run_sync(
task="Check the disk usage on this machine and report the top 5 largest directories under /home",
options=options
)
print(result.final_output)
That’s a complete working agent. The SDK handles the loop; the tool definitions and executor are the only custom code.
Adding Cost Controls
Add cost controls before multi-turn agents hit production.
Always set a max_turns ceiling and a token budget. An uncapped agent loop can run indefinitely on an ambiguous task.
options = ClaudeAgentOptions(
model="claude-sonnet-4-6",
max_turns=20,
max_tokens_per_turn=4000, # cap per individual turn
tools=tools,
tool_executor=execute_tool
)
Cost at 20 turns using Claude Sonnet 4.6 with an average of 2,000 tokens per turn:
Input: 40,000 tokens × $3/M = $0.12
Output: 10,000 tokens × $15/M = $0.15
Total per agent run: ~$0.27
At 1,000 agent runs per month: ~$270. At 10,000: ~$2,700. Budget from these numbers, not from seat prices.
Switching the inner loop to Haiku 4.5 for tool selection and Sonnet only for synthesis cuts cost significantly:
# Route lighter reasoning to Haiku, reserve Sonnet for synthesis
light_options = ClaudeAgentOptions(model="claude-haiku-4-5-20251001", ...)
heavy_options = ClaudeAgentOptions(model="claude-sonnet-4-6", ...)
Multi-Turn Agents (Conversational)
For agents where a human asks follow-up questions across multiple turns, maintain conversation history and pass it on each call.
from claude_agent_sdk import ClaudeAgentOptions, Runner
conversation_history = []
def chat_with_agent(user_message: str) -> str:
conversation_history.append({
"role": "user",
"content": user_message
})
options = ClaudeAgentOptions(
model="claude-sonnet-4-6",
max_turns=10,
tools=tools,
tool_executor=execute_tool,
messages=conversation_history # full history each call
)
result = Runner.run_sync(task=user_message, options=options)
conversation_history.append({
"role": "assistant",
"content": result.final_output
})
return result.final_output
# Usage
print(chat_with_agent("What Python packages are installed on this system?"))
print(chat_with_agent("Which of those are outdated?"))
Claude Managed Agents vs. the Agent SDK
The Agent SDK runs locally in your environment. Claude Managed Agents runs in Anthropic’s cloud infrastructure with persistent sessions, built-in tools, and cross-session memory. Choose based on where you need the agent to execute.
Agent SDK
Managed Agents
Where it runs
Your server / local machine
Anthropic-managed cloud
Persistent sessions
Manual (maintain history)
Built-in
Cross-session memory
Manual
Built-in (public beta)
Built-in tools
Bring your own
20+ included
Multi-agent coordination
Manual
Built-in
Cost
API tokens only
API tokens + platform fee
Control
Full
Managed
The Agent SDK is right for custom environments, data that can’t leave your infrastructure, and workflows deeply embedded in existing systems. Managed Agents is right when you want to skip infrastructure and get to the agent behavior faster.
What Goes Wrong in Production
The most common production failures are uncapped loops, conversation history that grows without bound, and tool definitions written too vaguely.
Uncapped loops: An agent on an ambiguous task will keep calling tools indefinitely without a max_turns ceiling. Always set one. Always check message.subtype rather than is_error — a max-turns termination doesn’t set is_error: true correctly in some SDK versions.
Growing conversation history: Each turn adds tokens to history. At 20 turns on a complex task, history can push 100K+ tokens. Summarize aggressively between phases for long-running agents: prompt Claude to summarize phase 1 outputs before starting phase 2.
Vague tool definitions: Tool descriptions are how Claude decides which tool to call and how to use it. Vague descriptions produce tool call errors and unnecessary retry loops. Write tool descriptions as precisely as you would write a function docstring — what it does, what inputs it expects, what it returns.
camelCase vs snake_case mismatch:AgentDefinition uses camelCase (disallowedTools); ClaudeAgentOptions uses snake_case (disallowed_tools). This caught teams in early SDK versions.
The Claude Agent SDK is Anthropic’s Python and TypeScript library for building autonomous AI agents. It wraps the same agentic loop that powers Claude Code — tool execution, context management, and session handling — so developers don’t build that infrastructure from scratch. It was formerly called the Claude Code SDK and was renamed in late 2025.
What is the difference between the Agent SDK and Claude Code?
Claude Code is Anthropic’s interactive terminal-based development tool for agentic coding. The Agent SDK is the programmatic library for embedding agent behavior in custom applications and pipelines. They share the same underlying agent loop and tool system. Claude Code stays in the picture for interactive development; the SDK is for production automation.
How much does it cost to run an agent?
Agent cost is API token cost only (no platform fee for the SDK itself). A 20-turn agent on Claude Sonnet 4.6 with 2,000 tokens average per turn costs approximately $0.27. At 10,000 agent runs per month, that’s about $2,700. Switching the tool selection loop to Haiku 4.5 and reserving Sonnet for synthesis significantly reduces cost.
When should I use Managed Agents instead of the Agent SDK?
Use Managed Agents when you want cloud-hosted execution, persistent cross-session memory, built-in tools (20+ included), and multi-agent coordination without building that infrastructure yourself. Use the Agent SDK when you need local execution, full control over the environment, or your data can’t leave your infrastructure.
Claude wins on coding quality and long-context reliability. GPT-5 wins on raw speed at the prior mid-tier list. Pick the SKU, not the family name.
Claude figures checked October 8, 2026 against platform.claude.com pricing and Haiku 5.5. OpenAI rows below are the October 1 figures on this page; they were not re-verified on this pass.
The Models Being Compared
Compare APIs by job shape — not by hype.
Compare Claude Haiku 5.5 / Sonnet 5.5 / Opus 5.5 against GPT-5 / gpt-6.1-sol. Fable 5.1 sits above Opus on Anthropic’s list price.
Model
Provider
Input (per 1M tokens)
Output (per 1M tokens)
Context
Claude Haiku 5.5 (≤100k / >100k)
Anthropic
$0.10 / $0.50
$0.50 / $2.50
priced by prompt length
Claude Haiku 4.5
Anthropic
$1
$5
still listed
Claude Sonnet 5.5
Anthropic
$2
$10
1M tokens; cache read $0.10
Claude Sonnet 5
Anthropic
$2
$10
1M tokens; cache read $0.20
Claude Sonnet 4.6
Anthropic
$3
$15
1M tokens
Claude Opus 5.5
Anthropic
$4
$20
1M tokens
Claude Opus 5 / 4.8
Anthropic
$5
$25
1M tokens
Claude Fable 5.1
Anthropic
$10
$50
1M tokens
GPT-5
OpenAI
$1.25
$10
400K tokens (Oct 1 figure)
gpt-6.1-sol (short-context standard)
OpenAI
$2
$10
long-context row was $4 / $15 (Oct 1 figure)
Sonnet 5.5 remains $2 / $10. Its cache read moved from $0.20 to $0.10 on October 7. Opus 5.5 remains $4 / $20 with cache reads at $0.20. Haiku 5.5 is the new cheap band: $0.10 / $0.50 under 100,000 prompt tokens, $0.50 / $2.50 over. Haiku 4.5 stays $1 / $5. GPT-5 standard list on the prior check ($1.25 / $10) was cheaper per input token than Sonnet 5.5. Do not average Haiku 5.5’s two bands, and do not treat the OpenAI rows as re-checked today.
Coding Performance
Use Claude Opus 5.5 or Sonnet 5.5 for interactive coding and agentic runs. Use Haiku 5.5 when the task is a subagent, summary, or classification and the prompt stays under 100k tokens.
Latency and Context
Claude Sonnet and Opus SKUs publish a 1M token context window at one rate. Haiku 5.5 raises the rate above 100,000 prompt tokens. Opus 5.5 fast mode is $8 / $40 on the Claude API only.
Cost Comparison for Real Workloads
On Claude, cache reads are now 5% of input on Sonnet 5.5 ($0.10) and Opus 5.5 ($0.20), and 2.5% on Fable 5.1 ($0.25). Haiku 5.5 cache reads are $0.01 under 100k. The 50% batch API still applies. For stateless high-frequency calls, Haiku 5.5 under 100k is the Claude list to beat. gpt-6.1-sol short-context matched Sonnet 5.5 at $2 / $10 on the October 1 check; that OpenAI pair was not re-read today.
Which API to Choose
Use Claude for coding, long-context document work, and agentic workflows. Use Haiku 5.5 for the cheap loop. Running both vendors is normal.
Claude Managed Agents is the product. Slack, Notion, Jira, and Asana are just the interface. Anthropic is building the invisible execution layer that powers the next generation of enterprise software.
Last refreshed: October 8, 2026 (Pacific)
There is a pattern emerging in enterprise AI that most people are reading wrong. They see Anthropic launch Claude Tag in Slack and think “chatbot upgrade.” They see Claude show up inside Notion and think “productivity feature.” They see AI agents appear in Jira and Asana and think “automation plugin.”
They are missing the architecture underneath all of it.
Anthropic is not building a better chatbot. It is building the invisible agent runtime that sits beneath every collaboration tool your team already uses. The company’s Claude Managed Agents (CMA) platform — launched in public beta on April 8, 2026 — is the infrastructure layer that makes this possible. And the speed at which partners are embedding it tells you everything about where enterprise software is heading.
What Claude Managed Agents Actually Is
What Claude Managed Agents actually is — the runtime layer.
Claude Managed Agents is a set of composable APIs for building and deploying production AI agents on Anthropic’s cloud infrastructure. The service handles sandboxed code execution, session persistence, credential management, scoped permissions, and end-to-end tracing — all the operational complexity that previously kept agents stuck in proof-of-concept limbo.
The architecture rests on three primitives: the Agent (configuration and behavior), the Environment (sandboxed execution), and the Session (the event log that tracks everything the agent does). What makes this interesting architecturally is how Anthropic decoupled the “brain” from the “hands.” Claude’s reasoning runs on Anthropic’s own infrastructure while the code execution sandbox spins up independently — and in parallel. The brain starts reasoning immediately while the sandbox provisions, delivering roughly 60% faster time-to-first-token at the p50 level and over 90% faster at p95, according to Anthropic’s engineering team.
Pricing follows a transparent model: standard Claude API token rates plus $0.08 per session-hour of active runtime during the current beta period. Runtime is measured to the millisecond and only accrues while the agent is actively executing — idle time waiting for input or tool confirmations does not count.
For teams that need to keep execution inside their own perimeter, CMA supports self-hosted sandboxes through partners including Cloudflare, Daytona, Modal, and Vercel, or custom VPC deployments. MCP tunnels allow agents to connect to private Model Context Protocol servers inside your network without exposing them to the public internet. A Vaults system keeps credentials out of the sandbox entirely using envelope encryption. And a feature called Dreaming runs scheduled reviews of past sessions to curate agent memory — essentially letting agents learn from their own operational history.
The Embedded Layer: Where CMA Actually Lives
Embedded layer: where CMA actually lives in the stack.
The real story is not the infrastructure. It is where that infrastructure shows up. In the ten weeks since CMA launched, Anthropic has embedded its agent runtime inside the collaboration tools that enterprises already depend on. This is not a roadmap — these integrations are live or in active beta.
Slack: Claude Tag as Persistent Team Member
Claude Tag, launched in late August 2026, replaces Anthropic’s original Claude in Slack integration with something fundamentally different. This is not a chatbot you summon with a slash command. It is a persistent AI team member that lives in your channels, builds memory across conversations, and can take initiative through what Anthropic calls “ambient mode” — proactively surfacing information, following up on forgotten threads, and keeping teams updated across the organization.
Claude Tag is multiplayer by design: one Claude identity per channel, accessible to everyone, with the ability to hand off half-finished tasks between team members. It launched on Claude Opus 4.8 and now runs on Claude Opus 5.5 (see our Claude Tag pricing guide). And internally, Anthropic reports that Claude Tag is already approving and incorporating 65% of the code changes their product team submits. The existing Claude in Slack app will be retired on August 3, 2026. Claude Tag is available on Enterprise and Team plans.
Notion: Claude as External Agent
On May 13, 2026, Notion launched its Developer Platform version 3.5, which introduced the External Agents API. This API lets AI agents — including Claude — operate inside your Notion workspace as first-class participants. They can read pages, write to databases, create tasks, trigger automations, and be @-mentioned directly in documents. Claude operating through this API can chain actions together: read a project brief, check the task database for related work, draft a new document, and create a linked task entry — all in a single session, running on CMA infrastructure with full sandboxing.
Asana: AI Teammates
Asana built AI Teammates on CMA — agents that pick up assigned tasks inside projects, draft deliverables, and hand back outputs for human review. Specialist agents handle specific workflows: the Campaign Brief Writer turns scattered notes into structured briefs, the Workflow Optimizer identifies process gaps and builds automations, and the Compliance Specialist checks work against regulatory standards. Asana’s CTO said CMA let them ship these features “dramatically faster” than any prior approach to agent development.
Atlassian: Claude Agent for Jira
Atlassian released Claude Agent for Jira, built on CMA infrastructure, which lets teams assign work items directly to Claude from the Jira UI. The agent clones the repository, analyzes the codebase, implements changes on an independent branch, pushes the code, and opens a draft pull request — streaming real-time status updates back to the Jira work item throughout the process.
Sentry: From Bug Detection to Merge-Ready PR
Sentry’s existing AI debugging agent, Seer, already used Claude for root cause analysis. With CMA, Sentry extended the workflow from diagnosis to automated fixing — the agent takes Seer’s root cause output, generates a fix, opens a branch with the changes, and creates a pull request for developer review. Sentry processes over one million root cause analyses per year and provides near-immediate reviews on over 600,000 pull requests per month. The CMA integration was built by a single engineer in weeks, eliminating months of custom agent runtime development.
Rakuten: Specialist Agents Across the Enterprise
Rakuten deployed specialist agents across product, sales, marketing, and finance using CMA, with each agent deployed in approximately one week. Agents plug into Slack and Teams, letting employees assign tasks and receive deliverables including spreadsheets, slides, and applications. In the pilot, Rakuten reported a 97% drop in critical first-pass errors, with cost down more than 30% and latency reduced by 34%, without any loss in output quality.
KPMG: Global Professional Services Alliance
On May 19, 2026, KPMG and Anthropic announced a global alliance and launched “Digital Gateway Powered by Claude.” The partnership embeds Claude, Cowork, and CMA directly into KPMG’s client delivery platform, with an initial focus on tax and private equity clients. Building an AI agent for tax regulation workflows previously took weeks and required switching between multiple tools. With CMA integrated into Digital Gateway, KPMG says the same capability takes minutes. The alliance extends to KPMG’s 276,000-person global workforce.
The Strategic Pattern: Agent Runtime as a Service
Step back from the individual integrations and the strategic pattern becomes clear. Anthropic is not trying to own the interface. It is deliberately positioning CMA as the execution layer underneath interfaces that other companies own. Slack owns the messaging UI. Notion owns the workspace UI. Jira owns the project tracking UI. Anthropic owns the agent brain that powers all of them.
This is a fundamentally different strategy from its two largest competitors.
OpenAI chose vertical integration. When OpenAI launched Workspace Agents on April 22, 2026, it positioned ChatGPT itself as the central hub — a no-code successor to custom GPTs that connects to Slack, Salesforce, Google Drive, and Notion through plugins. Agents are created inside ChatGPT, accessed from ChatGPT, and managed through ChatGPT. OpenAI wants to own the surface area.
Google chose platform depth. At Google Cloud Next on April 22, 2026, Google unveiled the Gemini Enterprise Agent Platform — a reimagined evolution of Vertex AI — alongside Workspace Intelligence, a semantic unifying layer that connects data across Docs, Slides, Gmail, and the broader Google Cloud ecosystem. Google’s agent platform supports 200+ models including Claude, and the Agent2Agent (A2A) protocol enables distributed peer-to-peer agent communication. Google is leveraging its data moat and distribution at the platform level.
Anthropic chose tool-centric orchestration. Rather than owning the UI (OpenAI) or the platform (Google), Anthropic is embedding its agent runtime into every tool through composable APIs and the Model Context Protocol. The platform you use becomes irrelevant — whether it is Slack, Notion, Jira, Asana, or Sentry — because the agent brain running underneath is Claude on CMA.
This is the agent-as-a-service model. And it may be the most defensible position of the three, because it does not require users to change their behavior or migrate to a new platform. The agent shows up where they already work.
What the Numbers Say About Enterprise Agent Adoption
The macro context supports Anthropic’s timing. Gartner predicts that 40% of enterprise applications will include embedded task-specific agents by the end of 2026, up from less than 5% in 2025. McKinsey’s April 2026 analysis found that agentic AI can enable automation of 60 to 80 percent of routine infrastructure work over time, translating to a 20 to 40 percent run-rate cost reduction in initial deployments.
The gap between experimentation and production remains the defining challenge. Industry research compiled from major firms shows that nearly four in five enterprises have experimented with or deployed agents in some form, but fewer than one in nine are running them in production at a scale that generates measurable business value. For the agents that do reach production, the average return on investment is 171% — though 19% of deployments never reach payback at all.
That production gap is exactly what CMA is designed to close. The infrastructure burden — sandboxing, session persistence, credential isolation, error recovery, observability — is the bottleneck. Engineering teams routinely dedicated significant senior engineering resources for months before a single agent reached production. CMA eliminates that layer entirely, which is why partners like Asana, Sentry, and Rakuten report shipping production agents in days or weeks rather than quarters.
What This Means for Businesses Already Using These Tools
If your organization uses Slack, Notion, Jira, or Asana — and statistically, you use at least two of them — you are about to encounter Claude whether you planned to adopt it or not. This is not a technology decision your IT team is making. It is a feature that your existing vendors are shipping.
The practical implications are significant. Claude Tag in Slack means your team channels will have an AI participant that remembers past conversations, can be handed tasks asynchronously, and may proactively surface information. Claude in Notion means your project documentation, databases, and task boards can be read, analyzed, and acted upon by an agent that chains actions together. Claude Agent for Jira means development tickets can be assigned to an AI that clones your repo, writes code, and opens pull requests.
For agencies and service providers managing client work across multiple tools, the embedded agent layer changes the economics fundamentally. Work that previously required a human to context-switch between Slack, Notion, and a project management tool — reading a brief here, updating a task there, drafting a document somewhere else — can be handled by an agent that operates across all of them simultaneously. The coordination tax that consumes a substantial share of knowledge work time is the exact problem embedded agents are built to solve.
The companies that benefit most will be the ones that have clean operational systems — structured task boards, documented processes, well-organized project databases — because agents can only act on information they can read. Messy Notion workspaces and disorganized Jira boards will limit what agents can accomplish. Operational hygiene just became a competitive advantage.
What This Means for Solo Operators Already Running Agent Infrastructure
There is a specific audience that should be paying very close attention to CMA: the solo operators and small agency owners who have already built their own agent stacks from scratch. If you are running scheduled Claude tasks on a GCP Compute Engine VM, connecting to WordPress via REST API proxies, piping work orders through Notion, monitoring Gmail for client replies, and publishing content through MCP-connected pipelines — you have already built a version of what CMA is productizing.
The economics question is worth doing the math on. A lightweight GCP VM running 24/7 to host recurring agent tasks — news desk monitors, outreach reply checks, newsletter extraction, scheduled content audits — costs a fixed monthly rate whether the agents are actively working or sitting idle. CMA at $0.08 per session-hour of active runtime only charges when agents are executing. For tasks that run for a few minutes every few hours, the per-session billing model could be substantially cheaper than keeping a VM warm around the clock. A task that runs for ten minutes six times a day would cost roughly $0.08 per day on CMA, versus the cost of a VM instance that never sleeps.
But the migration path is not ready yet, and solo operators should understand exactly where the gaps are before making any infrastructure decisions.
The biggest gap is MCP tunnels. CMA’s ability to connect agents to private MCP servers inside your network is still in research preview — not production-ready. If your agent stack depends on a private WordPress REST API proxy, a Notion workspace connected via MCP, or any internal tool that is not exposed to the public internet, CMA cannot reach it today. The Vaults system for credential management is promising, but it does not solve the network connectivity problem for self-hosted infrastructure.
The second gap is orchestration control. Solo operators who have built their own agent infrastructure typically have precise control over scheduling, retry logic, error handling, and the exact sequence of tool calls. CMA’s Dreaming feature — which reviews past sessions to curate agent memory — is an interesting approach to agent learning, but it is not the same as having direct control over a cron job that fires at 6:00 AM, checks three data sources in a specific order, and writes results to a specific Notion database with a specific schema.
The thesis for solo operators is straightforward: CMA is almost certainly the future migration path for self-hosted agent infrastructure. The economics favor it for intermittent workloads, the managed security and sandboxing eliminate operational risk you are currently carrying yourself, and the session persistence model solves problems that custom agent runtimes handle poorly. But the plumbing — particularly MCP tunnels to private infrastructure — is not production-ready. Track it closely. Do not migrate yet. When MCP tunnels graduate from research preview to general availability, revisit the math and the connectivity story. That is the trigger point.
The Risk Nobody Is Talking About
The risk nobody talks about — agents that act with memory.
There is a tension in this model that deserves attention. When Claude operates as an invisible layer inside tools you already trust, the boundary between the tool’s native capabilities and the AI agent’s actions blurs. A Jira ticket that was “completed” might have been implemented by Claude, reviewed by a human for thirty seconds, and merged. A Notion project plan that looks thorough might have been generated by an agent that filled in the sections with plausible-sounding content.
The embedded model works precisely because it reduces friction — but reduced friction also means reduced scrutiny. Organizations adopting embedded agents need to build review processes that match the speed at which agents can produce output. The 171% average ROI from agent deployments accounts for the value created, but it does not account for the subtle quality risks of production work generated by systems that are confident, fluent, and occasionally wrong.
Anthropic has built guardrails into CMA — sandboxed execution, credential isolation, session logging — but the governance layer for reviewing agent output at enterprise scale is still largely unsolved. This is a space where internal operational discipline matters more than the technology itself.
Where This Goes Next
Claude Tag launched on Slack first. Anthropic has indicated plans for wider rollout beyond Slack. If the pattern holds, expect Claude Tag’s persistent team member model to appear in Microsoft Teams, Discord, and any other collaboration surface where teams coordinate work.
The CMA primitives are designed to be composable, which means the partner integration list will grow rapidly. Any SaaS company with an API and a workflow that involves reading context, making decisions, and taking actions is a candidate for CMA integration. Customer support platforms, CRM systems, design tools, analytics dashboards, HR systems — the addressable surface is essentially every tool that knowledge workers touch.
Gartner’s long-term projection estimates that agentic AI could drive approximately 30% of enterprise application software revenue by 2035, surpassing $450 billion. If Anthropic’s embedded strategy succeeds, a meaningful slice of that revenue flows through CMA as the underlying runtime — regardless of whose logo is on the interface.
The chatbot era is ending. The embedded agent era is starting. And Anthropic is betting that the company that owns the invisible execution layer wins the market, even if no end user ever sees its name.
Claude Managed Agents is a set of composable APIs launched by Anthropic on April 8, 2026 in public beta. CMA lets developers build and deploy production AI agents on Anthropic’s cloud infrastructure, handling sandboxed code execution, session persistence, credential management, and end-to-end tracing. The architecture separates the “brain” (Claude reasoning) from the “hands” (code execution sandbox), enabling parallel processing and faster agent responses.
How much do Claude Managed Agents cost?
During the current public beta, CMA pricing is standard Claude API token rates plus $0.08 per session-hour of active runtime. Runtime is measured to the millisecond and only accrues while the agent is actively executing — idle time does not count. GA pricing has not been finalized and may differ from the beta rate.
What is Claude Tag in Slack?
Claude Tag is Anthropic’s persistent AI team member for Slack, launched in late August 2026. Unlike a traditional chatbot, Claude Tag lives in channels, builds memory across conversations, takes initiative through ambient mode, and works asynchronously. It is multiplayer — one Claude identity per channel that all team members interact with. Claude Tag now runs on Claude Opus 5.5 (launched on Opus 4.8) and is available on Enterprise and Team plans. It replaces the original Claude in Slack app, which retired August 3, 2026.
Which tools have Claude Managed Agents embedded?
As of October 2026, CMA is embedded in Slack (via Claude Tag), Notion (via the External Agents API), Asana (AI Teammates), Atlassian Jira (Claude Agent for Jira), and Sentry (extending the Seer debugging agent). Enterprise deployments include Rakuten (specialist agents across product, sales, marketing, and finance) and KPMG (Digital Gateway Powered by Claude for tax and private equity clients).
How does Anthropic’s agent strategy differ from OpenAI and Google?
Anthropic uses a tool-centric orchestration approach, embedding its agent runtime inside existing tools via composable APIs and the Model Context Protocol (MCP). OpenAI chose vertical integration with Workspace Agents, positioning ChatGPT as the central hub. Google chose platform depth with the Gemini Enterprise Agent Platform and Workspace Intelligence semantic layer. Anthropic’s approach does not require users to change platforms — the agent shows up where they already work.
What percentage of enterprise apps will have embedded AI agents by end of 2026?
Gartner predicts that 40% of enterprise applications will include embedded task-specific agents by the end of 2026, up from less than 5% in 2025. However, fewer than one in nine enterprises currently run agents in production at scale, suggesting significant growth ahead.
Can Claude Managed Agents run inside a private network?
Yes. CMA supports self-hosted sandboxes through partners including Cloudflare, Daytona, Modal, and Vercel, or custom VPC deployments. MCP tunnels allow agents to connect to private Model Context Protocol servers inside your network without public exposure. A Vaults system keeps credentials out of the sandbox using envelope encryption.
Direct answer (October 2026): Headline API rates did not move when Fable 5.1 shipped on September 1. Both Fable 5 and Fable 5.1 list at $10 / MTok input and $50 / MTok output. The change that matters for agent loops is cache: Fable 5.1 cache reads are $0.25 / MTok versus $1.00 / MTok on Fable 5. On claude.ai, Fable is included only on Max and premium Team/Enterprise seats, and only up to 50% of the weekly usage pool. Pro and Team Standard pay usage credits from the first Fable token.
API rates
USD per million tokens. Context window 1M. Max output 128K. No long-context surcharge on the published card.
Item
Fable 5
Fable 5.1
API ID
claude-fable-5
claude-fable-5-1
Input
$10
$10
Output
$50
$50
5-min cache write
$12.50
$12.50
1-hour cache write
$20
$20
Cache read
$1.00
$0.25
Batch in / out
$5 / $25
$5 / $25
That cache-read cut is the Sep 1 price event. Stable system prompts and repo prefixes that hit cache on 5.1 cost a quarter of what they cost on 5. Headline input/output is unchanged, so a cold one-shot is the same bill.
Opus 5.5 (current, shipped Sep 22, 2026) is $4 / $20. Opus 5 remains listed at $5 / $25. Sonnet 5.5 is the current Sonnet at $2 / $10 (cache read $0.10; shipped Sep 28, 2026). Haiku 5.5 is the current Haiku, from $0.10 / $0.50 (prompts up to 100K tokens). Sonnet 5 remains listed at the same $2 / $10 after Anthropic cancelled the scheduled Sep 1 step to $3 / $15. Against current Opus 5.5, Fable is 2.5× on list rates ($10/$50 vs $4/$20); against legacy Opus 5 it is still 2×.
Max, Team Premium, Enterprise Premium seats: included. Cap is 50% of weekly usage limits. Same weekly pool as every other model. Fable burns that pool faster. After the cap: usage credits or switch models.
Pro and Team Standard: not included. Credits from token one. The July 2026 $100 one-time credit was for the Fable 5 plan change only. Help Center: no equivalent credit for 5.1.
Enterprise Standard seats: only if the org turns credits on.
Fable 5.1 launched September 1, 2026 with Mythos 5.1. Same underlying model, different safeguards. Anthropic positions 5.1 for long coding and knowledge work. US-only inference is listed at 1.1× input and output. Availability: Claude API, Bedrock, Google Cloud, Microsoft Foundry, and paid claude.ai plans under the rules above.
What the cache change is worth in dollars
Direct answer: Fable 5.1’s headline rates didn’t move ($10 input / $50 output per million tokens), but cache reads fell 75% — from $1.00 to $0.25 per million. On workloads that re-read context, that’s the whole story.
Worked example — one agent loop day: 10M input tokens at a 90% cache-hit rate, plus 1M output tokens.
Fable 5.1: $10.00 fresh input, plus 9M cache reads × $0.25 = $2.25, plus $50.00 output. Total: $62.25.
The cache-read line alone drops from $9.00 to $2.25. Push the hit rate to 95% and the gap widens further — the more your loop re-reads its own context, the more 5.1 pulls away. A fresh prompt with no cache history costs exactly the same on both versions.
Fable 5.1 against the lineup
USD per million tokens, standard API processing. Cache-write column is the 5-minute rate.
Model
Input
Output
Cache read
Cache write (5m)
Fable 5.1
$10.00
$50.00
$0.25
$12.50
Fable 5
$10.00
$50.00
$1.00
$12.50
Opus 5.5
$4.00
$20.00
$0.20
$5.00
Sonnet 5.5 (current)
$2.00
$10.00
$0.10
$2.50
Sonnet 5 (legacy)
$2.00
$10.00
$0.20
$2.50
Haiku 5.5 (current, prompts ≤100K)
$0.10
$0.50
$0.01
$0.125
Haiku 5.5 (prompts >100K)
$0.50
$2.50
$0.05
$0.625
Haiku 4.5 (legacy)
$1.00
$5.00
$0.10
$1.25
Fable 5.1’s cache reads are priced at 0.025× its input rate — 97.5% below base input. Every other model in the table pays the standard 0.10× except Opus 5.5 and Sonnet 5.5 at 0.05×. That unusual cache multiple is Fable’s entire pricing argument.
When Fable is worth it
Pick Fable 5.1 for long-horizon agent loops that re-read large contexts — multi-step research agents, codebase-wide refactors, anything where the same prompt prefix gets re-fed dozens of times. The cache math above is where it earns its rate.
Pick something else when the workload doesn’t fit: interactive coding sessions belong on Sonnet 5.5 ($2/$10, current Sonnet; Sonnet 5 legacy still listed at the same rate after the Sep 1 step was cancelled), maximum reasoning per dollar is Opus 5.5 ($4/$20), and high-volume simple tasks are Haiku 5.5 (from $0.10/$0.50; Haiku 4.5 is legacy at $1/$5).
On claude.ai plans the calculus shifts: Fable rides inside Max and premium Team/Enterprise seats (capped at half the weekly pool), so plan users should think in pool-share, not tokens. API users think in tokens. Full seat and API pricing lives on our Claude AI pricing guide; model-to-model reasoning comparisons are in the Claude models comparison, and token-level API detail is in Claude API pricing, token costs and rate limits.
FAQ
Did Fable get cheaper on September 1?
Not on headline tokens. Cache reads on 5.1 dropped from $1.00 to $0.25 per million. Repeated agent context is cheaper. A fresh prompt is not.
Does Pro include Fable 5.1?
No. Pro can call it with usage credits. Included Fable lives on Max and premium seats only, and only up to half the weekly limit.
Is Fable 5.1 2.5× Opus 5.5 (and 2× legacy Opus 5)?
Against current Opus 5.5 ($4/$20), Fable at $10/$50 is 2.5× on list rates. Against legacy Opus 5 ($5/$25) it is still 2×. Opus 5 Fast mode lists at Fable’s standard rate. Pick Fable when the job is long-horizon and you have Max/premium inclusion or a reason to pay the cache-aware API bill.
Does the Batch API discount apply to Fable?
Yes. Anthropic’s Batch API takes 50% off standard rates across models, Fable included — roughly $5/$25 per million input/output tokens on Fable 5.1 for non-urgent work. Cache-read pricing discounts stack on top.
Do cache writes cost extra on Fable 5.1?
Yes, one line item to know: 5-minute cache writes are $12.50 per million (1.25× input), 1-hour writes are $20 (2× input). You pay the write once when the cache entry is created; every re-read after that bills at the $0.25 cache-read rate. Writes are a footnote — reads are the story.
How does the 50% weekly pool cap work for Fable on Max?
Max and premium Team/Enterprise seats include Fable, but only up to half of the weekly usage pool — Fable can’t consume the whole allowance. Past the cap, further Fable usage bills as usage credits from the first token. If Fable is your daily driver on a plan, watch the pool split, not just the total.
The Message Batches API lets you submit up to 100,000 Claude requests in a single call and receive results asynchronously — at exactly 50% of standard token prices. Most batches finish in under an hour. Results remain downloadable for 29 days. This page covers every verified limit, the per-tier rate limit tables, and how batch pricing stacks with prompt caching.
Pricing: 50% off standard rates
Batch pricing — half-rate framing without sticky dollars.
Every token processed through the Message Batches API is billed at half the standard input and output price. No quality difference from synchronous requests — only timing. The table below shows verified batch prices for active models.
Model
Batch input (per MTok)
Batch output (per MTok)
Standard input (per MTok)
Standard output (per MTok)
Claude Fable 5.1
$5.00
$25.00
$10.00
$50.00
Claude Opus 5.5
$2.00
$10.00
$4.00
$20.00
Claude Sonnet 5.5
$1.00
$5.00
$2.00
$10.00
Claude Haiku 4.5
$0.50
$2.50
$1.00
$5.00
Older models (Opus 4.5–5, Sonnet 4.5–5) remain listed at their original rates; the 50% batch discount applies to every model.
A batch expires if processing has not completed within 24 hours. Any individual request within that batch that did not finish is marked expired — you are not billed for expired or errored requests. Batch results (the JSONL file) are accessible for download for 29 days after the batch was created; after that the batch object itself is still visible but results can no longer be downloaded.
Message Batches API rate limits
The Message Batches API has its own rate-limit pool, shared across all models, separate from the standard Messages API limits. The “processing queue” count refers to individual batch requests (not batches) that have been submitted but not yet completed by the model. Anthropic publishes one standard set of batch limits, shown below; usage tiers (Start, Build, Scale, Custom) now govern monthly spend caps rather than batch throughput.
RPM here limits how fast you can make HTTP requests to the Batches API endpoints (create, retrieve, list, cancel). It does not limit how many individual requests inside a batch are processed per minute — that is governed by the queue cap above. If high demand causes processing to slow, more individual requests within a batch may reach the 24-hour expiration limit.
Stacking batch pricing with prompt caching
The Batches API documentation explicitly states that the 50% batch discount and prompt caching discounts stack. Cache writes incur a one-time cost at 1.25x the base input rate (5-minute TTL) or 2x (1-hour TTL); subsequent cache reads cost 0.1x the base input rate on most models (0.05x on Opus 5.5). Because batches process asynchronously and may take longer than 5 minutes, Anthropic recommends using the 1-hour cache duration for batch requests that share large context.
The following example uses Claude Opus 5.5 (standard input: $4.00/MTok) to show what each token type costs in a batch with a 1-hour cached system prompt.
Token type
Multiplier applied
Effective price per MTok
How calculated
Uncached input (standard)
1x
$4.00
Baseline
Uncached input (batch)
0.5x
$2.00
50% batch discount
Cache write — 1h TTL (batch)
2x × 0.5x = 1x
$4.00
2x write cost, then 50% batch
Cache read (batch)
0.05x × 0.5x = 0.025x
$0.10
5% read cost, then 50% batch
Output (batch)
0.5x of $20.00
$10.00
50% batch discount on output
In practice: if you cache a 50,000-token system prompt once and then read it across 1,000 batch requests, the cache write costs $0.20 (50K tokens at $4.00/MTok effective), while 1,000 cache reads cost $5.00 total (50M tokens at $0.10/MTok). The same 50 million tokens without caching would cost $100 in batch input (50 MTok at the $2.00/MTok batch rate). Cache hit rates on batches vary; Anthropic’s documentation notes typical rates of 30% to 98% depending on traffic patterns, since batch requests are processed concurrently rather than sequentially.
How results come back
How results come back from Message Batches.
When the batch finishes (or the 24-hour limit is reached), a results_url property is set on the batch object. Results are in JSONL format — one JSON object per line, in any order (not necessarily matching submission order). Each result carries the custom_id you assigned, plus a result object of type succeeded, errored, canceled, or expired. Streaming the results file rather than downloading it all at once is recommended for large batches. You are not billed for errored, canceled, or expired requests.
Does the Batches API count against my standard Messages API rate limits?
No. The Message Batches API has its own rate-limit pool that is tracked separately from the standard Messages API RPM, ITPM, and OTPM limits. You can use both simultaneously up to their respective limits.
What happens if my batch does not finish within 24 hours?
Any individual requests within the batch that did not complete are marked expired. You are not billed for those requests. The batch itself moves to ended status and whatever results did complete are available at the results_url.
Can I use extended thinking, tool use, or vision in a batch?
Yes. The Batches API supports vision, tool use (including server tools such as web search and code execution), system messages, multi-turn conversations, and extended thinking. The parameters not supported are stream: true, fast mode (speed), Threads parameters, and max_tokens: 0.
How long are batch results available for download?
Results are available for 29 days after the batch was created. After that window, the batch object remains visible in the Console and via the API, but the results file can no longer be downloaded.
Is the Batches API eligible for Zero Data Retention?
No. The Message Batches API is explicitly excluded from Zero Data Retention (ZDR). Data is retained under the feature’s standard retention policy regardless of your organization’s ZDR settings.
Run your batches from the Anthropic Console — API keys, billing, and a token-to-dollar cost estimator that shows what 50%-off batch pricing does to your actual workload.
