What Is Agent Handoff? The Waggle Standard

Agent handoff is how one AI agent passes context and finished work to another agent so the second one can keep going without starting over. It is the seam where a research agent gives its findings to a drafting agent, or where your coding agent hands a plan to an execution agent, and it breaks more often than any single agent does.

The standards world is moving on this fast. The Agent2Agent (A2A) protocol, which governs how agents talk across vendor boundaries, passed 150 organizations backing it in its first year after moving under Linux Foundation governance. Communication is getting solved. The harder problem is the work product itself: what exactly gets handed over, who made it, and whether the receiving agent can trust it.

Key Takeaways:

Agent handoff is the transfer of context and work products between AI agents, and it is where most multi-agent systems quietly lose information.
The standards split into layers: A2A handles agent-to-agent communication, MCP handles agent-to-tool connections, and a newer idea, the artifact reference, handles the work product passed between agents.
Waggle proposes a roughly 30-byte reference that stands in for an artifact, carrying attribution and provenance instead of a copied blob of text.
Small references matter because pasting full work products between agents burns context window and destroys the record of who produced what.
Handoff standards are early. Adopt the communication layers now, and watch the work-product layer as it matures.

What Is Agent Handoff (and Why It Breaks)

A handoff is the moment one agent stops and another picks up. In a single-agent workflow it does not exist. The instant you chain two agents, or run a team of them, every boundary between them is a handoff, and every handoff is a chance to lose something.

Three things break at that seam.

Context loss. The usual handoff is a wall of free text. Agent A writes a summary of what it did, Agent B reads that summary and tries to reconstruct the real state. Detail evaporates in the compression. The receiving agent works from a lossy paraphrase, not the actual artifact.

No attribution. When a drafting agent produces a paragraph and a review agent edits it and a third agent ships it, nothing in the final output records that chain. If the claim turns out to be wrong, you cannot walk back up the lineage to find where it entered. There is no provenance.

Unparseable format. Free-text handoffs are written for a human reader who is not there. Another agent has to re-parse prose to extract structure that was structured a moment ago, then got flattened into a sentence.

Consider Priya, a platform engineer wiring a three-agent pipeline: one agent researches a topic, one drafts a report, one formats it for publishing. In testing it looked clean. In production the draft agent kept citing figures the research agent never found, because the handoff between them was a 400-word summary that dropped the source table. She spent two weeks adding a shared scratch file, a naming convention, and a manual check before the pipeline stopped inventing numbers. The agents were fine. The seam between them was the bug.

Waggle's README puts a number on how common this is, claiming that "roughly 37% of multi-agent failures trace to exactly this seam". Treat that as the project's own figure rather than an independent benchmark, but it matches what anyone who has chained agents has felt.

What this resolved: A clear definition. Agent handoff is the transfer point between agents, and it fails through context loss, missing attribution, and format that the next agent cannot cleanly read.

What it left unsolved: Naming the problem does not standardize the fix. That is what the next section is about.

Waggle: A 30-Byte Artifact Reference Standard for Agent Handoff

Waggle is an early open project that reframes the handoff. Instead of copying an artifact from one agent into another, an agent "mints" a reference to it and hands over the reference. The README describes it as, in its words, a token that is "not a path, not a URL, a handoff that answers back."

The reference is small on purpose. Per the README, it is "a ~30-byte attributed name for an artifact, minted in one call," and "a path is a 30-byte reference, which is exactly the right size for a handoff." That size is the whole point. Only the short string enters the receiving agent's context. The artifact behind it never travels unless something actually fetches it.

Agent handoff: a free-text blob versus a ~30-byte attributed artifact reference

Behind the string sits what Waggle calls an attribution manifest. The README says it records "who minted it (Ed25519-signed when the host holds an identity), for which channel, from which parent (delegation forms a lineage tree), with variants." Unpack that and you get the three things free text loses:

Who made it. The minter is named, and cryptographically signed when the host has an identity to sign with. Attribution survives the handoff.
Where it came from. A parent link forms a lineage tree, so you can trace a work product back through every agent that touched it. That is provenance, built in.
What view each consumer gets. Variants let one reference resolve into a different projection for each reader, so a summarizer and an executor can pull what each needs from the same token.

Consumption runs over MCP. The README states plainly that "waggle is an MCP server," which means an agent in Claude Code, Codex, or Cursor resolves a reference the same way it calls any other tool, with one config line and no SDK. That is a deliberate design choice: ride the connection layer that agents already speak.

Waggle's GitHub README: the artifact-reference resolver runs as an MCP server an agent adds in one config line

Why does small size matter beyond tidiness? Because the alternative is expensive. Waggle cites the industry pattern that "multi-agent systems consume ~15x the tokens of a chat session," attributing the overhead to "duplicating context across agents and summarizing results for handoffs." Again, read that as Waggle's framing rather than a neutral measurement, but the mechanism is real: every time you paste a full artifact into the next agent's prompt, you pay for it in tokens and you overwrite the record of who wrote what.

What this resolved: A concrete mechanism. Hand over a tiny attributed reference, not a copied blob, and attribution plus provenance ride along for free.

What it left unsolved: Waggle is one early project, not a ratified standard. Whether the artifact-reference idea converges into something the whole ecosystem adopts is still open.

How Agent-to-Agent Context Handoff Works Today

Step back from any single project and the standards landscape sorts into layers. Getting the layers straight is the fastest way to understand where agent-to-agent communication stands in 2026.

MCP is the tool layer. The Model Context Protocol, the open standard introduced by Anthropic, connects an AI application to external systems: data sources, tools, APIs. Its own docs call it "a USB-C port for AI applications." MCP answers the question, how does an agent reach a tool or a dataset.

A2A is the communication layer. A2A is, per its docs, "an open standard for seamless communication and collaboration between AI agents." It lets "independent agents, including those using MCP, discover each other, delegate tasks, and share results." A2A answers a different question, how do two agents that were built separately talk to each other and hand off tasks across a boundary.

The work-product layer is the newest. Neither of the two above fully specifies the thing being handed over. A2A moves a task and a result across the wire, but the fidelity of the artifact inside that exchange, its attribution and lineage, is exactly what projects like Waggle are trying to formalize as a reference rather than a paste.

A quick way to hold it in your head: MCP is agent-to-tool, A2A is agent-to-agent, and the artifact reference is agent-to-artifact. The first two are maturing in public. The third is where the interesting, unsettled design work is happening right now.

Three layers of agent coordination: A2A agent-to-agent, the artifact reference work-product layer, and MCP agent-to-tool

Take Marcus, an ops lead at a mid-size SaaS company running a support-triage system. His stack already used MCP so each agent could read the ticketing tool. Adding A2A let his triage agent delegate a billing question to a separate finance agent that another team owned, without either team rewriting the other's code. What still stung was trust: when the finance agent returned an answer, nothing said which underlying record it came from. That missing provenance, not the communication, was the gap.

What this resolved: A layered map. MCP for tools, A2A for cross-boundary agent communication, and a separate emerging layer for the work product itself.

What it left unsolved: The work-product layer has no winner yet, so teams building today wire attribution by hand.

Agent Interoperability: What Handoff Standards Mean for Multi-Agent Systems

Agent interoperability is the ability of agents built by different teams, on different frameworks, to work together without custom glue for every pair. Handoff standards are the load-bearing part of it, because interoperability is worthless if the thing handed across the boundary arrives degraded.

The momentum is real and worth reading as a signal. A2A grew from more than 50 to over 150 supporting organizations in its first year under Linux Foundation governance, with named backers including AWS, Cisco, Google, IBM, Microsoft, Salesforce, SAP, and ServiceNow. The same announcement notes that Microsoft integrated A2A into Azure AI Foundry and Copilot Studio and that AWS added support through Amazon Bedrock AgentCore, alongside production deployments across supply chain, financial services, and IT operations. The A2A project itself is open source under the Linux Foundation, originally contributed by Google.

A2A protocol adoption in its first year: from 50 to over 150 organizations under Linux Foundation governance, backed by AWS, Google, Microsoft, IBM and more

When the major clouds converge on one communication standard inside a single year, the interoperability question shifts. It stops being "will agents be able to talk" and becomes "what quality of work can they actually hand each other." That is why the work-product layer matters more than it looks. A hundred and fifty organizations agreeing on how agents connect does not, by itself, guarantee that a report handed from one agent to another keeps its citations, its authorship, and its edit history.

For anyone designing a multi-agent system today, the practical read is: adopt the communication layers that already have consensus, and design your own handoffs so that attribution and provenance survive, because the standard that guarantees it for you is not finished.

What this resolved: Interoperability is arriving at the communication layer, backed by the major clouds and a foundation.

What it left unsolved: Connection consensus does not equal work-product fidelity. The layer that preserves what gets handed over is still forming.

How MoClaw Handles Context Across Multi-Step Tasks

Most of this article is about handing work between separate agents. There is a quieter version of the same problem inside a single agent that runs a long, multi-step task, and it is where a general-purpose platform like MoClaw actually lives.

A real MoClaw task rarely happens in one move. Ask it to research a topic, draft a summary, and format the result for a channel, and internally that becomes a chain: gather sources, hold onto them, produce a draft that references those sources, then format without losing them. Each step is a handoff to the next step, and the failure mode is the same one Priya hit earlier: the draft cites something the research step never actually found.

MoClaw keeps that from happening by persisting context across the steps of a task rather than re-summarizing it at each boundary. Memory carries the working state forward, so the formatting step is operating on the same artifacts the research step produced, not a lossy paraphrase of them. Think of it as the applied, single-workflow version of what handoff standards are trying to formalize between separate agents: keep a durable reference to the real work product, do not flatten it into prose and hope the next step reconstructs it.

The honest framing: MoClaw is not proposing a cross-vendor artifact standard, and it does not need to. Within one managed task, it controls both ends of every handoff, so it can hold context instead of shipping it as text. Standards like Waggle and A2A exist precisely because that control disappears the moment two independently built agents have to cooperate. If your work stays inside one agent's multi-step task, a platform that persists context solves the handoff for you. If it crosses agents you do not own, you are back in standards territory. You can see the multi-step pattern in MoClaw's use case library.

What this resolved: Inside a single multi-step task, persistent context is the handoff solution, and it is available today.

What it left unsolved: It does not extend across agents built by other teams. That is still the standards' job.

FAQ

What is agent handoff?

Agent handoff is the transfer of context and completed work from one AI agent to another so the second agent can continue the task. It happens at every boundary in a multi-agent workflow. Most information loss in these systems occurs at the handoff, not inside any single agent.

What is the Waggle protocol?

Waggle is an early open project that handles agent handoff by minting a roughly 30-byte reference to an artifact instead of copying the artifact itself. The reference carries attribution and lineage, and agents resolve it over MCP. Per its README, only the short string enters the next agent's context.

How do AI agents share context with each other?

Today they use layered standards: MCP connects an agent to tools and data, and A2A lets separate agents communicate and delegate tasks across boundaries. The work product passed between them is the least standardized part, which is what artifact-reference projects like Waggle aim to fix.

Is agent handoff the same as A2A?

No. A2A is the communication protocol that lets two agents talk and delegate. Agent handoff is the broader act of passing work between agents, which includes the fidelity of the artifact itself. A2A carries the exchange, but does not by itself guarantee the handed-over artifact keeps its attribution and provenance.

Where Agent Handoff Standards Go From Here

The communication layer is close to settled. A2A has the clouds and a foundation behind it, MCP has become the default way agents reach tools, and both are safe to build on today. The open frontier is the work product: the artifact that moves across the handoff, and whether it arrives with its authorship, sources, and edit history intact.

If you are building a multi-agent system this year, the move is to adopt the mature connection layers now and treat the work-product layer as something you engineer yourself until a standard wins. Keep a durable reference to real artifacts instead of pasting them between agents, record who produced what, and do not trust a free-text summary to carry state across a boundary. Whether Waggle specifically becomes the standard is unknowable, but the shape of the answer, a small attributed reference instead of a copied blob, is where the design is clearly heading. Watch that layer, because it is the one that decides whether a team of agents can actually be trusted with work that matters.