Everyone shipped the same feature this month: one shared brain for all your agents. What one agent learns, every agent can read. It is a genuinely good idea, and it solves a real problem.

It also creates a new one, and the new one is harder.

When three agents share one memory, the memory fills up with claims. One agent writes that the research is done. Another writes that the draft passed review. A third reads both claims and builds on them. Weeks later someone asks the questions that matter: what was actually done, what did each step return, what failed along the way, and has any of that record been edited since?

The shared brain cannot answer. It stores what agents said about the work. It does not store a checkable record of the work itself, because that record has to be created somewhere else: at the moment each step runs, in a form the next agent, or the client, can verify without asking anyone's permission.

That form is a chain of custody. Here is a real one, from this afternoon: https://zambo.dev/handover/ed184d30-f46b-4664-bfc2-4a79fc24d54e

The job behind that link ran in 18 steps, and the record does not flatter it. The first steps are capability searches, and two of them came back with "That capability is not available on the default connection." A prompt safety check passed. A plan was recorded. Four work steps ran. Then the job checked itself, and the checks failed four times in a row: a bounded rubric asked whether every supplied statement carried a citation marker, and the citation check at step 11 recorded failed_unfixed; the first retry at step 13 recorded failed_unfixed; the second retry at step 15 recorded failed_unfixed; and a fourth check at step 16, on whether the numbers carried citations, also recorded failed_unfixed. The job then gathered its receipts anyway and handed the whole thing over, failures included, as step 18.

Every one of those 18 steps carries its own receipt, and the page commits to a digest of the exact step list. The published bytes of each step are checked against what was recorded, and the page even gives you a box: change one character, watch it fail. The wrap-up itself is a receipt too: https://zambo.dev/run/caf88138-ea91-4a32-b144-ebb38fdea3db

That is the difference between memory and custody. Memory tells the next agent what to do next. Custody tells it what was recorded and whether that record has changed since it was saved. A shared brain full of unchecked claims is a faster way to compound a confident mistake: the wrong claim gets read by every agent, instantly, forever. A custody record does the opposite. It shows the next agent the dead ends and the failed checks alongside the wins, in a form it does not have to take on faith.

Honest limits, because the page states them itself and so will I. This record does not prove who the producer is: origin is self-asserted, and the page says so in its own "what this does not prove" list. It does not prove the work meets the recipient's needs. And a receipt proves the saved result was not changed since it was saved, never that the result was right. Judging the work is still your job. The receipt's job is narrower: it makes the record itself checkable, so the judging happens against the record instead of against another agent's memory of itself.

The numbers behind this are public, which is the point. Zambo's public receipt count stood at 110,043 today, with 2,146 receipts issued since midnight UTC. Every one of them is a saved result somebody can check. Shared memory will keep getting better, and it should. But when work changes hands, the teams that hold up are the ones who can hand over the record itself: every step, every failure, unchanged since the moment it was saved.

Give your agents the shared brain. Then give their work a chain of custody.

Add Zambo to your agent: https://zambo.dev/add/ (20 calls and 1 wrap-up free every day; picking up in another AI is always free).