← Back to Resources
Agent designOctober 26, 2026

Anthropic on Single-Agent Loops: Stop Building Committees

On October 22, 2026, guidance attributed to Anthropic began circulating on X with a blunt architectural message: fold your subagents into one loop. After two years of the agent ecosystem celebrating multi-agent orchestration—managers, planners, worker swarms—the lab behind Claude is reportedly telling builders that most of that machinery is overhead, and that a single iterating agent with the right tools wins more often than a committee of specialists.

The guidance, as reported

The X-reported guidance is short enough to state plainly: prefer one agent iterating in a loop—act, observe the result, adjust—over architectures that decompose a task across multiple subagents coordinated by a manager. The reported rationale covers the classic failure modes of multi-agent stacks:

  • Context handoffs lose information. Every subagent boundary is a summarization point; whatever the summary drops is gone from the system's working memory.
  • Coordination costs scale badly. The manager burns tokens decomposing, delegating, and re-integrating—work that the loop does implicitly.
  • Errors compound across hops. A wrong subagent result enters the integration step with the same authority as a right one, and debugging crosses component boundaries.
  • State becomes unauditable. One loop means one trace you can replay; a swarm means an event mesh you can only sample.

Note the epistemic status: this is guidance as reported on X, not a published Anthropic paper we can cite line-by-line—but it is consistent with the direction of Claude Code's own architecture and with Duet's single-proactive-agent design.

Why the loop wins: the context argument

The deepest reason is context economics. A task's relevant knowledge is discovered during the work—a file turns out to matter, a dependency version explains the bug, a user's phrasing narrows the intent. In a single loop, those discoveries stay in the context that continues the work. In a multi-agent decomposition, they must be serialized into handoff artifacts before they can influence the whole—and serialization is where agent systems quietly fail.

This changes what "good tools" means. In a single-loop world, the agent's capability is its tool layer, so the tooling market is the architecture market:

  • Context Engine — memory that persists across loop iterations and sessions, over MCP.
  • Kerno — backend tests executed inside the loop, so the agent observes ground truth instead of guessing.
  • Moli — a browser built for agents, extending the single loop onto the web.
  • Cobalt Cockpit — verification gates that keep a long loop honest.

When subagents are still right

The guidance, as reported, targets premature orchestration—not all parallelism. Subagents earn their overhead when:

SituationBetter fitWhy
Sequential, tool-heavy taskSingle loopDiscoveries must stay in the working context
Fan-out over many sourcesSubagents (parallel)Genuinely independent reads; latency wins
Untrusted or risky stepsIsolated executionBlast-radius control (see kosa8)
Context exceeds one windowHybridLoop core + subagents as context offload

How to refactor toward the loop

  • Count your handoffs: every manager → subagent → manager round-trip is a candidate for inlining into the loop with a better tool.
  • Move verification into the loop—tests, previews, and runtime checks (Kerno, Ovren, heal.dev) replace "the reviewer agent will catch it."
  • Give the loop memory (Context Engine) instead of a "memory agent."
  • Measure before/after on tokens, latency, and task success—the loop usually wins on all three; when it does not, you have found a legitimate subagent.

Single-Agent Loops FAQ

What are Anthropic's single-agent loops?

Per guidance from Anthropic reported on X (October 22, 2026): fold subagents into one loop. Instead of orchestrating multiple specialized subagents with a manager on top, build a single agent that iterates—act, observe, adjust—inside one continuous loop with a well-chosen toolset.

Why fold subagents into a single loop?

As reported, the reasoning is that multi-agent stacks accumulate coordination overhead: context handoffs lose information, subagents duplicate work, and errors compound across hops. A single loop with good tools keeps context coherent and makes the agent's state inspectable at every step.

Does one agent mean one model?

Not necessarily. The loop pattern concerns control flow—one iterating agent—not the model count. A common 2026 pattern is a flagship model for planning steps and a cheap flash model for extraction/routing inside the same loop.

When are subagents still the right call?

When work is genuinely parallelizable and context-independent—fan-out research across many sources, isolation-sensitive tasks, or when context volume exceeds what one loop can hold. The guidance targets premature architecture, not all multi-agent designs.

What tools support the single-loop pattern?

A single loop leans hard on its tool layer: MCP servers for capability (see Context Engine for shared memory), test-in-loop tooling like Kerno, and verification layers like Ovren and Cobalt Cockpit so each iteration proves its work.

AIXList is an independent AI tools directory. This article summarizes agent-design guidance attributed to Anthropic as reported on X on October 22, 2026; we are not affiliated with Anthropic. For the authoritative version, consult Anthropic's official engineering blog at anthropic.com.