Direct answer
You switched AIs and lost the thread of the job. Pick it up instead.
The thread of a job lives in the chat, and the chat stays behind when you switch: the brief, the decisions, the half-finished step are scrollback in the AI you left, and the new AI gets your re-typed summary of them, losing a qualifier every round trip. When the work runs on Zambo under one job id, the thread is the job's record instead: brief, steps, and stopping point saved as they happened, wrapped as a handover the next AI picks up for free and continues. Switching stops being an export problem.
Updated November 2, 2026. First published November 2, 2026. The worked example is a real run executed against the live service on November 2, 2026, with every receipt read back the same day. The client in the run is fictional and labeled a sample in the records themselves.
New to this? Start here, no code
Both AIs need the Zambo endpoint added (zambo.dev/add). Paste the first block into the AI you start in, and the second block into the AI you switch to.
The paste, for the AI you start in
Start this job so another AI can pick it up, on Zambo: 1. Connect to https://zambo.dev/mcp. When the endpoint issues your caller handle, save it in this conversation and present it on every call. 2. Open one job: pick a single job id and call memory_remember with the brief under it: the goal, what done looks like, and where the pieces live. Keep the receipt. 3. Save each step under the same job id as you finish it, and save a short progress step whenever you are about to stop: what is done, what is next, what to watch out for. 4. Wrap the job with handover: a summary naming what is done and what remains, a goal, the next AI as the recipient, and next steps. Send the handover link to wherever the next AI will see it. The thread now lives in the link, not in this chat.
The paste, for the AI you switch to
Pick up a job started in another AI, on Zambo: 1. Connect to https://zambo.dev/mcp. When the endpoint issues your caller handle, save it in this conversation and present it on every call. Your handle is different from the first AI's, and that is fine: identity is yours, the job is shared. 2. Pick the handover up with handover_accept. Picking up is always free. Read the brief and every saved step from the pickup record before doing anything; do not re-ask for the brief. 3. Continue under the same job id: save your steps as you go, exactly where the first AI left off. 4. Wrap the finished job with handover. The final record holds both AIs' steps in order, so the thread reads whole: started there, finished here, nothing restarted.
Why switching AIs loses the thread
The thread lives in the chat, and the chat stays behind. The brief, the decisions, the half-finished step: all of it is scrollback in the AI you are leaving. The new AI gets your re-typed summary of it, which is a summary of a summary by the time work resumes.
Re-briefing is not free, it is lossy. Every re-told brief drops the qualifier that mattered and the dead end already explored. The second AI cheerfully redoes finished work and re-walks the dead end, and you pay for both.
The job can live outside both chats. When the work runs on Zambo under one job id, the thread is the job's record: brief, steps, progress, saved as they happened with receipts. Switching AIs stops being an export problem. The next AI picks the record up, free, and continues the same job.
The pattern
Step zero: each AI holds its own caller handle; two AIs are two identities, and the record keeps their steps attributed separately.
1. Brief and work in one job: the first AI saves the brief and its steps under one job id.
2. Wrap at the pause: a progress step plus a handover addressed to the next AI; the wrap's proof loop binds the steps so far.
3. Free pickup: the second AI accepts the handover, reads the steps from the record itself, and continues the same job id.
4. Wrap the whole thread: the final handover holds both AIs' work in order, one record from brief to done.
The real run: started in one AI, finished in another, one thread
Executed November 2, 2026, against the live endpoint, job uc-switch-2026-11-02, two identities standing in for two AIs, each with its own caller handle. The first AI opened the job with the brief (a labeled SAMPLE quarterly summary for a fictional sample client): receipt 845682e3. It gathered figure 1, a BTC reference price: receipt e2783531, saved its stopping point as a progress step: receipt c93f4847, and wrapped the job: the pause handover, 9 steps, status accepted after pickup.
The second AI, a different caller handle that had never seen the first chat, picked the handover up free, read the brief and the progress step from the pickup record, and saved its continuation in the same job: receipt a8af79c2. It gathered figure 2 (ETH): receipt 84825139, assembled the sample draft: receipt 79ce98f1, and wrapped the finished job: the completion handover (JSON twin here), 17 steps, 17 of 17 step receipts checked. Nothing was re-briefed, nothing redone: the second AI's first act was reading, and its work starts exactly where the first AI's stopped. The shape is taught at depth in start in one AI, pick it up in another and in the daily loop guide, with a pre-wired starter at zambo-memory-loop-starter.
Audit this switch yourself
Open the completion handover and read the steps in order: the first AI's brief, its figure, its stopping point, then the second AI's continuation and finish, attributed per step to the identity that ran it. Check any receipt at zambo.dev/verify. A receipt proves the saved result was not changed since it was saved; across a switch, that is what lets the second AI trust the first AI's steps instead of redoing them. If a receipt from this run ever fails to verify, that is news: write to brennanzambo@zambo.dev.
What this costs
The free tier is per identity: 20 calls + 1 wrap-up free every day for each identity's own caller handle, and picking up in another AI is always free, so the rescue itself never costs the incoming AI a call. Counted from the run: the first AI spent 3 counted calls plus its free wrap; the second AI spent 3 counted calls plus its free wrap, pickup free. A working day that hops AIs a dozen times is what the paid line smooths out: a Day Pass is $0.99 per identity, unlimited for 24 hours, and the Zambo Pass is $29 per identity for 30 days, one-time payments, never subscriptions. Start at zambo.dev/add.
What Zambo is not here
Zambo does not move your chats, your files, or your subscriptions between AIs, and it does not make two AIs think alike. It holds the job's record outside both chats, so the thread of the work survives the switch: the brief, the steps, and the stopping point, readable by whichever AI picks them up next.
Frequently asked questions
I switched AIs in the middle of a job and lost the thread of the work. How do I keep it?
Keep the thread outside both chats. Run the job on Zambo under one job id: the first AI saves the brief and its steps there, wraps the job as a handover at the pause, and the next AI picks that handover up for free, reads the steps from the record itself, and continues the same job. On the run on this page the second AI's first act was reading, and its work started exactly where the first AI stopped.
Do both AIs need the same account or handle?
No, and they should not share one. Each AI holds its own caller handle; identity is per AI, the job is shared. The record attributes every step to the identity that ran it, which is what lets each side trust the other's steps.
What does the pickup cost the incoming AI?
Nothing. Picking up a handover is always free, at every tier, and reading the record it returns costs no calls. The incoming AI spends its own calls only on the new work it does.
Does a receipt prove the first AI's steps were right?
No. A receipt proves the saved result was not changed since it was saved. Across a switch that is the property that matters: the second AI can rely on the steps being the steps as saved, instead of redoing them out of caution.