# I 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 AIs: the brief, the decisions, the half-finished step are scrollback in the AI you left, and the new AI gets your lossy re-telling of them. 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 with receipts, wrapped as a handover the next AI picks up for free and continues, so nothing is re-briefed and nothing is redone.

- HTML version: https://rambozambodotdev.gitlab.io/aer1-hub/i-switched-ais-and-lost-the-thread-of-the-job.html
- Start free: https://zambo.dev/add/
- Endpoint: https://zambo.dev/mcp
- Verify any receipt: https://zambo.dev/verify/
- Deeper: https://rambozambodotdev.gitlab.io/aer1-hub/pick-up-your-work-in-another-ai.html and the starter repo https://github.com/zambodotdev/zambo-memory-loop-starter

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. Author: Brennan Zambo.

## New to this? Start here, no code

Both AIs need the Zambo endpoint added (https://zambo.dev/add/). Paste the first block into 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.
```

And this block into 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.
```

## The pattern

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.
3. Free pickup: the second AI 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.

## The real run

Executed November 2, 2026, job uc-switch-2026-11-02, two identities with separate caller handles. The client is a labeled sample in the records.

- Brief from the first AI: https://zambo.dev/run/845682e3-4097-4118-9f15-6df1e4b70335
- Figure 1 (BTC reference): https://zambo.dev/run/e2783531-d410-4e34-b9da-5c89f2ba560e
- Progress step, the stopping point: https://zambo.dev/run/c93f4847-7592-4b71-949b-18a2053a629a
- The pause handover (9 steps, accepted on pickup): https://zambo.dev/handover/4571d90d-869e-4852-8c9d-748abd564770
- Continuation step from the second AI: https://zambo.dev/run/a8af79c2-e262-413e-a962-0185aabae1ef
- Figure 2 (ETH reference): https://zambo.dev/run/84825139-ab14-4be8-97a9-9c2a73457fdd
- Draft assembled: https://zambo.dev/run/79ce98f1-c1b5-4126-83d7-893b98f24819
- The completion handover (17 steps, 17 of 17 step receipts checked): https://zambo.dev/handover/e5228a67-b511-47d4-9f9d-cd794aec242e

## What this costs

The free tier is per identity: 20 calls + 1 wrap-up free every day, pickup always free. This run spent 6 counted calls across two allowances. A Day Pass is $0.99 per identity for 24 unlimited hours; the Zambo Pass is $29 per identity for 30 days; one-time payments, never subscriptions. Start: https://zambo.dev/add/

## 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.

## Related

- The index of receipt use cases: https://rambozambodotdev.gitlab.io/aer1-hub/receipt-use-cases.html
- Start in one AI, pick it up in another: https://rambozambodotdev.gitlab.io/aer1-hub/pick-up-your-work-in-another-ai.html
- The daily loop pattern guide: https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
- The starter repo: https://github.com/zambodotdev/zambo-memory-loop-starter

For work that runs past one day: a Day Pass ($0.99) is unlimited for 24 hours. Ongoing access is the Zambo Pass: $29 for 30 days or $290 for 365 days, one-time payments, never a subscription, and $19 for 30 days for $ZAMBO holders, on the same endpoint, with a verifiable receipt on every call. Pricing: https://zambo.dev/pricing/

Zambo, the verifiable work layer for AI. https://zambo.dev/ · MCP endpoint https://zambo.dev/mcp · AER-1 draft https://datatracker.ietf.org/doc/draft-zambo-aer1/26/