Multi-Agent Handoffs Without Lost Context

The fastest way to lose trust in a multi-agent demo is a handoff that drops the ticket ID, double-sends the email, or “remembers” a plan the evaluator already rejected. More agents are not a maturity model. Clear handoffs are.

This spoke sits under the Agentic Systems Operating Manual. Read state machines and memory patterns alongside it.

When multiple agents are worth it

Split when work naturally specializes and you can name the interface:

• Research vs draft vs compliance check
• Intake classification vs enrichment vs write-back
• Librarian (retrieval) vs worker (prose) vs evaluator (judge)

Do not split because a slide said “multi-agent.” One worker plus one evaluator beats five chatty peers that share a muddy transcript.

Multi-agent handoff patterns

Pattern A — Relay

Agent A finishes a stage, emits a handoff package, Agent B starts clean. No shared scratch. Best default for business ops.

Pattern B — Hub

A thin coordinator assigns sub-jobs, collects packages, and decides next states. The hub should be mostly deterministic code or workflow logic, not a free-form gossip model.

Pattern C — Critique loop

Worker produces; critic/evaluator returns failures; worker revises. The critic must not hold write tools. This is still “multi-agent” even when people call the critic a module.

Pattern D — Parallel specialists (use sparingly)

Two specialists work disjoint subproblems, then a merge step reconciles. Requires hard partitions of the problem and an idempotent merge. Easy to get wrong; great when it fits.

The handoff package (minimum fields)

{
  "job_id": "tkt_18422",
  "goal": "Draft internal triage summary; do not send to customer",
  "constraints": ["no refund promises", "cite help center or no_match"],
  "artifacts": [{ "type": "summary_md", "uri": "s3://..." }],
  "open_questions": ["customer timezone unknown"],
  "tools_tried": [{ "name": "tickets.get", "ok": true }],
  "evaluator": { "last_verdict": "fail", "failures": ["citation_missing"] },
  "budget": { "usd_remaining": 1.2, "revisions_remaining": 2 },
  "memory_refs": ["customer_id:cus_9"],
  "next_hint": "re-retrieve refund policy; rewrite summary"
}

Rules:

• Typed artifacts, not “see chat above.”
• Budget remaining travels with the work.
• Evaluator state travels so the next agent does not repeat a failed approach blindly — or so it does retry with evidence.
• No private chain-of-thought required. If B needs reasoning, regenerate from artifacts and failures.

Agent coordination for business (without the buzzword fog)

Business coordination needs:

1. Role cards — what each agent may do and which tools they hold.
2. State machine ownership — which component advances states (prefer the rail, not a chatty chairman agent).
3. Idempotency — handoffs may retry; side effects must not.
4. Single writer for each external resource per run when possible.
5. Escalation owner — one path to humans, not three agents emailing the same manager.

If you cannot draw which agent may write which system, stop adding agents.

Lost context: failure modes and fixes

Failure	Symptom	Fix
Dropped IDs	B invents or asks again	Required fields in package schema
Stale plan	B follows A’s rejected plan	Include evaluator failures; ban plan reuse without re-validate
Double write	Two agents patch CRM	Single-writer rule; idempotency keys
Overshare	PII in every hop	Redact; pass refs not payloads
Undocumented tool use	B retries burned tools	tools_tried with errors

Validate the package with a schema at every hop. Invalid package → escalate, not “improvise.”

How much should agents talk to each other?

Less than vendors imply. Prefer package relay through the workflow rail. Free-form agent-to-agent chat is hard to audit, hard to budget, and easy to poison. When you need negotiation, constrain it: fixed rounds, structured proposals, evaluator on the merge.

Testing handoffs

• Contract tests on the package schema
• Replay: given package P, agent B produces artifact meeting criteria
• Chaos: drop optional fields; system must fail closed
• Duplicate delivery of the same handoff; no double side effects

Pilot advice

Spurlock Studios pilots ($1,500 · 5 days) default to one worker + one evaluator. A librarian is the first extra agent when RAG is in scope. Fancy mesh topologies wait until the thin path clears the golden set.

/agentic · /contact?intent=agentic-pilot

Anti-patterns

Shared infinite transcript as bus. Contamination as a service.

Agents that renegotiate the job goal. Goal changes are human or intake-only.

Peer agents with identical tools. Confusion and double writes.

Handoff via screenshots or Slack vibes. Not a system.

Interface-first design workshop (90 minutes)

Before naming agents, fill a table:

| Stage | Input package | Output artifact | Tools allowed | Evaluator criteria |

If two stages share the same tools and criteria, they are one stage. If a stage cannot name its output artifact type, it is not ready to be an agent.

This workshop kills vanity topologies faster than any model comparison.

Versioning contracts between agents

Handoff schemas get versions (handoff.v1, handoff.v2). Consumers declare accepted versions. Breaking changes require a migration plan. Silent field reuse (“notes used to be free text, now it’s JSON”) is how production bleeds.

Contract tests run in CI: sample packages must validate; sample worker outputs must validate before merge.

Latency and fan-out economics

Each extra agent adds model latency and handoff overhead. Parallel specialists only pay off when wall-clock matters and merge is cheap. For many internal ops jobs, a serial relay is faster to operate even if slightly slower to run, because traces are linear and blame is obvious.

Budget remaining must decrement across the whole relay. A fresh budget per agent is how fleets overspend while each agent “stayed under cap.”

Human handoffs

Escalation to a human is a handoff pattern too. Use the same package schema plus a UI that shows failures and proposed next actions. Do not dump the human into a raw transcript and call it collaboration.

Spurlock Studios defaults pilots to worker+evaluator; additional agents appear when interfaces are crisp. $1,500 · 5 days — /agentic. Broader map: operating manual.

Package size budgets

Handoffs should be small. Point to artifact URIs instead of inlining megabytes of tool dumps. Large packages tempt the next model to ignore the middle. If B needs raw tool JSON, B should re-call a read tool under its own sandbox, not inherit a secret-laden blob from A.

Failure propagation

If A failed evaluation, B should not pretend success. Either B is a reviser consuming failures, or the machine escalates before B starts. Silent resetting of evaluator state at the hop boundary is a classic multi-agent bug.

Naming agents after verbs

retrieve, draft, judge, writeback beat alice, bob, and genius. Verb names clarify tools and keep vanity headcount down.

More in the manual. Prove one hop pair after a thin pilot: /agentic.

Handoff acknowledgements

B should emit accepted or rejected_schema before heavy work. Fire-and-forget relays hide poison packages until cost is spent. Acknowledgements also help observability stitch timelines.

Backpressure

If escalate queues are deep, intake should shed load or degrade to human-only rather than spawning more agents. Multi-agent handoff patterns that ignore queue depth create cascading spend.

Agent orchestration for business teams

Prefer a workflow rail as orchestrator. Keep LLMs in specialist roles. Business users understand tickets moving across statuses; mirror that. Status = state. Assignee = agent role. Attachment = artifact URI.

When you outgrow one worker, add a specialist with a contract — after scores say you earned it. Start: /agentic.

Example relay: research → draft → judge

1. Librarian returns chunks or no_hit package.
2. Drafter writes summary JSON with citation keys.
3. Evaluator judges criteria; on fail, drafter revises with evidence; on pass, writeback agent patches internal field only.

Each hop validates schema. Writeback never runs on fail. Budget decrements along the path. Trace ids remain constant. This is multi-agent handoff patterns without a chat room of agents arguing.

When orchestration becomes the product

If your customers buy “an agent platform,” handoff contracts, sandbox catalogs, and evaluator harnesses are the product. Fancy persona names are not. Agent orchestration for business buyers should look like operable workflow, not sci-fi.

Load testing handoffs

Replay 1,000 packages through B including 10% invalid. Confirm reject paths. Duplicate 5% of deliveries; confirm idempotent writes. Chaos is how you learn before customers do.

Human language for stakeholders

“Agents pass a form to each other” lands better than “autonomous swarm.” Use forms/packages in executive updates. Save swarm language for conferences if you must — not for production ownership.

Lost context is usually a schema problem, not a model problem. Fix the package. Broader map: operating manual. Prove the thin path first: /agentic.

Closing note on fewer agents

The best multi-agent handoff patterns often wait. Ship one worker and one evaluator with a typed escalate package to humans. Add specialists when an interface is boringly obvious and scores are green. Agent orchestration for business is mostly contracts and rails. Start narrow on /agentic; keep the operating manual handy when you split roles later.

One more operating rule

If a handoff cannot be validated with JSON Schema in CI, it is not ready for production volume. Schema-first relays are how multi-agent systems stay boring enough to operate on a Tuesday.

Pass budget remaining and revisions remaining on every hop — no exceptions. Fresh wallets per agent are how fleets overspend while each hop claims compliance. Add tool outcomes already tried so the next agent does not repeat a burned call.

Keep the package small enough to read.

Typed packages beat shared transcripts every time — especially when money or customers are in the blast radius.

FAQ

What are multi-agent handoff patterns that work?

Relay with typed packages, hub-and-spoke with a deterministic coordinator, worker–critic loops, and carefully partitioned parallel specialists. Start with relay plus critic.

What does agent coordination for business require?

Clear roles, enforced state transitions, idempotent writes, budget propagation, and one escalation path. Coordination is mostly systems engineering, not prompt poetry.

How do you avoid lost context between agents?

Schema-validate handoff packages with job IDs, artifacts, evaluator failures, tools tried, and budget remaining. Pass references to durable facts instead of dumping full histories.

When should we add a third agent?

When a second specialty has a crisp interface and the two-agent path already meets pass-rate and cost targets. Specialty without interface is just headcount for models.

Can Spurlock Studios build multi-agent systems?

Yes — Tier 2+ style builds split workflows across agents with evaluation harnesses. Pilots stay intentionally thin. See /agentic and the operating manual.

Should the coordinator be an LLM?

Prefer code or workflow logic for routing and budget enforcement. Use a model coordinator only for soft classification inside intake, with hard policy checks after.