Building a Multi-Agent Operating System with Claude: Architecture, Tools, and Workflows for Production AI Agents

A multi-agent operating system built on Claude uses one orchestrator agent that delegates work to isolated subagents, each running in its own context window with its own tool permissions, and returns only a summary to the lead agent. That is the core architecture behind the Claude Agent SDK, the same lead-agent-plus-subagents pattern that powers Claude Code, and it is the architecture I would bet on for production. Gartner's June 2025 forecast predicts more than 40% of agentic AI projects will be canceled by end of 2027, driven by escalating costs, unclear business value, and inadequate risk controls, so the architecture you pick matters as much as the model you pick.

I have been shipping agent systems since the single-agent era, and imo most multi-agent builds die from three things: compounding per-step error, context rot in long sessions, and zero observability. The math is unforgiving: a 10-step task at 95% per-step reliability completes only about 60% of the time (0.95 to the 10th power is 0.599). Fix that with isolation, durable execution, and human checkpoints, and multi-agent systems start paying for themselves.

Key takeaways:

• Recommended topology: orchestrator-worker, one lead agent with scoped workers
• Each Claude subagent runs in an isolated context window and returns only its summary
• Production minimums: tracing, cost tracking, a verification step, and human checkpoints on anything that writes or spends
• Delegation depth is limited in the Claude Agent SDK; do not design around recursive delegation without checking current docs
• Start with one agent, add subagents only when you can measure what they cost

What Is a Multi-Agent Operating System?

A multi-agent operating system is the orchestration layer that coordinates several AI agents: it assigns tasks, manages shared memory, controls tool access, handles retries, and routes results between agents. Think of it as a scheduler and supervisor for autonomous workers rather than a chatbot wrapper.

The Claude Agent SDK is Anthropic's Python and TypeScript library (formerly the Claude Code SDK) that exposes the same agent loop, built-in tools, and context management that power Claude Code. The SDK runs the Claude Code CLI as a subprocess from your application, so every agent gets file reads, shell execution, web search, and code editing out of the box, without you implementing tool execution yourself.

The "harness" around the model is what makes it an operating system rather than a prompt. Per Anthropic's own engineering talks, a production harness needs tools, prompts, a file system, skills, subagents, and memory. The model is the replaceable part.

Which Multi-Agent Topology Works Best in Production?

There are four standard multi-agent topologies in 2026:

• Orchestrator-worker, a lead agent delegating to subagents, which is the Claude Agent SDK's native pattern
• Peer-to-peer handoff, agents transferring control to each other, LlamaIndex's AgentWorkflow style
• Hierarchical pipeline, fixed stages with each agent owning one stage
• Dynamic topology, agents spawning, merging, or rerouting at inference time, still mostly research-grade

For production, orchestrator-worker wins for a boring reason: accountability. One agent owns the plan, one agent reports to the user, and every subagent is a scoped worker with a narrow job. When something breaks, you know which worker broke it.

One caveat worth knowing before you design anything: the Claude Agent SDK limits how deep delegation goes. Depending on SDK version, subagents may not spawn their own subagents at all, or only a few levels deep. Check the current docs for your version before building a topology that assumes recursive delegation. A supervisor that fans out to five workers is safe. A supervisor whose workers fan out again needs verification against your SDK version first.

How Does Subagent Isolation Work?

A subagent is a spawned worker agent that receives a task, runs it with a restricted tool set, and reports back. Each subagent spawned by the lead agent runs in its own context window, a clean slate containing only its system prompt, the delegation message, and whatever it reads or calls. It has no visibility into the main conversation's history. When it finishes, only its final summary returns to the lead agent; the verbose intermediate work, the searches, file reads, and tool output, never pollutes the orchestrator's context.

This matters more than it sounds. Context rot, the degradation of accuracy as a conversation transcript grows, is the number two killer of long-running agents, and it hits well before you reach the context window limit. Isolation is the fix. A research subagent can burn 150K tokens reading garbage and the orchestrator only pays a few hundred tokens for the summary.

Memory across sessions is a separate layer. The SDK reads CLAUDE.md from the working directory for persistent project context, and long-running agents stay inside the context window through automatic compaction, which summarizes older messages as the limit approaches. For anything richer, you bolt on a memory layer (Honcho, Mem0, Zep) or a vector store exposed as an MCP server so any agent can call it through the same tools interface.

What Tools Do Production Agents Need?

Tools are how agents touch the world. MCP, the Model Context Protocol, is the open standard that lets an agent call external tools and data sources uniformly, and the common 2026 pattern is exposing every capability, retrieval included, as an MCP server so any agent in the system can call it the same way. MCP standardizes the interface, not the safety: permission boundaries, secrets handling, sandboxing, and validation of tool output are still your job, and prompt injection through tool output remains the top attack surface.

The second lever is model routing: sending simple subtasks to a cheap, fast model (Claude Haiku-class, Gemini Flash-class, Phi-4, DeepSeek) while complex reasoning routes to a frontier model. The SDK supports per-subagent model configuration, so a frontier orchestrator with Haiku-class workers is a common pattern. My rule of thumb, and it is a rule of thumb, not a benchmark: most worker subtasks do not need frontier reasoning, so route them down and measure the cost delta.

Keep the subagent count deliberate. Every subagent is a new failure surface and a new token consumer. In my experience three to five well-scoped workers beat twelve overlapping ones.

What Does a Production Workflow Look Like?

Here is the workflow shape that actually holds up:

• Plan (orchestrator, frontier model): decompose the task, decide what needs research, code, or execution
• Fan out (workers, cheap models): parallel research across sources, one file per review agent, one chunk per summarizer. Fan-out works best when subtasks are independent and do not need each other's intermediate results
• Reduce (orchestrator): merge summaries, resolve conflicts, draft the deliverable
• Verify (dedicated critic subagent): a separate agent with a different prompt reviews the output for factual errors, injection attempts, and scope violations. Never let the generator grade its own work
• Checkpoint (human-in-the-loop): anything that charges cards, writes rows, or sends client-facing email gets an approval gate

For durability, pair the SDK with a workflow runtime like Temporal, which provides automatic retries and state that survives crashes. Durable execution, meaning the workflow's state persists so it can resume after a failure instead of restarting, is what separates a system from a demo. An agent loop without durable state is a script.

Why Is Observability Non-Negotiable?

Gartner's May 2026 guidance on agent governance predicts that by 2027, 40% of enterprises will demote or decommission autonomous AI agents due to governance gaps identified only after production incidents. Observability is governance's eyes.

Minimum viable observability for a multi-agent OS:

• Tracing on every agent call and tool invocation (Langfuse is the open-source default; LangSmith and Arize are the hosted options)
• Cost tracking per agent and per workflow, so you know which worker eats budget
• Input/output logging on every subagent boundary, because that is where errors compound silently
• Eval scores on golden test sets, run on every prompt or model change

The failure modes that kill unmonitored systems are well documented: prompt injection through tool output (a webpage tells your agent to do something else), silent quality drift after model swaps, and cost blowups from a worker stuck in a retry loop. All three are invisible in request/response logs and obvious in traces.

How Much Does It Cost to Run?

The economics depend almost entirely on orchestration discipline, and honest numbers are workload-dependent. The levers, with sources:

• Context is 60 to 80% of LLM API spend in production systems, per 2026 observability reports from Langfuse and Anthropic's own cost guidance. Subagent isolation attacks exactly this
• Prompt caching can cut costs by up to 90% on repeated content (Anthropic's documented figure for cache hits on repeated prefixes), though total system savings are always lower than the cache-hit rate
• Compounding error is a cost too: at 95% per-step reliability, roughly 40% of 10-step runs fail and need reruns. Verification steps cut rerun rates; imo they pay for themselves, but measure it on your own workload
• A frontier orchestrator with cheap-model workers is the standard cost pattern; run one week with routing and one without and compare the bill

The build-vs-buy question resolves simply: if you need five or fewer coordinated agents, build on an SDK. If you need enterprise governance, audit trails, and cross-team policy, buy a platform. Most small teams overestimate how much agent they need.

How Do You Get Started?

1. Install the Claude Agent SDK (Python or TypeScript) and run a single agent with built-in tools in a loop. Thirty lines of code gets you a working terminal agent
2. Add a CLAUDE.md to the working directory so the agent accumulates project context across sessions
3. Define your first subagent as a markdown file in .claude/agents/ with a scoped prompt and a restricted tool list, and remember to allow the delegation tool itself or the spawn gets blocked
4. Wrap the loop in a durable runner (Temporal, or even a disciplined cron plus state file) before you trust it unattended
5. Add Langfuse tracing before the second subagent, not after the fifth
6. Route simple subtasks to a cheap model and measure the cost delta

The mistake I see most often is teams building the topology first and the verification layer never. Build the critic first. The workers are the easy part.

Multi-agent systems went from research curiosity to default enterprise architecture in roughly two years, with Grand View Research projecting a compound annual growth rate near 48% for multi-agent systems through 2030. The teams that win with them are not the ones with the cleverest topology. They are the ones with isolation, traces, checkpoints, and a cost dashboard. Boring architecture, shipped. That is the whole game.