How Anthropic's Internal Agent Hierarchy Works

Anthropic's system has three functional layers. At the top sits a coordinating module responsible for project intake, priority assignment, and cross-project resource allocation. This isn't a router that simply passes requests downstream. It holds context across all active projects and makes decisions about which specialist tier should handle which task.

The middle tier contains what you'd call domain leads: components scoped to a specific function (research, synthesis, drafting, review) that receive delegated tasks from the coordinator and break them into discrete units of work. Each domain lead manages its own queue and reports status upward on a defined cadence.

The bottom tier is where execution happens. Individual contributor nodes handle atomic tasks: pull a source, summarize a document, score a candidate, generate a section. They don't make routing decisions. They receive a well-formed input, produce a well-formed output, and hand off to the next step in the chain.

The critical design choice is the handoff contract between tiers. Each layer communicates through explicit schemas, not freeform text. The coordinator doesn't tell the research module "go find information about X." It passes a structured object: topic, scope boundaries, output format, deadline, and the downstream consumer that will receive the result. This specificity is what makes the system auditable and what makes individual components independently testable.

We built our first Autonomous SDR pipeline using a flat three-component setup: a research module, a scoring module, and a writing module, all reporting to a single orchestrator. It worked cleanly on five contacts. At fifty, the scorer sat idle waiting on research that had nothing to do with scoring. The orchestrator had no mechanism to parallelize because it treated the pipeline as a single sequential chain rather than a set of independent workstreams with explicit dependencies.

Splitting into discrete components with typed handoff contracts between them cut processing time and made each module independently testable. That experience is why every pipeline we build now uses explicit inter-component schemas. Implicit data passing, where one module just "knows" what the next one needs, doesn't hold up once you add concurrency or try to swap out a component for a better one.

Anthropic's architecture solves the same problem at a larger scale. When eight to ten projects run simultaneously, a flat system creates a bottleneck at the orchestrator: every decision, every status check, every resource allocation flows through one point. A tiered system distributes that load. Domain leads handle intra-project coordination. The top-level coordinator only touches cross-project decisions. The result is a system that degrades gracefully under load rather than collapsing at a threshold.

This is also where single-model workflows show their limits. One reasoning engine handling research, synthesis, scoring, and drafting simultaneously isn't specialization. It's context pollution. The model's attention is split across incompatible task types, and the outputs reflect that. Dedicated components, each scoped to a narrow function, produce more consistent results because the task definition is tighter.

The organizational logic of Anthropic's system maps directly onto tools most engineering teams already use. In n8n, for example, the coordinator tier becomes a master workflow that receives project intake via webhook, assigns tasks to sub-workflows based on type, and aggregates status through a shared data store. Each sub-workflow is a domain lead: scoped, independently triggerable, and connected to the master via a defined input/output contract.

The implementation sequence matters. Start with the handoff schema before writing any logic. Define what the coordinator passes to each domain module, what each module returns, and what the individual contributor nodes at the bottom tier receive and emit. If you can't write that schema in thirty minutes, the task decomposition isn't clear enough yet. This is a design problem, not a coding problem. We've written more about this distinction in our piece on design-first versus prompt-first AI workflow construction.

Accountability checkpoints are the second structural requirement. In Anthropic's system, domain leads report status upward on a defined cadence. In a practical build, this means each sub-workflow emits a status record to a central log on completion, including the input it received, the output it produced, and any errors encountered. Without this, debugging a failure in a ten-component system means tracing through logs manually. With it, you can isolate the failing component in seconds.

The third requirement is failure isolation. Each tier should handle its own errors before escalating. A contributor node that fails to retrieve a source should retry with a fallback, then emit a structured error record to its domain lead, not crash the entire pipeline. The domain lead decides whether to reassign the task, skip it, or escalate to the coordinator. This mirrors how functional engineering teams handle incidents: local resolution first, escalation only when local resolution fails.

One honest limitation of this architecture: it's expensive to build correctly. Defining explicit schemas for every handoff, instrumenting every tier for observability, and testing each component in isolation requires upfront investment that a flat single-model setup doesn't. For a five-task workflow running once a day, the overhead isn't justified. The tiered approach pays off when you're running concurrent projects, when components need to be swapped or upgraded independently, or when you need to audit what the system did and why. If none of those conditions apply, a simpler build is the right call. We've seen teams over-engineer early pipelines and then abandon them because the maintenance burden outweighed the benefit. Our analysis of custom harness traps covers this failure mode in detail.

Define the coordinator's scope before building anything else. The most common mistake we see is building specialist components first and then trying to retrofit a coordinator on top. The coordinator's job, what decisions it makes, what it delegates, and what it never touches, should be written down before a single node is configured. Retrofitting coordination logic into an existing flat pipeline is harder than building it correctly from the start.

Version the handoff schemas explicitly. When a component is upgraded or replaced, the schema it emits may change. Without versioning, a schema change in one module silently breaks downstream consumers. Treat inter-component contracts the same way you'd treat a public API: version them, document breaking changes, and give downstream consumers a migration path. This is the discipline that makes a multi-tier system maintainable over months rather than weeks.

Build the observability layer before the first production run, not after the first failure. Every tier should emit structured logs from day one. The temptation is to add logging after something breaks. By then, you've already lost the data you needed to diagnose the first failure. Instrument first, then run. The pipelines in our full blueprint catalog ship with logging hooks at every tier boundary for exactly this reason.