ZAMBO.

Direct answer

The scheduled agent heartbeat: pick up free, work, wrap the proof

A scheduled agent has the hardest memory problem in software. Its process dies on purpose: the cron fires, the agent wakes in a fresh session with no thread, no notes, and no memory of yesterday's run, does its job from whatever the prompt happens to repeat, and dies again. Whatever it learned yesterday, a threshold it tuned, a baseline it set, a mistake it already made once, is gone unless something outside the process keeps it. The heartbeat is the loop that keeps it: four steps wrapped around the work the agent already does, so every run starts from the last run's record and ends by extending it. This page gives the recipe in copy-paste form, the accounting that makes it free, and a real run with its receipts.

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

The amnesia tax

Operators patch the memory problem with longer prompts: the scheduled prompt grows a paragraph of standing facts, then a page, then a small handbook. It helps once and then quietly rots. A prompt is a briefing, not a memory: it holds what the operator remembered to repeat, frozen on the day it was written, and it cannot hold what the agent itself learned last night. So the watch agent re-derives its baseline every morning and cannot say what it saw yesterday. The triage agent re-asks questions the operator already answered. The digest bot repeats a story it already sent, because nothing in its world records that it sent it. And when a run goes wrong, there is no record to audit: the process kept no notes, and its output is a claim in a chat log. The heartbeat replaces the growing prompt with a small constant loop and moves the state to where state belongs: saved, receipted, and readable by the next run.

The recipe: four steps around the work

1. Pick up: read the job before touching it

The run opens with continuity_get_recent: the steps already saved on this job, the receipts they carry, and the handover the last run left, including its written next steps. Pickup is free, and picking up in another AI is always free, so a run that starts in a different model than the one that wrapped still pays nothing to read its own history. One piece of discipline makes it work: when the agent first connects, the endpoint issues a caller handle. The agent saves that handle in its own notes and presents it on every call. Its job, its memory, and its daily free allowance all key to that handle.

2. Recall: bring back the standing facts

memory_recall returns what past runs saved: the watch rule, the alert threshold, the last baseline, the decision the operator made last week and the reason for it. On the very first run this returns nothing, and that is correct: the memory is empty until the agent starts keeping it. From the second run on, recall is the difference between an agent that has a history and an agent that has a schedule.

3. Work: the job itself, unchanged

Prices checked, inbox triaged, pages watched, report assembled: whatever the cron exists to do, done the same way it is done today. Nothing in the recipe replaces the work. What changes is that every call returns a verifiable receipt as it runs, under AER-1, draft-zambo-aer1-26, so the run accumulates as evidence instead of as claims in a log nobody can check later.

4. Remember and wrap: hand tomorrow a starting point

Before sleeping, the agent calls memory_remember with what changed: the new baseline, the tuned threshold, the thing it learned, the question still open. Then it calls handover to wrap the run: the steps and their receipts sealed into one record, a plain summary of what was done, and the next steps written for the following run. Tomorrow's agent, usually the same agent in a new process, picks that record up at step 1. The wrap-up is the day's free one; it consumes none of the 20 calls.

The standing instruction, ready to paste into a scheduled prompt

Standing instructions for every scheduled run of this agent:
1. Connect to https://zambo.dev/mcp and present your saved caller handle.
2. Call continuity_get_recent to pick up the job, then memory_recall for the standing rules, thresholds, and baselines.
3. Do the scheduled work. Every call returns a receipt; keep the receipt links in your run notes.
4. Call memory_remember with anything the next run must know: new baselines, changed thresholds, open questions.
5. Call handover to wrap the run: what was done, the receipts, and the next steps for the next run.
The free tier covers this loop daily: 20 calls + 1 wrap-up free every day. Picking up in another AI is always free.

One heartbeat, run live on November 2, 2026

To keep this page honest, the loop was executed for real before it was written up: a fresh agent identity, created for this run and named heartbeat-recipe-run-2026-11-02, running a small daily watch job. The job: check BTC and ETH once a day, and alert only on a move of 3 percent or more in 24 hours against the remembered baseline. What happened, step by step, with the receipts the service issued:

The run, receipt by receipt

Why the free tier covers it exactly

Count a heartbeat. Pickup: free, always. Recall: 1 call. The work: as many calls as the job itself takes, 2 in the example above. Remember: 1 call. Wrap: the day's free wrap-up, 0 calls. A realistic daily heartbeat lands between 4 and 10 of the 20 free calls, with room for a heavier day. That fit is not an accident of generosity; it is the shape of the tier. 20 calls + 1 wrap-up free every day. Picking up in another AI is always free. A cron does not churn, does not forget its instructions, and does not take weekends off, so the same small loop fires every day against the same free allowance, indefinitely. The paid step appears exactly where it should: when the schedule outgrows the loop, an agent waking hourly instead of daily, or one operator running the recipe across a fleet, the use is real and daily, and the Day Pass or Pass is priced for it.

Why the loop compounds

Day one of a heartbeat is barely better than a plain cron: the memory holds one rule and one baseline. The compounding is in what accumulates. Baselines become a series, so the agent compares against last week and not only yesterday. Thresholds get tuned by outcomes the agent itself recorded, and the tuning is in memory with its reasons, not in an operator's head. Mistakes become instructions: a false alert, once saved, is a fact the next run recalls before it decides. And the handover chain becomes the agent's whole working record: an operator auditing a month of a digest bot opens thirty handovers, each step checkable, instead of trusting thirty summaries. Every run makes the next run cheaper to start and harder to fool, and the history is the asset. An agent with ninety days of receipts and memory has something no fresh process can copy quickly, which is the point of giving it a heartbeat in the first place.

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 alert threshold was wise, or the agent chose the right tool. A heartbeat makes a scheduled agent'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 is a scheduled agent heartbeat?

A scheduled agent heartbeat is the loop a cron-driven agent runs at the start and end of every scheduled job. On waking, the agent picks up its job's saved context and recalls its memory before it works; before sleeping, it saves what changed to memory and wraps the run into a handover: the steps, the receipts, and the next steps for the following run. In Zambo the loop runs against https://zambo.dev/mcp: continuity_get_recent to pick up, memory_recall to remember, the work itself, and handover to wrap. Nothing about the schedule changes; the loop is pasted into the prompt the scheduler already runs.

What does the heartbeat 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, so the pickup at the start of a run never tolls the day, and the wrap-up at the end is the day's free one. The worked example on this page used 6 of the 20 calls, including two price checks of real work. A daily heartbeat therefore runs free outright. For $0.99, a Day Pass makes the endpoint, https://zambo.dev/mcp, unlimited for 24 hours, no subscription: get the Day Pass. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders.

How does a scheduled agent remember anything between runs?

Two saved things survive the night. The first is the caller handle the endpoint issues when the agent connects: the agent keeps it in its own notes and presents it on every call, and its job history and memory are keyed to it. The second is memory itself: facts the agent saves with memory_remember, thresholds, baselines, decisions, come back through memory_recall on the next run. In the worked example on this page the loop was run a second time minutes after the first, and the second run's recall returned the exact watch rule the first run had saved. A cron restarts the process; it does not restart the record.

What does the wrap-up at the end of a run prove?

The handover's receipts prove the saved results were not changed since they were saved. Anyone holding the handover link can open each step and run the check, so a month of runs is a chain of records a reader can test one by one. It does not prove the agent's judgment was right: whether an alert should have fired is a decision the reader still makes. The wrap-up 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 scheduled agent 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 heartbeat a day fits the free tier by design. An agent that wakes hourly, or a fleet running the same recipe across many agents, 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 two shapes a daily loop takes, and a starter repo with Zambo already wired in.