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 Enterprise starts at $20/seat/month for access, but actual spend runs $60–250+ per user depending on usage — because tokens are billed separately at API rates. The ROI calculation isn’t about the seat fee. It’s about whether the productivity return on active usage exceeds the total consumption cost.
This is a practical ROI framework for business decision-makers evaluating Claude Enterprise in 2026. It covers what the pricing actually includes, how to model real cost, and what the productivity return looks like across different team roles.
What Claude Enterprise Actually Costs in 2026
Enterprise pricing changed in April 2026: Anthropic decoupled seat fees from token bundles. The headline price is $20/seat/month, but that covers access only — every token consumed by every user is billed separately at standard API rates.
This is a meaningful structural change from the pre-2026 model, where Enterprise seats included bundled token allocations. Under the current model:
Component
Cost
Seat fee
~$20/user/month (annual, contact sales)
Token usage — Haiku 4.5
$0.80 input / $4 output per 1M tokens
Token usage — Sonnet 4.6
$3 input / $15 output per 1M tokens
Token usage — Opus 4.8
$15 input / $75 output per 1M tokens
Claude Code (premium seat)
$100/seat/month (annual)
Minimum seats
Custom, typically 20+ for sales-assisted
Compare this to Claude Team:
Plan
Seat Cost
Token Model
Cap
Team Standard
$20/seat/mo (annual)
Bundled — included in seat
150 users
Team Premium (with Claude Code)
$100/seat/mo (annual)
Bundled
150 users
Enterprise
~$20/seat + API usage
Metered separately
None
Team is predictable cost with a usage ceiling. Enterprise is variable cost with no ceiling and no cap. The right choice depends on your compliance requirements and usage intensity, not just team size.
The Real Cost Per Active User
Real cost per active user — model seats, not sticker shock.
The most important number is not the seat price — it’s the real cost per active user, which is seat fee plus token consumption. At 10% seat adoption, your effective cost per active user is 10x the headline seat price.
Adoption rate determines economics:
Team size
Active users (40% adoption)
Monthly seat cost
Token cost (moderate usage)
Total / active user
50 seats
20
$1,000
~$800
~$90
100 seats
40
$2,000
~$1,600
~$90
500 seats
200
$10,000
~$8,000
~$90
At 10% adoption (a common early-deployment reality):
Team size
Active users
Monthly seat cost
Token cost
Total / active user
100 seats
10
$2,000
~$400
~$240
The implication: increasing adoption from 10% to 40% is a higher-ROI move than adding seats. An adoption problem looks like an economics problem but isn’t.
What the Productivity Return Looks Like
Productivity return depends on the job shape.
Industry estimates put the productivity upside at $7,800 per employee per year — but that figure only materializes when Claude is actively integrated into daily workflows, not when it’s available as an optional chat tab.
The $7,800/employee figure comes from enterprise AI ROI research measuring time saved across knowledge work tasks. It assumes genuine integration into workflows, not passive availability. Here’s how it breaks down by role:
Software developers (highest ROI):
Agentic coding with Claude Code reduces code review cycles, test writing, and boilerplate
Estimated 1.5–2 hours/day returned on routine coding tasks
At $100K loaded annual salary: ~$9,000–12,000/year in time value per developer
Content and marketing teams:
Drafting, editing, research, brief writing at significantly higher speed
Estimated 45–90 minutes/day returned on writing-heavy tasks
At $75K loaded: ~$5,600–11,200/year per person
Legal and compliance teams:
Contract review, policy drafting, compliance checklist work
Estimated 30–60 minutes/day returned
At $120K loaded: ~$7,500–15,000/year per lawyer or compliance analyst
Operations and admin:
SOPs, reporting, email drafting, meeting prep
Estimated 20–30 minutes/day returned
At $60K loaded: ~$2,500–3,750/year
The ROI Model
A simple ROI model: (hours returned per user per day × working days × loaded hourly rate) − annual total cost per user = net annual value per seat.
Example for a 50-person software team on Enterprise:
Loaded developer salary: $120,000/year = ~$57.70/hour
Hours returned per day (conservative): 1 hour
Working days: 230
Value returned per developer: 230 × $57.70 = $13,271/year
Annual Enterprise cost per developer:
Seat fee: $20 × 12 = $240
Token cost (moderate Sonnet usage): ~$600/year
Total per developer: ~$840/year
Net ROI per developer: $13,271 − $840 = $12,431
ROI multiple: 15.8x
Even at half the productivity estimate (30 minutes/day returned), the ROI multiple remains above 7x for any knowledge worker with a loaded salary above $60K. The economics are compelling when adoption is real.
When Enterprise Is the Right Choice vs. Team
When Enterprise is right vs Team.
Choose Enterprise when you have a compliance mandate (SSO, SCIM, audit logs, HIPAA), a team above 150 users, or a negotiated consumption commitment that reduces effective per-token cost. Otherwise, Team is more predictable and sufficient.
Need
Team
Enterprise
SSO / SAML authentication
✗
✓
SCIM provisioning
✗
✓
Audit logs
✗
✓
HIPAA-ready configuration
✗
✓
Compliance API (export to SIEM)
✗
✓
Users above 150
✗
✓
Fixed predictable monthly cost
✓
✗
Usage bundled in seat price
✓
✗
The honest rule: buy Team until a real compliance or scale requirement forces Enterprise. If security review, identity governance, or audit trails are requirements, Enterprise is necessary. If they’re not, Team is cheaper and simpler.
Claude Enterprise starts at approximately $20/user/month for access (billed annually, custom via sales), with token usage billed separately at standard API rates. Real total cost typically runs $60–250+/user/month depending on usage intensity and which Claude models the team uses most.
What’s the difference between Claude Team and Enterprise?
Team is self-serve per-seat licensing ($20 standard / $100 premium per seat/month, annual) with token usage bundled into the seat and a 150-user cap. Enterprise adds SSO, SCIM, audit logs, HIPAA support, a Compliance API for SIEM integration, no user cap, and usage billed separately at API rates. Choose Team for simplicity; choose Enterprise for compliance and governance requirements.
What is the ROI of Claude Enterprise?
At 1 hour of productivity returned per day per knowledge worker, the annual value per seat at a $120K loaded developer salary is approximately $13,270 — against an annual Enterprise cost of ~$840/developer. ROI multiple is roughly 15x under that assumption. At 30 minutes/day returned, the multiple is still above 7x for most knowledge worker salaries.
Why did Anthropic unbundle tokens from Enterprise seats?
Anthropic decoupled seat fees from token bundles in April 2026, lowering the headline seat price from $40–200/seat to $20/seat while making token usage variable. The change gives large organizations more flexibility — light users cost less, heavy users cost more — but requires better usage monitoring to forecast actual spend.
Claude wins on coding quality and long-context reliability. GPT-5 wins on raw speed and cost per token. The right choice depends on which workload you’re optimizing for — and for most serious agentic coding workflows, Claude is the default for good reasons.
This comparison covers the metrics that matter for production API decisions in 2026: pricing at each tier, latency benchmarks, coding benchmark scores, context window handling, and where each model actually performs better. No marketing claims — just the numbers and where they point.
The Models Being Compared
Compare APIs by job shape — not by hype.
The relevant comparison in 2026 is Claude Sonnet 4.6 / Opus 4.8 against GPT-5 / GPT-5.5 — the mid-tier workhorses and frontier flagships from each lab.
Model
Provider
Input (per 1M tokens)
Output (per 1M tokens)
Context
Claude Haiku 4.5
Anthropic
$0.80
$4
1M tokens
Claude Sonnet 4.6
Anthropic
$3
$15
1M tokens
Claude Opus 4.8
Anthropic
$15
$75
1M tokens
GPT-5
OpenAI
$1.25
$10
400K tokens
GPT-5.5
OpenAI
$5
$30
1M tokens
The pricing gap is the first thing to understand: GPT-5 is cheaper per token than Claude Sonnet at every tier. Claude Opus is the most expensive flagship at any lab. That cost difference only makes sense if the quality difference justifies it — and for specific workloads, it does.
Coding Performance
Claude leads on coding benchmarks in 2026. Claude Sonnet scores approximately 77% on SWE-bench Verified versus roughly 72% for GPT-5. Claude Opus 4.8 and Fable 5 push higher still — Fable 5 is the current leader on AutomationBench.
SWE-bench Verified measures a model’s ability to solve real GitHub issues — fixing bugs, implementing features, navigating existing codebases. It’s the most production-relevant coding benchmark available.
Why Claude leads on coding:
Better multi-step refactor reliability on large codebases
Stronger instruction-following in complex, multi-constraint prompts
More consistent behavior across long agentic loops without drift
Claude Code and Cursor both default to Claude models — a market signal that carries weight
Where GPT-5 is competitive on coding:
Faster time-to-first-token for autocomplete-style workloads
GPT-5.5’s terminal-based coding benchmark (Terminal-Bench: 82.7%) is strong
Codex — OpenAI’s coding-specific deployment — is built on GPT-5.5 and optimized for that workload
The practical rule: for interactive coding assistance and agentic code execution, Claude Opus or Sonnet. For high-frequency autocomplete at scale where speed matters more than quality depth, GPT-5 mini or Haiku-class models.
Latency
GPT-5 is faster. OpenAI generally delivers 80–110 tokens per second on GPT-5; Claude Sonnet runs 60–90. Claude Haiku 4.5 is the fastest model in this comparison — first token in under 600ms on medium prompts, outpacing GPT-4.1 Mini by roughly 4x in March 2026 benchmarks.
Latency matters differently depending on the use case:
Use case
Which latency matters
Winner
Interactive chat / autocomplete
Time-to-first-token
GPT-5 (or Claude Haiku)
Agentic batch processing
Throughput, quality
Claude Sonnet / Opus
Long-context document analysis
Context handling
Claude (1M vs GPT-5’s 400K)
Real-time voice pipeline
TTFT + throughput
OpenAI Realtime API (no Claude equivalent)
For most production agentic workflows where the agent is running asynchronously, the latency difference between Claude Sonnet and GPT-5 is negligible compared to the quality difference on complex tasks.
Context Window
Context window and output limits are different ceilings.
Claude’s 1M token context window is a meaningful technical advantage over GPT-5’s 400K. At 1M tokens, entire medium-sized codebases, full legal contract libraries, or complete email archives fit in a single context without chunking or retrieval engineering.
GPT-5.5 also ships with a 1M context window, but at $5/$30 per million tokens compared to Claude Sonnet at $3/$15. For long-context workloads where you need the full window, Claude Sonnet is both more capable and cheaper than GPT-5.5.
Practical implications of the context gap at the mid-tier (Claude Sonnet vs GPT-5):
Codebases over 300K tokens: Claude handles them without chunking; GPT-5 requires retrieval engineering
Long contract or document review: Claude reads the full document in one pass
Multi-session agent context: Claude Managed Agents with memory handles this; GPT-5 requires custom solutions
Cost Comparison for Real Workloads
OpenAI is cheaper per token at every tier, but Claude’s 90% prompt caching discount and batch API 50% discount close the gap significantly for production workloads with repeated system prompts.
Workload cost comparison at scale:
Workload
Claude Sonnet
GPT-5
Notes
10K daily chat queries (~500 tokens avg)
~$15/day
~$6.25/day
GPT-5 cheaper
Same, with 80% prompt caching
~$4.50/day
—
No GPT-5 equivalent discount
100M tokens/month agentic batch
~$1,500
~$625
GPT-5 cheaper without caching
Same, with Claude batch API (50% off)
~$750
~$625
Near parity
The conclusion: for high-volume workloads with repeated context (system prompts, persistent agent instructions), Claude’s caching discounts make it competitive with GPT-5 on cost. For simple, stateless, high-frequency calls with no repeated context, GPT-5 is cheaper.
Tool Use and Agent Reliability
Claude is the dominant choice for agentic tool use in 2026. The Claude Agent SDK, Managed Agents platform, and Claude Code are purpose-built for autonomous multi-step workflows. OpenAI has function calling and a code interpreter, but no equivalent managed agent infrastructure.
Where this matters in practice:
Claude Code and Cursor lean on Claude because the model follows multi-step instructions with better consistency
Claude Managed Agents runs cloud-sandboxed agents with persistent memory, built-in tools, and multi-agent coordination — OpenAI has no direct equivalent
For complex tool-use chains where the agent needs to recover from errors and continue, Claude’s behavior is more reliable
Where OpenAI has an edge:
Computer Use is available natively on GPT-5 for web browsing and desktop control workflows
OpenAI’s Realtime API integrates speech-to-text, LLM, and text-to-speech in one pipeline — no Claude equivalent exists
Which API to Choose
Which API to choose depends on the workload class.
Use Claude for: coding, long-context document work, agentic workflows, and anything where instruction-following quality matters more than cost per token. Use GPT-5 for: high-frequency stateless calls, voice pipeline integration, and workloads where cost is the primary constraint.
Decision framework:
If your primary need is…
Choose
Agentic coding and multi-step execution
Claude Sonnet / Opus
Long-context document analysis (>400K tokens)
Claude Sonnet
High-volume, cheap inference at scale
GPT-5 / Claude Haiku
Voice + LLM pipeline
OpenAI Realtime API
Production agent with persistent memory
Claude Managed Agents
Terminal-based coding workload
GPT-5.5 / Codex
The most common real-world answer: Claude Sonnet for the reasoning-heavy core, Claude Haiku or GPT-5 for high-frequency auxiliary calls where speed and cost dominate. Running both APIs is normal and often optimal.
Yes, on most production coding benchmarks. Claude Sonnet scores approximately 77% on SWE-bench Verified versus about 72% for GPT-5. Claude also handles multi-step refactoring and large codebase navigation more reliably. GPT-5.5 on Terminal-Bench (82.7%) is competitive for terminal-based workflows, and OpenAI’s Codex is optimized for that use case.
Is Claude more expensive than GPT-5?
Per token, yes — Claude Sonnet is $3/$15 per million tokens versus GPT-5 at $1.25/$10. Claude’s prompt caching (up to 90% off cached input) and batch API (50% off) close the gap significantly for production workloads with repeated context. Opus is the most expensive flagship model available.
Does Claude have a larger context window than GPT-5?
Yes at the mid-tier. Claude Sonnet has a 1M token context window; GPT-5 has 400K. GPT-5.5 also offers 1M tokens but at a higher price than Claude Sonnet. For workloads requiring full-document context without chunking, Claude Sonnet is the better mid-tier choice.
Which API is faster?
GPT-5 is faster on raw throughput (80–110 tokens/second vs Claude Sonnet’s 60–90). Claude Haiku 4.5 is the fastest model in this comparison for time-to-first-token. For most asynchronous agentic workloads, latency differences are less significant than quality differences.
A local vector database Claude setup — indexed with your business documents, contracts, SOPs, client notes, and invoices — gives back the operational time lost to hunting through folders. The right answer appears in seconds, without any of those documents leaving the machine.
This is the full build: architecture, tools, working code, what performs well in production, what breaks, and whether the ROI justifies the setup time.
What Problem This Solves
The problem isn’t that the documents don’t exist. It’s that finding the right one — the specific contract clause, the pricing from eight months ago, the onboarding SOP for a client — takes longer than it should, and normal search doesn’t solve it.
File search matches keywords. It doesn’t understand that “what did we agree on for payment timing” and “net 30” are the same thing. A retrieval-augmented setup solves the semantic gap: the vector database finds relevant sections by meaning, Claude synthesizes them into a direct answer.
The use cases where this setup pays for itself:
Contract and clause lookup — “What are the payment terms in the Acme agreement?” in 4 seconds vs. 3 minutes of folder navigation
SOP retrieval — “What’s our onboarding process for new social media clients?” surfaces the relevant runbook section directly
Client history — “What scope did we quote [client] last spring?” retrieves the invoice or email thread
Cross-document synthesis — “What are the termination clauses across all active client contracts?” — something no file search can do
The Architecture
Architecture: business files into a local vector index.
The stack is ChromaDB for local vector storage, Nomic Embed for on-device embeddings via Ollama, LlamaIndex for document ingestion, and Claude Sonnet via API for the reasoning step — all files stay local, Claude only sees the retrieved chunks.
Component
Tool
Why
Vector database
ChromaDB (local)
Free, runs on-device, persistent to disk
Embedding model
Nomic Embed via Ollama
Open-source, 8K context, no external calls
Ingestion layer
LlamaIndex
Handles PDF, DOCX, MD, TXT, CSV natively
Retrieval layer
Python (custom)
Readable and modifiable as needs evolve
Reasoning layer
Claude Sonnet API
Materially better synthesis than local models
Interface
CLI
Most queries don’t need a UI
Why local for the vector database: The documents never leave the machine. Claude receives only the retrieved chunks — not the full corpus. For contracts, financial records, and internal communications, this is the right boundary.
Why Claude for reasoning and not a local model: Local models (Llama 3, Mistral) handle the retrieval step comparably. They don’t handle synthesis comparably — reading five contract sections and returning a coherent, accurate answer is where Claude’s API cost is earned.
What to Index
Start with the 50 most-referenced documents. Get the workflow running and verified before expanding to the full corpus.
File types that index well:
Contracts and agreements (PDF, DOCX)
Internal SOPs and runbooks (MD, DOCX)
Client notes and meeting logs (MD, TXT)
Invoices and financial records (PDF, CSV)
Email threads exported from Gmail (EML, TXT)
Organize before indexing. File names and folder paths become metadata attached to each chunk. A consistent folder structure takes an hour to set up and improves retrieval quality throughout:
500 files on an M2 MacBook Pro takes approximately 20–25 minutes. The index persists to disk — this runs once, then incrementally as files change.
Step 3: Build retrieval and reasoning
import anthropic
def query_business_knowledge(question: str, top_k: int = 5) -> str:
retriever = index.as_retriever(similarity_top_k=top_k)
nodes = retriever.retrieve(question)
context = "\n\n---\n\n".join([
f"Source: {node.metadata.get('file_name', 'unknown')}\n{node.text}"
for node in nodes
])
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1000,
messages=[{
"role": "user",
"content": f"""Answer this question using only the provided business documents.
If the answer isn't in the documents, say so clearly. Always cite the source file.
Question: {question}
Documents:
{context}"""
}]
)
return response.content[0].text
print(query_business_knowledge("What are the payment terms in the Acme contract?"))
Always include source attribution in the prompt. When an answer returns, the source file name makes verification fast.
What Works Well in Production
What works well in production — narrow corpora first.
Cross-document synthesis is the capability that justifies this over standard search — querying across hundreds of files simultaneously to find patterns, compare terms, or surface a specific clause is something no file search does.
Where the system consistently delivers:
Contract and clause lookup: Specific clause retrieval across a full contract library. Synthesis across multiple contracts simultaneously (termination terms, payment terms, liability caps) returns a summary across all of them at once.
SOP and runbook retrieval: Operational questions answered directly from internal documentation. Works best when SOPs are written in complete sentences rather than bullet fragments — the retrieval quality reflects the writing quality.
Client history: Invoice amounts, quoted scopes, prior project notes. Email threads sometimes split across chunks in ways that lose context — use the result as a pointer to the source document, then verify.
Cross-document pattern finding: “What are the common liability terms across our contracts?” — synthesizes across every indexed contract in one response. No file search tool does this.
What Breaks
What breaks — bad chunks and untrusted documents.
The index is only as current as the last re-index. The most common production failure is stale data — documents updated after the last index run return old answers.
Stale index: Build re-indexing into the workflow immediately. Schedule it weekly, or trigger it automatically when files are modified. Documents that change and don’t get re-indexed are the biggest reliability risk.
Top-k ceiling: Retrieval returns the top-k chunks (default 5). A question whose complete answer requires synthesizing 20 documents gets a partial answer. Increase top_k for broad synthesis questions — at the cost of slightly more API token usage.
Numerical calculations: The system finds financial documents reliably. It should not be trusted to calculate totals across extracted text. Use it to surface the right source documents; do the arithmetic elsewhere.
Documentation debt: The index reveals gaps in internal documentation. SOPs written in ambiguous shorthand, contracts with undefined terms, emails with unclear context — all produce lower quality retrieval. The index reflects the quality of the underlying documents.
Chunk Size
512 tokens with 50-token overlap is the right starting point for mixed document types.
Financial records (tabular): Parse as structured data where possible; plain text chunking loses table relationships
Metadata Filtering at Scale
Once the corpus exceeds ~200 files, adding metadata to chunks and filtering at query time significantly improves precision.
# Tag at ingestion
documents = SimpleDirectoryReader(
"./business-knowledge",
recursive=True,
file_metadata=lambda filepath: {
"document_type": filepath.split("/")[2],
"client": filepath.split("/")[3] if len(filepath.split("/")) > 3 else "internal"
}
).load_data()
# Filter at retrieval
retriever = index.as_retriever(
similarity_top_k=5,
filters={"document_type": "contracts"}
)
“What are our SOPs for [client]?” filtered to that client’s folder returns meaningfully more accurate results than querying the full corpus.
ROI
Setup takes roughly one full day. At 25 minutes saved per week on document lookups, break-even is approximately 6–8 weeks.
Item
Cost
Setup time
~8 hours
ChromaDB
Free
Nomic Embed (Ollama)
Free
Claude Sonnet API per query
~$0.003
Monthly at 50 queries/week
~$0.60
Weekly time saved
~25 minutes
Break-even
~7 weeks
The less quantifiable return: operational confidence. Questions that previously required folder-hunting get answered in seconds. That reduces the cognitive overhead of running a multi-client operation and changes how quickly decisions get made.
No. The vector database and embedding model run locally. Claude receives only the retrieved chunks — small sections of relevant documents — not the full corpus. For zero external calls, replace Claude with a local model, though synthesis quality will be lower.
What file types are supported?
LlamaIndex handles PDF, DOCX, TXT, MD, CSV, EML, and HTML natively. Other formats need conversion to plain text first.
How long does indexing take?
Approximately 20–25 minutes for 500 files on an M2 MacBook Pro. Subsequent re-indexing processes only changed or new files and takes a few minutes.
What is a vector database?
A vector database stores documents as numerical representations (embeddings) that encode meaning, not just keywords. This allows semantic search — finding relevant contract sections from a natural-language question, even when the exact words don’t match.
Can a local model replace Claude?
es — swap the API call for an Ollama-hosted model. Retrieval quality is comparable. Synthesis quality on complex multi-document questions is noticeably lower on current local models.
What chunk size should be used?
512 tokens with 50-token overlap is the right default for mixed document types. Adjust for document type: larger for dense contracts, smaller for short emails.
Metricool 2026 is a social media scheduling, analytics, and API platform that manages multi-brand operations across LinkedIn, Facebook, Instagram, X/Twitter, Google Business Profile, TikTok, YouTube, Pinterest, Threads, and Bluesky — at a price point that makes Hootsuite and Sprout Social look overpriced for most use cases.
This guide covers what changed in 2025–2026, how to set up the platform correctly from day one, how to use the API for programmatic scheduling, and where the tool still falls short. Built from operating 24 brands in Metricool, not from a comparison of their marketing pages.
What Is Metricool and What Does It Do in 2026?
What Metricool is and does in 2026.
Metricool is a social media management platform organized around “brands” as the core unit — one login manages multiple brands, each with its own calendar, analytics, and connected accounts, at plan-based pricing that doesn’t scale per connected account.
Platform support as of August 2026:
Platform
Scheduling
Analytics
API Access
LinkedIn (profile + page)
✓
✓
✓
Facebook (page)
✓
✓
✓
Instagram (business/creator)
✓
✓
✓
X / Twitter
✓
✓
✓
Google Business Profile
✓
✓
✓
TikTok
✓
✓
✓
YouTube
✓
✓
✓
Pinterest
✓
✓
✓
Threads
✓
Limited
✓
Bluesky
✓
Limited
✓
The core value proposition is unchanged: multi-brand management at plan-based pricing (not per-seat or per-connected-account), with a working REST API that most competitors at the same price point don’t offer.
What’s New in Metricool in 2025–2026
The biggest 2026 updates are Threads and Bluesky as stable scheduling platforms, a rebuilt analytics dashboard, AI caption suggestions in the composer, and a versioned API developer portal replacing the old PDF documentation.
Threads scheduling (stable): Moved from beta to fully stable. Posts with images, text, and links schedule and publish reliably. Analytics remain limited relative to Instagram — engagement data is available but not at native-insight depth.
Bluesky scheduling (stable): Full scheduling and basic analytics now live. Handles the platform without a separate tool.
Analytics dashboard redesign: Cross-platform comparison views are cleaner. Custom date ranges now set on the overview screen without drilling into individual platform tabs first.
AI caption suggestions: Available inside the post composer for first-draft generation. Useful for routine content; not a replacement for intentional copy.
API developer portal: Documentation moved from a downloadable PDF to a versioned web portal. Same endpoints, significantly easier to navigate.
How to Set Up Metricool Correctly
How to set up Metricool correctly.
Create one brand per entity, connect all social accounts for that brand before creating the next one, and establish posting cadence in the Planner before importing any bulk content. Setup decisions made incorrectly early create restructuring work later.
Step 1: Create brands
Navigate to the brand switcher in the top left and create a new brand for each business, client, or property. Name each brand clearly — the name appears in the interface and in API responses as the brand identifier. Each brand is an isolated workspace: separate calendar, separate analytics, separate connected accounts.
Step 2: Connect social accounts per brand
With a brand selected, link every social platform before moving to the next brand. Common friction points:
Instagram: Requires a Professional account (Business or Creator) linked to a Facebook Page. Personal Instagram accounts cannot be scheduled through third-party tools. If the Facebook Page isn’t connected first, Instagram won’t link.
LinkedIn: Personal profiles and Company Pages connect separately. Add both if scheduling to both.
Google Business Profile: Connect via Google account. GBP posts are limited to 1,500 characters and one image — Metricool enforces this in the composer.
Step 3: Configure the Planner
The Planner is the scheduling interface used most. Access it from the left navigation. Best-time recommendations appear as highlighted slots based on historical engagement data — worth following for the first few months before overriding with observed data.
Step 4: Enable post failure notifications
When a scheduled post fails — usually because a platform connection expired — the right time to know is immediately, not when a client asks why content didn’t go out.
How the Metricool Planner Works
Click a time slot or use the New Post button, write the caption, attach media, select platforms, set the publish time, and Metricool handles publishing across all selected channels.
Post creation steps:
Click a time slot or New Post
Write the caption — platform previews update in real time on the right
Upload media — Metricool flags aspect ratio issues per platform
Select platforms using the toggles
Set date and time, or accept the best-time recommendation
Click Schedule
Platform previews matter: LinkedIn truncates long captions differently than Instagram. What reads cleanly on one platform can break on another. Always check previews before scheduling.
Bulk scheduling via CSV: Upload a spreadsheet of posts with columns for caption, media URL, platform, date, and time. Right workflow for scheduling a full month at once rather than building post by post.
How Metricool Analytics Works
How Metricool analytics works.
Analytics shows follower growth, engagement, reach, impressions, and best-performing content across all connected platforms — with a unified overview and per-platform deep dives.
Overview dashboard: Aggregated metrics across all platforms for the current brand. Custom date ranges with prior-period comparison. Answers “how is this brand doing overall” without switching tabs.
Per-platform analytics: Post-level performance, follower growth trends, engagement rate over time, audience demographics where platforms expose them, and best-performing content sortable by any metric.
Competitor tracking: Add competitor social profiles for follower count and posting frequency monitoring. Available on paid plans.
What analytics don’t do: Metricool doesn’t integrate with GA4 for web traffic attribution. If connecting social performance to site traffic and conversions is a requirement, a separate analytics tool is needed.
How the Metricool API Works in 2026
The Metricool REST API allows programmatic post scheduling, post retrieval, brand listing, and media management — authenticated via an API token from account settings, with full CRUD operations on scheduled content.
Step 1: Get your API token
Go to account settings and find the API section. Generate a token — it’s account-level, not brand-specific. Treat it like a password.
Step 2: Get brand IDs
GET https://app.metricool.com/api/v2/brands
Authorization: Bearer YOUR_API_TOKEN
Returns an array of brands with IDs, names, and connected platforms. Store these IDs — they’re required on every brand-specific API call.
A successful POST returns the created post object with its ID. Store IDs for any post that may need updating or deletion.
What the API can do: Schedule posts to any connected platform, retrieve scheduled and published posts, list brands and connected networks, upload and attach media, delete or update scheduled posts.
What the API can’t do: Analytics data is not exposed via the API. Engagement metrics are view-only in the dashboard. For analytics in automated workflows, a separate reporting approach is required.
Rate limits: Metricool enforces rate limits per endpoint. For production workflows scheduling at volume, build exponential backoff retry logic on 429 responses.
Metricool Plans and Pricing in 2026
Metricool charges per brand, not per connected social account — which makes it significantly cheaper than Hootsuite or Sprout Social for multi-brand operations.
Plan
Brands
Posts/Month
Team Members
API Access
Free
1
50
1
No
Starter
1
2,000
1
No
Advanced
5
Unlimited
3
Yes
Agency
15+
Unlimited
5+
Yes
API access requires Advanced or above. For a 10-brand operation, Metricool Advanced costs a fraction of the Hootsuite or Sprout Social equivalent, where per-seat or per-account pricing compounds quickly.
Metricool vs. Hootsuite vs. Buffer in 2026
For multi-brand operations managing 5+ brands with API requirements, Metricool wins on price. Buffer is comparable for simple single-brand operations. Hootsuite is justified only at enterprise scale with dedicated support requirements.
Feature
Metricool
Hootsuite
Buffer
Pricing model
Per brand
Per user + per account
Per channel
API access
Yes (Advanced+)
Yes (Enterprise)
Limited
GBP scheduling
Yes
Limited
No
Multi-brand management
Native
Clunky
Basic
Analytics depth
Strong
Strong
Basic
Best for
Agencies, multi-brand operators
Large enterprise
Simple single-brand
Hootsuite for a 10-brand agency operation typically runs 3–5x the cost of Metricool at the equivalent plan level.
Common Metricool Problems and Fixes
The most common issues are expired social connections, Instagram setup errors, and GBP rejection — all fixable in a few steps.
Instagram won’t connect: Switch the account to Professional (Business or Creator) in Instagram settings, connect to a Facebook Page, then reconnect in Metricool.
Scheduled post failed: Look for failed posts in the calendar. The cause is usually an expired connection. Disconnect and reconnect the affected platform, then reschedule.
GBP post rejected: Check the error message — GBP rejections usually include a reason. Verify the post is under 1,500 characters, uses one image, and doesn’t contain promotional language that violates GBP content policies.
API 401 Unauthorized: Token expired or regenerated. Go to account settings, generate a new token, update the integration.
Wrong brand getting content: The most common operational error in multi-brand setups. Confirm the active brand in the switcher before creating or scheduling. Build this check into every team SOP.
Frequently Asked Questions
What is Metricool used for?
Metricool is used for social media scheduling, analytics, and multi-brand management across LinkedIn, Facebook, Instagram, X/Twitter, Google Business Profile, TikTok, YouTube, Pinterest, Threads, and Bluesky — with a REST API for programmatic scheduling.
Is Metricool free?
Yes — a permanent free plan (not a trial) supporting one brand, 50 posts per month, and basic analytics. API access and multi-brand management require a paid plan.
Does Metricool have an API?
Yes. The Metricool REST API supports programmatic post scheduling, retrieval, brand management, and media handling. Available on Advanced plan and above. Documentation is at Metricool’s developer portal.
How does Metricool compare to Hootsuite?
Metricool is 3–5x cheaper for multi-brand operations at agency scale. Hootsuite charges per user and per connected account. Hootsuite has stronger enterprise support and integrations; Metricool wins on value for most agency and mid-market use cases.
Can Metricool schedule Google Business Profile posts?
Yes — and it’s one of Metricool’s strongest differentiators. Most tools at this price point don’t support GBP scheduling. Posts are limited to 1,500 characters and one image.
Does Metricool support Threads and Bluesky?
Yes. Both are fully stable as of 2026. Threads analytics are available but limited. Bluesky analytics are basic. Scheduling to both platforms is reliable.
The Anthropic roadmap 2027 comes into focus after Fable 5 launched in June 2026 as Anthropic’s most capable widely available model — a new Mythos-class tier above Opus — and the signals from Anthropic’s research agenda, model release cadence, and safety roadmap point clearly toward what comes next.
This is a forward-looking read grounded in public signals: what Anthropic has shipped, what they’ve said, and what the patterns suggest for 2027. It’s relevant for developers planning integrations, enterprises making multi-year platform commitments, and anyone tracking where Claude’s capabilities are heading.
Where Anthropic Stands as of Mid-2026
Where Anthropic stands as of mid-2026.
Claude has grown from a single chat model in 2021 to a four-tier family — Haiku, Sonnet, Opus, and the new Mythos class — with a 1-million-token context window, native vision, tool use, Computer Use, extended thinking, and persistent memory across managed agents.
The model lineup as of August 2026:
Tier
Model
Best For
Mythos
Claude Fable 5
Most demanding reasoning, long-horizon agentic work
Opus
Claude Opus 4.8
Flagship reasoning, fallback for Fable 5 safety filters
Sonnet
Claude Sonnet 4.6
Everyday development, high-volume production
Haiku
Claude Haiku 4.5
Fast, cheap, high-throughput
Fable 5 launched June 9, 2026 alongside Claude Mythos 5 — a restricted version available only through Project Glasswing for vetted cybersecurity and infrastructure partners. The distinction matters: Fable 5 is the general-availability frontier model; Mythos 5 is the same model with certain safety filters lifted for specific use cases.
The June 2026 launch was followed by a brief government-imposed deployment pause after Amazon researchers identified a method of prompting Fable 5 to surface software vulnerabilities. Anthropic worked with government partners to add new classifiers and redeployed the model globally July 2, 2026.
What the Fable 5 Launch Signals About 2027
The Fable 5 launch established that Anthropic is building a two-track release model — a general-availability tier with conservative safety filters and a restricted frontier tier for vetted partners — and that cadence will continue into 2027.
Several specific signals point forward:
The Mythos class will expand access. Anthropic said explicitly at Fable 5 launch that Project Glasswing would expand to more vetted partners over time. The current restriction is a staged rollout, not a permanent ceiling. By 2027, Mythos-class access is likely to be more widely available to enterprise customers who can meet Anthropic’s trust and verification requirements.
Safety classifiers will improve. Fable 5 launched with classifiers that trigger on roughly 5% of sessions, routing those queries to Opus 4.8 instead. Anthropic committed to reducing false positives “as more capable models arrive in the coming months.” More capable models arriving implies at least one Mythos/Opus generation release before end of 2026 or early 2027.
Token unbundling sets up the next Enterprise pricing tier. The April 2026 decoupling of Enterprise seat fees from token bundles — moving from $40–200/seat with bundled tokens to $20/seat with usage billed separately — creates a cleaner structure for consumption-based tiers as model capability increases. Expect the 2027 pricing architecture to track closely with Mythos access tiers.
Agentic infrastructure is the platform bet. Managed Agents launched April 8, 2026, Memory entered public beta April 23, and the Agent SDK (formerly Claude Code SDK) now handles the entire agent loop automatically. The infrastructure is being built to support long-running, multi-session, multi-agent workflows. The 2027 roadmap is almost certainly agentic-first.
What Anthropic’s Research Agenda Suggests
Anthropic’s published research priorities — interpretability, Constitutional AI, alignment, and scaling — point toward a 2027 model that is more self-correcting, better at long-horizon planning, and safer to deploy with reduced human oversight.
Interpretability is Anthropic’s differentiator. Chris Olah’s interpretability team is the most distinct research group at any frontier lab. Their work on understanding what’s actually happening inside neural networks feeds directly into how future models are trained and where safety filters are placed. Advances in interpretability in 2026–2027 will likely show up in more precise, less overreaching safety classifiers — meaning fewer false positives on legitimate requests.
Long-horizon agency is the capability frontier. Fable 5’s headline capability over Opus 4.8 isn’t raw reasoning quality on static benchmarks — it’s how little friction there is in multi-step agentic workflows. Fable 5’s AutomationBench scores are the clearest signal of where Anthropic is competing. The 2027 research agenda will push this further: more steps, less human intervention, better recovery from errors mid-task.
Multi-agent coordination is early. The current Managed Agents platform supports multi-agent orchestration, but the tooling is young. 2027 is when production multi-agent deployments at scale become routine rather than experimental for most enterprise customers.
What It Means for Developers
What it means for developers building agents.
Developers building on Claude in 2026 should architect for the Agent SDK and Managed Agents platform, not just the Messages API — that’s where Anthropic is investing, and it’s where the capability gains will be most significant in 2027.
Practical implications:
Plan for Fable 5 as the default frontier model. Opus 4.8 remains the strong fallback and the model most workflows should run on today. But product architectures that don’t account for Fable 5 as the primary reasoning layer within 12–18 months are likely to require significant refactoring.
The Fallback API is now infrastructure. Any integration calling Fable 5 needs fallback logic configured. Anthropic’s safety classifiers will route some queries to Opus automatically — your integration needs to handle that gracefully, not treat it as an error.
Memory changes what agents can do. Agents that don’t retain context across sessions are meaningfully less capable than those that do. The Managed Agents memory API (public beta since April 23, 2026) is the right surface to build persistent agent behavior on now, before it becomes a standard expectation.
What to Watch
What to watch next on the roadmap.
The clearest leading indicators for 2027 Anthropic roadmap developments:
Project Glasswing expansion announcements — any broadening of Mythos-class access is a signal that the trust-gating model is maturing
Interpretability research publications — Anthropic publishes regularly; major interpretability papers tend to precede model releases by 3–6 months
Managed Agents general availability — currently in public beta; GA signals the platform is production-ready for the long-term
Context window changes — the 1M token context window is already the industry standard; what comes next is likely structural, not just larger
Claude Fable 5 is Anthropic’s most capable widely released model, launched June 9, 2026. It sits in the new Mythos class above the Opus tier and is built for the most demanding reasoning and long-horizon agentic work. It launched alongside Claude Mythos 5, which is restricted to vetted partners through Project Glasswing.
What is Project Glasswing?
Project Glasswing is Anthropic’s program for giving vetted cybersecurity and infrastructure partners access to Claude Mythos 5 — the same underlying model as Fable 5, but with certain safety filters lifted for specific use cases. Access is currently limited and application-based.
When will Anthropic release the next model after Fable 5?
Anthropic has not announced a release date. Their historical cadence — roughly one major model generation per 6–9 months — suggests a 2026 Q4 or early 2027 release is plausible. Anthropic has stated that more capable models are coming and that safety classifiers will improve as they arrive.
What is Claude Managed Agents?
Claude Managed Agents is Anthropic’s managed infrastructure for running autonomous Claude agents in cloud sandboxes, launched in public beta April 8, 2026. It handles session management, tool execution, credential management, and multi-agent coordination without requiring developers to build that infrastructure themselves. Memory for Managed Agents entered public beta April 23, 2026
Most AI assistants still answer from memory. Ask one a question and it reasons from patterns baked in during training — useful, but static. The moment a question depends on something that changed yesterday, or something that only exists inside your own systems, that static knowledge runs out.
The more interesting shift happening in AI tooling right now isn’t bigger models — it’s agents that can actually go check. Dispatch-style AI systems, the kind that can spin off an isolated task, open a real shell, browse a real page, or read an actual file, are starting to close the gap between “the AI’s best guess” and “what’s actually true right now.” GitHub is a good test case for why that distinction matters.
Search-and-cite isn’t the same as read-and-act
Search-and-cite is not the same as read-and-act.
A lot of what gets marketed as an AI “GitHub integration” is really a search layer: the assistant can look up an issue or a pull request and summarize it, with a citation back to the source. That’s genuinely useful for answering “what did that PR change” — but it’s a dead end the moment you need the assistant to actually do something, like open an issue, comment, or verify what a repository’s current state really is.
The more capable version of this connects an agent directly to real developer tooling: an actual shell, a real git client, real file access. Instead of summarizing a cached snapshot of a repo, the agent can clone it, read the current commit log, open the actual config files, and answer questions against what’s genuinely there today — including the uncomfortable cases, like when the live state doesn’t match what anyone assumed it would.
Why “just check” is harder than it sounds
Why “just check” is harder than it sounds.
The obvious rebuttal is: shouldn’t a good assistant just check before it answers? In practice, most AI tools default to answering from what they already “know,” because checking is slower and requires actual tool access, not just a knowledge base. The systems that skip the check tend to produce confident, plausible-sounding answers that are quietly wrong the moment reality has drifted from training data — a stale API, a renamed config path, a repo that moved.
The fix isn’t a smarter model. It’s an agent willing to spend the extra step: open the real file, run the real command, read the real log, before saying anything with confidence. That habit is unglamorous, but it’s the difference between an assistant that sounds right and one that actually is.
The practical takeaway
The practical takeaway for agent builders.
For any business layering AI into real workflows, the question worth asking about a tool isn’t just “how smart is the model” — it’s “what can this thing actually go look at, and will it bother to.” An assistant that can search and summarize is a research aid. One that can open a shell, read your actual repository, and ground its answer in what’s really there is a different category of tool entirely — and it’s the direction the whole space is quietly moving.
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.
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 June 23, 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 runs on Claude Opus 4.8, Anthropic’s most capable model released May 28, 2026. 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 June 23, 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 runs on Claude Opus 4.8 and is available on Enterprise and Team plans. It replaces the original Claude in Slack app, which retires August 3, 2026.
Which tools have Claude Managed Agents embedded?
As of June 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.
Claude is far more than a chatbot. Anthropic calls Claude Code and Cowork “general agents — broad-domain systems that handle research, operations, analysis, and code with equal fluency.” In practice, that means the same AI that writes software can also run your marketing, draft grant proposals, analyze a spreadsheet, and automate the busywork that fills your week. This guide maps what people actually use Claude for, organized by the job you’re trying to get done — with a deeper walkthrough behind each one.
Content & marketing
Content, ops, build, knowledge — pick the lane first.
The most popular non-technical use. Claude researches, drafts, edits, and optimizes — from a single blog post to an entire editorial pipeline.
Where Claude started. Claude Code is an agentic coding tool that reads your codebase, writes and refactors, runs tests, and ships — from the terminal, an IDE, or a desktop app.
Which Claude is right for you depends on the job, not the brand.
Chatbot, coding agent, knowledge-work agent, Slack teammate — these are different doors into the same models. Match the surface to your job first, then size the plan.
Content creation, software development, business operations, data analysis, and knowledge work. Anthropic positions Claude Code and Cowork as general-purpose agents, not just a chat assistant.
Do you need to know how to code to use Claude?
No. Claude’s chat, Cowork, and Slack surfaces require no coding, and even Claude Code can be driven by non-developers for writing, research, and file work.
What’s the difference between Claude, Claude Code, and Cowork?
Same underlying models, different surfaces: Claude (chat) for conversation, Claude Code for agentic coding, and Cowork for agentic knowledge work. See the full comparison.
Is there a version of Claude for my industry?
Yes — see the industry walkthroughs above (marketing, real estate, agencies, restoration, local news, B2B SaaS, and nonprofits) for sector-specific workflows.
New to Claude? Start with pricing & plans, then pick the surface that fits the job you have in mind.
Claude for Nonprofits is Anthropic’s program that gives qualifying nonprofits up to 75% off Claude’s Team and Enterprise plans — with Team seats starting around $8 per user per month — plus nonprofit-specific data connectors, free AI training, and access to a $150M fellowship. If your organization holds 501(c)(3) status (or an international equivalent), you almost certainly qualify. Here’s what’s included, who’s eligible, and how mission-driven teams are putting it to work.
Direct Answer (August 2026): Anthropic offers discounted Claude Team subscriptions and grants for verified 501(c)(3) nonprofit organizations, charities, and educational foundations, facilitating grant writing, donor communications, and operational reporting.
What is Claude for Nonprofits?
What Claude for Nonprofits actually is.
Launched by Anthropic in 2026, Claude for Nonprofits packages the same Claude models used by enterprise teams into an offering built for the realities of mission-driven work: tight budgets, lean staff, and a constant need to do more with less. It bundles three things nonprofits rarely get together — steep pricing discounts, sector-specific integrations, and free training — into one program. It runs on the same foundation as Anthropic’s commercial plans, so nonprofits get the latest Claude models (Opus, Sonnet, and Haiku), not a stripped-down version.
Who qualifies?
Who qualifies — check eligibility before budgeting.
Eligibility is broad, and Anthropic validates organizations through its partner Goodstack. The program covers:
501(c)(3) nonprofits in the U.S., and organizations with equivalent charitable designations internationally
K–12 schools, public and private
Mission-based healthcare organizations with 501(c)(3) status — including independent Critical Access Hospitals (CAHs), Rural Emergency Hospitals (REHs), HRSA-designated Federally Qualified Health Centers (FQHCs) and FQHC Look-Alikes, and CMS-certified Rural Health Clinics (RHCs)
If you can document charitable status, eligibility is usually straightforward.
How much does it cost?
Qualifying organizations receive up to 75% off Claude’s Team and Enterprise plans:
Team plan — discounted pricing starts around $8 per user, per month, which makes it realistic to roll Claude out to an entire staff rather than a single power user.
Enterprise plan — custom pricing for larger organizations; you contact Anthropic’s sales team.
The highest-leverage uses cluster around the work that eats the most staff time:
Grant writing — drafting proposals aligned to a specific funder’s priorities, then tailoring them per application.
Donor stewardship — personalizing outreach and acknowledgements at a scale a small development team could never manage by hand.
Program evaluation & impact analysis — turning messy program data into the impact narratives boards and funders want.
Board & compliance documentation — generating board materials, reports, and compliance documents from source data.
The common thread: Claude removes the blank-page tax on the writing- and analysis-heavy work that keeps nonprofit staff at their desks instead of in the field.
Connectors built for the nonprofit stack
Anthropic built integrations with the platforms nonprofits already run on, so Claude can work against real organizational data:
Benevity — access to 2.4M+ validated organizations for volunteering and donation research
Blackbaud — CRM and fundraising tools for donor management, campaign tracking, and donation optimization
Candid — data on nonprofits and funders to discover organizations, grants, and philanthropic opportunities
Free training and the Claude Corps fellowship
Two things set this apart from a plain discount:
AI Fluency for Nonprofits — a free course Anthropic developed with GivingTuesday, covering grant writing, program evaluation, donor engagement, and organizational efficiency. It’s aimed at staff, not engineers.
Claude Corps — a $150M fellowship initiative pairing nonprofits with AI expertise and resources to implement Claude across their operations. Anthropic also works with partners including The Bridgespan Group, Idealist Consulting, Vera Solutions, and Slalom to support adoption.
How to get started
Confirm your charitable status (501(c)(3) or international equivalent).
Apply through Anthropic’s nonprofit page — eligibility is validated via Goodstack.
Choose Team (self-serve, discounted seats) or contact sales for Enterprise.
Enroll staff in the free AI Fluency for Nonprofits course to get value quickly.
Not free, but heavily discounted — up to 75% off Team and Enterprise plans, with Team seats starting around $8 per user per month for qualifying organizations.
Who qualifies for Claude for Nonprofits?
501(c)(3) nonprofits (and international equivalents), K–12 public and private schools, and mission-based healthcare organizations with 501(c)(3) status. Eligibility is validated by Goodstack.
Which Claude models do nonprofits get?
The discounted plans include Claude’s current lineup — Opus, Sonnet, and Haiku — the same models on the commercial plans, not a limited version.
What can a nonprofit do with Claude?
Common uses include grant writing, donor stewardship, program evaluation, and board and compliance documentation, plus integrations with Benevity, Blackbaud, and Candid.
Is there training for nonprofit staff?
Yes. Anthropic and GivingTuesday offer a free “AI Fluency for Nonprofits” course, and the $150M Claude Corps fellowship provides hands-on implementation support.
