Your agent finished the job in another app. The work is stuck there.

Three things get trapped when an agent works in one app

The context. What you asked for, what the agent decided along the way, what it tried and ruled out: all of it sits in the app's thread. A second AI cannot see that thread. It gets your summary of it, written from memory, after the fact.

The work itself. The files, the drafts, the data it pulled, the intermediate results: stored inside the app, in the app's formats, behind the app's login. Moving the job means exporting, downloading, and re-uploading by hand, and every manual hop is a place for the current version to stop being the version that moves.

The proof. The only evidence any of it happened the way the agent says is the agent's own closing message. In personal agent apps the pattern is the same: the agent reports the task done, and you take its word, because there is nothing outside the app to check the word against. Inside one app, that is an inconvenience. The moment the work matters to someone else, a client, a teammate, a second AI that has to build on it, it is the whole problem.

A handoff inside one app is not a handover

Personal agents are good at handing tasks around inside their own walls: a morning brief proposes the work, you approve it, the same agent picks it up later in the same thread. That loop is real and useful, and it never crosses an app boundary. The agent's memory, its connected apps, and its records all belong to the one product.

A handover is a different object. It is a record addressed to whoever comes next: a different AI, in a different app, possibly from a different maker, or a human reviewer. It carries the deliverable, the steps with receipts, the sources, the decisions, and an explicit list of what was not checked, and it ends with the receiver's own recorded response. Nothing about it requires the receiving side to trust the sending side, because the steps can be checked instead of believed. That is the gap a personal agent, by design, does not fill: it is the worker, not the road between workers.

How the work moves: one endpoint both apps already accept

1. Add the endpoint once per app. Zambo is a remote MCP server at https://zambo.dev/mcp. Claude, ChatGPT, Cursor, Grok, VS Code, and Windsurf each add it in their connection settings; coding tools take a one-line config or command. No API key to start.
2. The first AI does the job on the shared layer. Its Zambo calls return receipts as they run, and when the job is ready to move, you ask it to hand the work over. The handover is saved as one link holding the whole record.
3. The second AI opens the link and continues. It reads the steps, the sources, and the not-checked list, picks up where the record stops, and its own work extends the same chain. This is not a context paste: the record is the job, not a description of the job.
4. Anyone can check any step. Every receipt on the chain recomputes free at zambo.dev/verify, including by the client the work was for, with no Zambo account and no access to either app.

This already runs in the open. A two-AI chain where one agent's audited work was handed over and accepted by the receiving side is public: the accepted audit handover. The flagship work record at bd7e5325 shows the same shape from the sending side.

What the receipt proves, and what it does not

A verifiable AER-1 receipt proves one narrow thing completely: the saved result of a call has not changed since it was saved. Anyone can recompute the commitment and compare. It does not prove the agent's work was correct, and it does not turn a bad result into a good one. What it changes is who has to be trusted. Without the receipt, continuing the work in another app means trusting the first agent's summary, the first app's export, and your own retyping. With it, each step of the record can be checked by the receiver before they build on it, and the argument about what ran is over in seconds.

That is why the layer sits under the agents instead of replacing them. Your personal agent keeps doing the work, in the app you like, with the memory it keeps there. The jobs that have to outlive that app, because another AI continues them, a client judges them, or you switch tools mid-job, run on the layer that carries them.

The gap, counted on a live stream

Zambo's public receipt stream shows calls as they land, and the busiest traffic on the layer is carrying work, not answering questions. In the 100 most recent receipts at 20:49 UTC on 2026-10-22, a 48 minute window counted from the public feed, agents ran 20 different tools: 29 of the 100 were workflow closes sealing multi-step runs, 7 were continuity reads pulling a job's recent state back up, and 3 were handovers moving work to a receiver. Counted from the public receipt feed on 2026-10-22; the stream is live, so the counts move.

On the other side of the gap, the workaround is folklore, not a feature. A practitioner writing about working with Claude across surfaces describes the manual version plainly: ask the first chat to "craft a self-contained handoff brief", because "the context from one surface is not automatically available to another surface". A brief is a retelling written by the agent that did the work. A handover record is the work itself, with the receipts attached.

Questions, answered