ZAMBO.

Direct answer

The loop by use case: one routine, pre-built for every daily job

Counted from the public receipt stream, 4,247 distinct callers used Zambo in the week this page was written, and 98.5 percent of them came exactly one day. The 17 who kept coming back run one shape: pick up yesterday's work for free, recall what was saved, do the job, remember what changed, wrap it for tomorrow. That shape is the loop, and this page pre-builds it for the everyday jobs agents already run. Each recipe below is a runnable file with the loop already wired, a standing instruction ready to paste, its free-tier cost counted, and a real run executed against the live service, with the receipts to read.

See the instrument first: the live demo runs one real call and hands you its verifiable receipt, no signup.

Updated November 2, 2026. First published November 2, 2026. Every worked example below is a real run executed against the live service on November 2, 2026, with every receipt read back from the service the same day.

One loop, five steps

Every recipe on this page is the same five steps; only step 3 changes. The discipline that makes it work is step zero: when the agent first connects, the endpoint issues a caller handle. The agent saves it and presents it on every call, and its job, its memory, and its daily free allowance all key to that handle. The deep version of the recipe, with the accounting, lives on the heartbeat page.

1. Pick up: continuity_get_recent reads the job's saved steps and the last run's handover. Free, always.
2. Recall: memory_recall returns the facts earlier runs saved.
3. Work: the job itself, one or two real tool calls.
4. Remember: memory_remember saves what the next run must know.
5. Wrap: handover seals the run into one record the next run picks up. The wrap-up is the day's free one.

Watch monitor: the scheduled price watch

The job: an agent checks two assets once a day and has to know whether a move is real. Without memory it re-derives its baseline every morning and cannot say what changed. With the loop, the baseline is a remembered fact and the alert rule is a remembered rule: flag any move of 3 percent or more against yesterday's saved numbers. The file: examples/watch-monitor.py in the starter repo. Run it as-is: python3 watch-monitor.py. Cost of one run: 5 of the day's 20 free calls, plus the free wrap-up.

The standing instruction

1. Connect to https://zambo.dev/mcp and present your saved caller handle.
2. Pick up the job with continuity_get_recent, then memory_recall for the watch rule and the last baseline.
3. Check the watched assets with live_price.
4. Compare against the baseline and flag any move of 3 percent or more.
5. memory_remember the new baseline and whether an alert fired, then wrap with handover.

The real run, November 2, 2026

Lead watch: the daily demand scan

The job: watch one trade in one city for public demand signals, every day, and build a record a human can trust. The loop's contribution is the criteria living in memory instead of in a prompt, and the empty days being written down: a scan that finds nothing has still run, and the next run can only spot the change if this run recorded the calm. The file: examples/lead-watch.py. Set ZAMBO_WATCH_TRADE and ZAMBO_WATCH_CITY to watch your own market. Cost of one run: 4 of the day's 20 free calls, plus the free wrap-up, and one of leadsignal's own 3 free scans a day.

The standing instruction

1. Connect to https://zambo.dev/mcp and present your saved caller handle.
2. Pick up the job with continuity_get_recent, then memory_recall for the watch criteria.
3. Run leadsignal for the watched trade and city.
4. memory_remember the criteria and what the scan found, including an empty result, then wrap with handover.

The real run, November 2, 2026

Research digest: the one-line daily brief

The job: a short daily brief on the assets you follow. A digest bot without memory repeats stories it already sent, because nothing in its world records that it sent them. With the loop, yesterday's takeaway is the first thing today's run recalls, so the brief reports the change instead of the whole story. The file: examples/research-digest.py. Set ZAMBO_DIGEST_SYMBOLS for your own list. Cost of one run with two assets: 5 of the day's 20 free calls, plus the free wrap-up.

The standing instruction

1. Connect to https://zambo.dev/mcp and present your saved caller handle.
2. Pick up the job with continuity_get_recent, then memory_recall for the last takeaway.
3. Check each watched asset with live_price.
4. Write the one-line takeaway and memory_remember it with the prices, then wrap with handover.

The real run, November 2, 2026

Client delivery log: every delivery, a link

The job: client work, delivered by an AI, that the client later asks about. The loop turns each delivery into a written note, a remembered job reference, and a wrapped handover the client can open, so "did you actually deliver that?" is answered with a link instead of an argument. The file: examples/client-delivery-log.py. Its defaults are a fictional sample, marked as a sample in the note itself; set ZAMBO_CLIENT_NAME, ZAMBO_JOB_REF, and ZAMBO_DELIVERABLE to log a real job. The write tool lives on the full tool surface, so the recipe talks to https://zambo.dev/mcp?full=true. Cost of one run: 4 of the day's 20 free calls, plus the free wrap-up.

The standing instruction

1. Connect to https://zambo.dev/mcp?full=true and present your saved caller handle.
2. Pick up the job with continuity_get_recent, then memory_recall for past deliveries on it.
3. Write the delivery note with the write tool.
4. memory_remember the client, the job reference, and what was delivered, then wrap with handover and send the client the link.

The real run, November 2, 2026

Cross-AI daily driver: the loop split across two AIs

The job: work that starts in one AI and continues in another, daily, because that is how the person works. The handover is the bridge: the first AI wraps, the second AI picks the record up for free and keeps going. Each AI keeps its own caller handle, and memory is keyed to a handle, so the receiving AI saves the carried facts into its own memory on pickup; the job's record travels whole, each side keeps its own key to it. No code: the file examples/cross-ai-daily-driver.md carries both standing instructions and the accounting. Cost: the wrap is the first AI's free daily wrap-up, pickup in the second AI is free, and recall, work, and remember count on whichever side spends them, 4 to 10 calls a side on a normal switch day.

The standing instruction, for the AI you start in

1. Connect to https://zambo.dev/mcp and present the caller handle saved in this conversation; if none is saved, take the one the endpoint issues and save it here.
2. Pick up the job with continuity_get_recent, then memory_recall for the standing facts.
3. Do the work. Keep the receipt link of every call in your notes.
4. Before we switch AIs, memory_remember what the other AI must know, then wrap with handover: a plain summary, the receipts, and the next steps written for the receiving AI.
5. Give me the handover link. That link is the whole handoff; nothing else needs to move.

The standing instruction, for the AI you pick up in

1. Connect to https://zambo.dev/mcp and present the caller handle saved in this conversation; if none is saved, take the one the endpoint issues and save it here.
2. Pick up the handover I give you. Picking up is always free.
3. memory_recall for your own standing facts, then memory_remember the facts the handover carries, so your memory holds them too.
4. Continue the work from the handover's next steps. Keep every receipt link.
5. When we switch back, wrap again with handover and give me the new link.

See the bridge before you trust it

No code: the loop as one paste

Use this version for one-off sessions in a chat AI, when there is no scheduler and no code: a single job you want picked up, remembered, and wrapped by hand. Add the endpoint to the AI first (the two-minute setup at zambo.dev/add), then drop this block into the conversation and name the job at the end. The AI saves the caller handle it is issued inside the conversation, so the handle survives exactly as long as the conversation does, and the handover it wraps is the part that survives longer.

The paste

Run this job as a Zambo loop, here in this chat:
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. Pick up: call continuity_get_recent to read the job's saved state.
3. Recall: call memory_recall for the standing facts about this job.
4. Do the job I name below. Keep the receipt link of every call.
5. Remember: call memory_remember with anything the next session must know.
6. Wrap: call handover with a plain summary, the receipts, and the next steps, and give me the handover link.
The job: [write the job here]
The free tier covers this loop: 20 calls + 1 wrap-up free every day. Picking up in another AI is always free.

Next session, in this AI or another one, paste the same block with the handover link from the last wrap: the new session picks the record up for free and the chain continues. When the same job starts running every day, graduate it to one of the files above and let a scheduler hold the handle.

Why pre-built beats hand-rolled

A loop an operator designs for themselves gets designed once and quietly skipped on the busy days. A recipe that ships as a file gets pasted once and then just runs, and every run makes the next one cheaper to start: baselines become a series, criteria stop being re-argued, yesterday's takeaway is the first thing today's run reads. The asset is the accumulated record, thirty handovers deep, each step checkable, and a fresh process cannot copy it quickly. That is the whole bet of the loop, and pre-building it per job is how the bet gets placed without a design meeting.

What a record does not settle

A verifiable receipt proves the saved result was not changed since it was saved; it does not prove the price was right, the scan was complete, the note was well written, or the agent chose the right tool. A recipe makes a job's history checkable, so judgment, the operator's, a client's, another AI's, can rest on a record that is not quietly moving. This page is general information, not legal advice.

Frequently asked questions

What does this page give me that the recipe page does not?

The recipe page teaches one loop for scheduled agents. This page pre-builds the same loop per job: for each use case, a runnable file in the starter repo, a standing instruction ready to paste, the free-tier cost of one run, and a real run executed against the live service on November 2, 2026, with its receipts linked. Nothing structural is left to design: copy one file, run it, and the loop is your agent's daily shape.

What does one run of each recipe cost on the free tier?

The free tier is 20 calls + 1 wrap-up free every day; picking up in another AI is always free. Counted per run: the watch monitor spends 5 calls, the lead watch 4, the research digest 5 with two assets, and the client delivery log 4, and every wrap-up is the day's free one. The lead watch also uses one of leadsignal's own 3 free scans a day. A Day Pass ($0.99) makes the endpoint unlimited for 24 hours when a job outgrows the free shape.

Can I run the loop with no code at all?

Yes. Add https://zambo.dev/mcp to a chat AI and paste the single block in the no-code section of this page. The AI saves the caller handle it is issued inside the conversation, presents it on every call, then picks up, recalls, does the job you name, remembers, and wraps, all in the open. It is the manual shape of the same loop, built for one-off sessions with no scheduler and no code.

What does the record of a run prove?

Each step's receipt proves the saved result was not changed since it was saved, and anyone holding the handover link can open the steps and run the check. It does not prove the price was right, the scan was complete, the note was well written, or the agent chose the right tool. The record settles what the run did and what it saved, so the argument can be about the decisions instead of about whose notes are real.

What happens when a job outgrows the free tier?

The ceiling announces itself plainly: a call past the daily 20 is blocked before it runs, returns its own receipt, and offers the Day Pass. Nothing is silently dropped mid-run, and pickup stays free, so the agent can always read its context even on a day it cannot work. One run of a recipe a day fits the free tier by design. A job that runs hourly, or one operator running several recipes across a fleet, is the natural Day Pass or Pass case: $0.99 for 24 unlimited hours, or the Pass at $29 a month, $290 a year, $19 a month for $ZAMBO holders.

Related

The Loop kit

One routine, every piece of it in one place: the data that found the loop, the recipe, the library of pre-built jobs, the two shapes a daily loop takes, and a starter repo with Zambo already wired in.