Why One AI Agent Isn’t Enough (And How to Run 1,000) - CJ Avilla & Harrison Stall, Anthropic

Read the talk

Why One AI Agent Isn’t Enough (And How to Run 1,000)

CJ Avilla and Harrison Stall explain how Claude Managed Agents Flows divide work, allocate compute across phases, and put controls around long-running agent systems.

From a talk by CJ Avilla and Harrison Stall

At a glance

Ideas worth remembering

  • Flows let a lead agent plan phases and delegate discrete work; at the time of the talk, the speakers describe a 1,000-agent limit and one layer of nesting.

  • Use isolated contexts for narrow assignments and independent review, then evaluate coverage and quality rather than assuming parallelism guarantees either.

  • Budgets, event streams and interrupts support inspection and intervention during long runs; raising a reached budget can resume completed work without starting over.

  • Keep real credentials outside the agent environment, constrain where they can be injected, and separately restrict tools and network access.

The coordinator becomes the bottleneck

A single person can hold a small project together. CJ Avilla opens with Ken Thompson’s month of work on Unix, then contrasts it with IBM’s much larger OS/360 effort. Fred Brooks’s account of that project described a surgical team: one leader maintains a coherent view while specialists do focused work. That arrangement helps, but the leader still has a limit.

The Linux maintainer example moves the question from a small team to a network. Avilla describes a shift from contributors sending patches directly to Linus Torvalds toward trusted maintainers reviewing contributions before escalating them. What changes in the illustrated topology? A star with 36 actors feeding one center becomes layers with roughly four reports at each level. The relationship matters because the central maintainer no longer has to process every contribution directly.

The same pressure appears when agents generate more work than a person—or one coordinating agent—can inspect. Anthropic’s Harrison Stall and Avilla introduce Flows as a way to organize that work into smaller contexts and phases, while giving developers ways to observe and interrupt a run.

0:120:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:12 · section reference included

A lead agent plans work in phases

Claude Managed Agents provides an API for defining an agent with resources such as skills, tools and MCP servers, then running it in a session. The platform manages the agent lifecycle and exposes a durable event log. Flows add a dynamic workflow: a lead agent makes a plan, creates agents for discrete pieces of work and brings their results through phases.

Earlier multi-agent APIs required developers to define subagents and manage their threads and messages. Stall’s hypothetical repository migration starts instead with a goal: the lead might first fan out exploration agents to read files, then use another phase to analyze what they found. The developer need not draw every connection in advance. A single event stream exposes activity across agents, and an API interrupt can stop a session that is heading the wrong way.

Flows are intended for API integrations, including scheduled jobs and webhook-driven processes. Claude Code’s interactive workflow is useful when a person is working in a terminal; Managed Agents lets a product or background process invoke the workflow. Stall initially describes a vision of complex nested topologies, but clarifies in the final Q&A that the implementation at the time supports one layer of nesting. Avilla gives 1,000 agents as the current Flow limit.

6:5112:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:21 · section reference included

A watchlist gets one context per ticker

The console demonstration starts a Stock Watchlist Scanner template in an environment—a computer on which the agent can work. Stall enters a list including Apple, Nvidia, Amazon and JPMorgan, starts a session and opens the live activity. A previous run had used roughly six concurrent agents at each step; the lead can vary that number with the work.

The scanner divides the ticker list so each scan agent works in an isolated context for one ticker. Its findings pass to a separate review context, which can send work back to the scanner or surface details for the report. This division gives each scanner a narrow assignment and gives review a separate view of the findings.

What did the single-agent and Flow comparison show? Avilla says the Flow found more detail and cost much more. The comparison is useful for understanding the tradeoff, but the spoken description does not provide enough measurements to establish a general quality or cost ratio.

Compute can be distributed unevenly. Avilla suggests two Haiku agents per ticker for a relatively inexpensive internet scan, followed by two or three more capable agents per ticker to examine the returned details. Those counts are proposed settings, not results from the demo. For important work, he recommends evaluating the resulting Flow against a comprehensive set of cases.

After prototyping in the console, a developer can enable multi-agent configuration and ask the lead to run a workflow, then trigger it from an application or on a schedule—for example, before market open. The lead can create subagents on demand or use preconfigured specialists for particular news or financial sources. Custom skills, MCP servers and tools can give those agents the capabilities their assignments require.

18:3019:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:31 · section reference included

Inspect, pause and tune a long run

Claude Code can create managed-agent resources through API calls, but it runs separately from the resulting managed session. The console can show the topology and drill into individual threads; the API exposes per-thread events, tool calls, results and handoff messages. Those events can also support a custom interface.

A session budget is a spending guardrail, and Stall says the model does not know the budget during the run. When the limit is reached, an event reports it; the developer can inspect the work, raise the budget and resume without discarding completed work. An interrupt serves a different purpose: stop the current direction and provide new information. The lead can then start a new Flow informed by the history, but the speakers say inserting a step into the middle of the original plan and rerunning its later steps was not supported.

The operating-system experiment shows why intermediate state matters. Avilla asked for a Unix-compatible system with a Python interpreter, gave the agents a repository and allowed up to 1,000 agents. After about 85 hours, the work was still unfinished, with roughly 1,000 commits reported. A documentation team was prompted to record what each phase implemented, making the repository a place to inspect progress. Neither the commit count nor the elapsed time establishes that the system worked.

The Q&A exposes several practical limits:

  • Shared files, separate contexts: Subagents have separate session threads and context windows, but share a filesystem. The API did not offer a direct command to force one subagent to message another. Prompting agents to stay within directories is not filesystem permissioning; Stall describes checking and denying file-read tool requests as one possible control.
  • Conditional work: For a change such as a new commit SHA, Stall suggests putting detection in the application layer or prompting a Flow to act conditionally. A Flow is unlikely to be a good fit for a task one agent can finish in 30 seconds.
  • Tuning: Developers can examine run transcripts for excess or missing work, use Hill Climb to refine prompts, or use Dreaming to improve an attached memory store across sessions. These are ways to improve future runs, not a built-in scheduled self-improvement guarantee.

More agents also do not come with a known payoff curve. Asked about diminishing returns and coordination costs, Stall does not offer a number. His practical advice is to start with lower defaults, use evaluations and explicitly request greater parallelism when the task warrants it. For context efficiency, Avilla suggests an index of Markdown documents so a kernel agent, for example, can read the kernel details without loading the editor and assembler documents as well.

32:2332:53
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

32:23 · section reference included

Bug Hunter separates suspicion from proof

Bug Hunter applies the same separation to pull-request review. It divides code into slices, assigns each slice to an agent that lists possible problems, then gives the candidates to a separate reviewer that can agree or disagree. A subsequent phase selects candidates worth verifying.

How does a suspicion become a useful review comment? A prover agent can download the repository and try to reproduce the issue, including effects in a distant part of the codebase. The resulting findings can appear as prioritized inline PR comments. The phase relationship matters: generating a plausible concern and checking whether it manifests are separate jobs.

1:03:441:04:14
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:03:44 · section reference included

Explainer Studio turns a brief into scenes

Explainer Studio uses phases for a different output. Research, planning and fact-checking produce a brief; production takes that brief and makes animated scenes. Additional phases handle work such as scripting, sound effects and voiceover. Avilla says Anthropic uses a Flow to produce many of its product explainer videos, and the demonstration includes an animation about finding change-of-control clauses across 300 contracts.

A brand style can be supplied to guide the visual treatment. The demonstrated workflow produces the video; it did not automatically deploy it to YouTube. That distinction leaves distribution as a separate decision.

1:07:141:07:44
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:07:14 · section reference included

Three ways a single context can go wrong

Avilla uses an outage investigation to explain why isolated work and review can help. The instruction is to inspect 50 services, find the root cause and avoid changing production.

  • Agentic laziness: After seeing 35 healthy services, one agent may infer that the rest are probably fine and stop looking. Assigning a context to each service and tracking completion makes the intended coverage explicit. A coordinator with only a few subagents can still lose count or inherit the same incomplete-work problem.
  • Self-preference: An agent asked to judge its own poem or code may favor its own output. An independent reviewer can challenge a generator’s work, as in Bug Hunter’s separate review phase.
  • Goal drift: As a long context fills and is compacted, an instruction such as “don’t touch production” may be lost. A Flow can copy the relevant goal into each phase’s agent context.

These are design responses to observed failure modes, not guarantees that every service was checked or every instruction obeyed. The Flow itself is not necessarily deterministic, so coverage and constraints still need verification.

1:12:021:12:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:12:02 · section reference included

Declare, contain and detect

A larger agent system multiplies the consequences of a bad tool call or malicious instruction. An agent reading the open web can encounter text that tries to redirect it or exfiltrate information; a plaintext API key in its environment can become another route to damage.

Stall organizes the controls under three jobs:

  • Declare: Define the agent’s persona, skills, tools and permission policies.
  • Contain: Set physical limits, including budgets and restrictions on network access or web tools.
  • Detect: Watch the durable event stream and interrupt sessions that depart from the intended behavior.

A budget can be paired with an outcome and rubric: ask for a result while setting a spending limit. For an active correction, the API event user.interrupt stops the Flow so the developer can redirect it. The event history can also be passed to a reviewer agent to look for unexpected tool calls or access across previous sessions.

Avilla recommends Auto Mode as a permission policy that assesses individual tool calls, partly because repetitive approval prompts can train people to click through. It is one layer of review alongside the environment and tool restrictions, rather than a substitute for choosing what the agent can access.

1:16:201:17:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:16:20 · section reference included

Keep credentials out of the agent’s computer

Managed Agents separates the inference loop and session state—the “brain”—from the environment and tools that take actions—the “hands.” For credentials, the practical consequence is that the sandbox can receive a placeholder while a real secret remains outside it. An egress proxy substitutes the real value as the request leaves.

The Twilio example shows where that substitution is constrained. A vault stores the credential; configuration identifies where it belongs in an outgoing request, such as an authorization field or body, and which host may receive it. The agent can use the placeholder in its environment without reading the real key. Restricting the destination prevents the same placeholder from causing the proxy to send the key to an unrelated host.

Network and tool controls add separate limits. Web search or fetch can be disabled, individual MCP tools can be enabled selectively, and environment network rules can restrict reachable hosts at the firewall. These controls reduce what an agent can do even if it encounters a malicious instruction; their effectiveness depends on the configuration.

A placeholder crosses the sandbox; the secret is injected at egress

Agent environmentCreates an outgoing request using a placeholder credential.
Credential vaultStores the real credential and its configuration.
Egress proxySubstitutes the real value at the configured location for the allowed host.
Allowed API hostReceives the outgoing authenticated request.
The vault supplies the proxy, while the sandbox sends a request containing a placeholder. Host and injection-location settings constrain substitution.
Read the diagram as text
  • Agent environment. Creates an outgoing request using a placeholder credential.
  • Credential vault. Stores the real credential and its configuration.
  • Egress proxy. Substitutes the real value at the configured location for the allowed host.
  • Allowed API host. Receives the outgoing authenticated request.
  • Agent environment → Egress proxy: Request with placeholder.
  • Credential vault → Egress proxy: Credential and substitution settings.
  • Egress proxy → Allowed API host: Request with injected credential.
1:21:201:21:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:21:20 · section reference included

Human taste, dependency graphs and private tools

For outputs that depend on taste, such as video, Avilla suggests first working through the process interactively and encoding the useful procedure as a skill. Hill Climb can incorporate human preference: generate alternatives, choose one, then repeat while the prompt changes. This makes the human’s judgment part of the iteration rather than pretending the video has a simple automatic score.

The final Bug Hunter question returns to repository context. If a multi-repository project has an explicit dependency graph, Claude can inspect it; otherwise it may need to search files and symbols. Each PR review needs the repositories mounted or checked out in its environment. A graph prepared in advance can be uploaded as a session file and pointed out to the agent, saving it from reconstructing that information each time.

Flows also support self-hosted sandboxes, although Stall notes that some other platform features may differ there. For a private MCP server behind a VPN, he points to MCP tunnels using Cloudflare Tunnels as a way to give managed agents private access. The recurring design choice is to give the workflow the context and tools it needs, while making the route to that access explicit.

1:32:221:32:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:32:22 · section reference included

Resources

Transcript download
Full transcript

Loading transcript…