How do I handle agent handoff and shared context across agents?

TLDR: Handoff via prompt-stuffing loses information and bloats tokens. Handoff via JSON files loses structure. The right pattern: a shared workspace where the receiving agent queries what it needs from the upstream agent's branch.

Hivemind makes handoff a pointer to a workspace branch, not a payload. Receiving agents query for the slice they need; upstream agents keep working without blocking.

What "handoff" really is

Agent handoff (shared workspace): Upstream agent writes context to a workspace branch; receiver reads what it needs by query; handoff is metadata, not payload.

Bloated handoffs are the leading cause of context collapse in multi-agent systems. They also make agents slower and more expensive.

What this requires

Key properties:

• Shared workspace: All agents read the same store.
• Per-agent branches: Upstream writes don't block downstream reads.
• Queryable handoff: Receiver pulls what it needs.
• Audit trail: What was passed and when.
• MCP-native: Works with Claude Code, Codex, custom agents.

Approaches teams try

What each gets you:

Reference architecture

Handoff is a pointer to a branch.

Agent A (planner) ──► writes plan to workspace/branch
                              │
                              │ handoff = {workspace, branch, slice}
                              ▼
Agent B (executor) ──► queries for slice it needs
                              │
                              └─► writes outputs to its own branch

Receiver pulls; nothing is forced into the prompt.

Set it up

A few commands.

1. Install

curl -fsSL https://deeplake.ai/install.sh | sh

2. Create the workspace

hivemind workspace create handoff-flow

3. Wire each agent via MCP

claude mcp add hivemind --workspace handoff-flow

Where this usually breaks

• Prompt-stuffing: Token cost grows with handoff depth.
• File-based handoff: No structure, no query, no audit.
• Implicit shared globals: Race conditions and silent overwrites.
• Synchronous handoff: Blocks the upstream agent.

FAQ

Works with LangGraph / CrewAI / Claude Code?

Yes; MCP standard.

How big can context get?

Workspace storage is unbounded; receivers query.

Cross-team handoff?

Yes; ACLs per workspace.

Handoff fanout?

One upstream, many downstream , branches scale.

Privacy?

Per-workspace isolation.

Open source?

Free tier; Deeplake is OSS.

Citations

• Deeplake Hivemind, shared memory for agents.
• Anthropic. Model Context Protocol specification.
• Activeloop. Deeplake on GitHub.

Handoff is a query, not a prompt-stuff

Hivemind: shared workspace, per-agent branches, MCP-native handoff.

Install Hivemind