The Real Bottleneck Is Handoff

Spinning up five agents in parallel takes minutes. Getting them to hand off work cleanly takes weeks of iteration. The handoff problem is the bottleneck that nobody talks about because it is not a configuration issue - it is an architecture issue.

Research from 2025 benchmarks puts the failure rate for multi-agent tasks anywhere from 41% to 86.7% depending on task complexity and agent count. The agents themselves are usually not why. The coordination layer is.

What a Handoff Actually Involves

Agent A finishes processing raw data and needs to pass it to Agent B for analysis. Sounds simple. But the moment you go deeper, the questions multiply:

• What exactly does Agent A send? The full dataset? A summary? A pointer to where the data lives?
• How does Agent B know the data is ready - does it poll, subscribe, or get called?
• What if Agent B is already running a different task?
• What if Agent A crashes after finishing but before the handoff write commits?
• Does Agent B receive Agent A's full reasoning, or just the output?

With five parallel agents, these questions don't add - they multiply. Agent C might depend on results from both A and B. Agent D might need to wait for C but can start some work based on A's output alone. Agent E monitors all of them and intervenes when something goes wrong. Every dependency edge is a handoff point. Every handoff point is a potential failure.

The Architecture of a Handoff

There are three common approaches to agent-to-agent transfer, each with different tradeoffs.

Direct message passing is the simplest. Agent A calls Agent B with a payload. No shared infrastructure required. The problem: it creates tight coupling, the sender blocks until the receiver confirms, and if the receiver is unavailable you need retry logic at the call site. This pattern also makes it hard to add a third agent that needs to observe the same data.

Shared state store breaks the direct dependency. Agents read from and write to a common store - Redis, Postgres, a file system, a structured memory layer. Agent A writes its output and marks a task as complete. Agent B polls or is notified, reads the output independently, and proceeds. No direct coupling, no blocking. The tradeoff: you now need a schema for what lives in the store, and stale reads become a real risk. If Agent B reads before Agent A's write commits, it operates on old data.

[Agent A] --write--> [State Store] --read-- [Agent B]
              |                                  |
         Task: DONE                        Task: IN_PROGRESS
              |
         [Event Bus] --notify--> [Agent B trigger]

Event-driven triggers sit on top of shared state and eliminate polling. Agent A writes output, then publishes an event: task.research.complete. Agent B subscribes to that event type. When it fires, Agent B reads from the state store and starts. This decouples timing entirely - Agent B doesn't need to exist when Agent A finishes. The tradeoff: you now have a message broker to operate and events can arrive out of order.

The production-grade pattern combines both: shared state as the source of truth, events as the notification layer.

[Agent A]
    |
    v
[State Store] <--- write output + metadata
    |
    v
[Event Bus] <--- publish "task_complete" event
    |
    v
[Agent B] <--- subscribe, read from store, execute

What Gets Serialized in a Handoff

The payload an agent passes at handoff time is not just the output. A complete handoff envelope includes:

{
  "task_id": "research-001",
  "source_agent": "researcher",
  "target_agent": "analyst",
  "status": "complete",
  "output": {
    "summary": "Found 3 relevant competitors with pricing data",
    "artifacts": ["s3://bucket/research-001/raw.json"],
    "confidence": 0.87
  },
  "context": {
    "original_goal": "Compare SaaS pricing in devtools market",
    "constraints": ["focus on sub-$100/mo tiers", "B2B only"],
    "decisions_made": [
      "excluded freemium tiers as out of scope",
      "used latest pricing pages, not Wayback"
    ]
  },
  "metadata": {
    "started_at": "2026-03-26T10:00:00Z",
    "completed_at": "2026-03-26T10:04:32Z",
    "token_count": 14200,
    "model": "claude-sonnet-4-6"
  }
}

The decisions_made field is often omitted - and that is where context loss starts. The receiving agent sees the output but not the reasoning that shaped it. It makes different assumptions, re-explores territory the first agent already ruled out, and produces inconsistent follow-on work.

OpenAI's Agents SDK formalizes this with typed input_type on handoffs - the model declares what metadata it is passing at handoff time, the SDK validates the schema before transfer, and the receiving agent gets a structured object instead of a free-form string. This alone eliminates a category of silent failures.

Real Failure Modes

Stale state propagation. Agent A finishes and writes to the shared store. Agent B starts 200ms later but reads a cached version of the store from before Agent A's write. Agent B now processes stale data, produces a result that conflicts with Agent A's output, and the coordinator has to reconcile two inconsistent states downstream. In Redis this happens when read replicas lag. In Postgres it happens when Agent B's connection holds a snapshot transaction. Fix: add a version field to every state entry and reject reads older than the current task epoch.

Retry ambiguity after partial handoff. Agent A writes its output to the store but crashes before publishing the completion event. The coordinator sees no event and assumes Agent A is still running. After a timeout, it retries Agent A's task from the start. Now you have two copies of Agent A's output in the store - the original partial write and a new complete write - and Agent B reads whichever it finds first. Fix: writes and event publishes need to be atomic, or the coordinator needs to check the store directly before retrying.

Context window blowup on long chains. A five-agent pipeline where each agent passes the full accumulated context forward hits model limits fast. If each agent adds 4K tokens of reasoning and output, the fifth agent receives 20K tokens of prior context before doing any of its own work. At ten agents the number exceeds most models' practical context window. Fix: each handoff should pass a summary plus a pointer to the full artifact, not the full artifact inline. The receiving agent fetches details only when it needs them.

Deadlock via circular dependency. Agent A is waiting for Agent C to finish before it can proceed. Agent C is waiting for Agent B. Agent B is waiting for Agent A. All three are blocked. This is rare in simple pipelines but appears quickly when agents share a resource pool or when a monitoring agent has the ability to pause other agents. Fix: dependency graphs should be validated as DAGs (directed acyclic graphs) before execution starts. Any cycle is a deadlock waiting to happen.

Silent schema drift. Agent A is updated to return an additional reasoning_trace field. Agent B was written expecting the old schema and ignores unknown fields. Everything appears to work. Six weeks later someone adds logic to Agent B that depends on reasoning_trace being absent - and it breaks intermittently based on which version of Agent A ran. Fix: version your handoff schemas explicitly and validate both sender and receiver against the current schema on every run.

Coordination Overhead Is Not Free

Each handoff adds measurable latency. Research from production deployments puts per-handoff overhead at 100ms to 500ms depending on the implementation - serialization, network round-trip, deserialization, and state synchronization combined. A linear pipeline with ten agent handoffs adds 1-5 seconds of pure coordination overhead before accounting for any actual LLM inference time.

The coordination tax also scales nonlinearly with agent count. Two agents need one connection. Five agents have ten potential interaction paths. Eight agents in a fully connected graph have 28 paths. Latency compounds: two agents add roughly 200ms of overhead; eight agents can add 4+ seconds.

This is why minimizing handoff surface area matters more than optimizing individual agents. One fast handoff with a clean schema beats three slower ones with verbose context dumps. A pipeline that shares state via a store beats one that passes full context through direct calls at every step.

What Works in Production

Shared state store with versioned writes. Agents read from and write to a common database with explicit version or epoch tracking. No serialization into messages, no blocking calls between agents. Agent A writes version: 42; Agent B only starts when it sees version: 42 available.

Event-driven triggers, not polling. Agents subscribe to typed events (task.complete, task.failed, task.needs_review). No busy-waiting, no timeout-based polling loops. AutoGen 0.4 rewrote its entire architecture around this model - typed events on an internal message bus replaced the previous conversation-based design because polling was the primary source of coordination latency.

Typed handoff schemas with validation. Define the exact structure of every handoff payload. Validate at send time and receive time. LangGraph implements this via Pydantic-typed State objects passed between nodes - the schema is the contract, and any mismatch fails loudly rather than silently passing bad data downstream.

Explicit timeout budgets per handoff. Every handoff gets a deadline. If Agent B does not acknowledge a task within N seconds, the coordinator reassigns rather than waiting indefinitely. The right timeout is specific to the task - a web scraping agent needs a different budget than an in-memory summarizer.

Summarize, don't forward. Each agent produces a compact summary of its work for downstream agents and stores the full artifact in the shared store. Downstream agents pull the full artifact only if they need it. This keeps context windows manageable in long pipelines.

The Dependency Graph Matters More Than the Agents

The most expensive mistake in multi-agent system design is treating the agents as the primary design decision. Which model, which tools, which prompts - these get all the attention. The dependency graph between agents - who waits for whom, what gets passed, how failures propagate - gets designed last, if at all.

The handoff architecture determines your floor on latency, your ceiling on reliability, and your ability to recover from partial failures. An orchestration layer with clean schemas, atomic writes, and typed events will run a mediocre set of agents more reliably than a fragile coordination layer running state-of-the-art models.

The bottleneck is almost always the space between agents. Build that space carefully.

More on This Topic

• Why Passing Full Context Between Agents Fails
• AI Agent Handoff Context Loss With Git Diff
• Context Drift Killed the Longest Agent Sessions

Fazm is an open source macOS AI agent. Open source on GitHub.