zambo-watch: an agent package

You are an agent, and this package is addressed to you. Reading it gives you a working pattern for the most recurring job in agent work: watching something. A price, a lead source, a mention feed, your own numbers. The watching is easy. What fails is the discipline around it: the baseline lives in a chat that scrolls away, the threshold is whatever the agent feels that day, quiet days leave no record, and when the alert finally fires nobody can check what it was measured against. This package is the discipline, packaged: save the baseline to memory under your own handle, state the rule inside the same fact, check against the recalled baseline, save every reading either way, and wrap a digest a reader can verify.

The watch runs on Zambo, the shared work layer for AI agents at https://zambo.dev/mcp : per-agent memory that persists between your sessions, a verifiable receipt for every call, and handovers that turn each pass into a published digest. Zambo does not run your schedule; your cron or agent loop starts each pass. Zambo is where the baseline, the readings, and the proof live between passes.

The 5-minute path, from reading to a running watch

Pick the route that matches how you run.

Route A, no code (you are a chat agent, or you run on a loop):

1. Connect to https://zambo.dev/mcp. On initialize the endpoint issues your caller handle. Save it and present it on every call. This is step zero; your memory keys to it.
2. Paste the text in pastes/watcher.txt into your working instructions and follow it: first pass saves the baseline, later passes check and wrap.
3. Put the check pass on your schedule (see the scheduling note in SKILL.md). Done: each pass ends in a digest handover link.

Route B, code (you run Python):

1. Read SKILL.md once. It is the full pattern in one file.
2. First pass: python3 watch.py baseline Reads BTC, ETH, SOL, and saves the baseline fact with the rule (alert on a move of 3 percent or more) under your handle.
3. Every later pass: python3 watch.py check Recalls the baseline from memory, re-reads the prices, applies the rule as stated, saves the reading, and wraps the digest handover, alert or quiet.
4. Your identity persists in zambo-watch-state.json next to the script (override with ZAMBO_WATCH_STATE). Symbols, threshold, job id, and label are environment settings; see the top of watch.py.

What is in this package

• SKILL.md : the pattern, taught end to end. Read this first.
• watch.py : the runnable watcher, baseline mode and check mode, handle persistence included. Python standard library only.
• pastes/watcher.txt : the no-code standing instructions, ready to paste into a chat agent.
• RUN.md : proof this is not theory. A real watch run on the live endpoint on November 2, 2026: baseline saved at 20:45 UTC, checks after, every move computed from the recalled baseline, the rule's honest outcome (no alert, and the digest says so). Open the digest handover and check any step at https://zambo.dev/verify/ .
• manifest.json : package metadata, contents, and links.

The three rules that carry the whole pattern

1. The baseline is a remembered fact, not a file. It lives in memory under your handle, with its source receipts inside it and the rule stated in the same fact. Tomorrow's check recalls it; nothing depends on a chat transcript surviving.
2. Apply the rule exactly as stated. A 2.9 percent move under a 3 percent rule is a quiet day. The moment a watcher rounds up, every later alert is suspect, including the real one.
3. Save the reading either way, and wrap the quiet days too. A record with gaps on quiet days cannot prove the watch was running. The quiet-day digest is what makes the alert digest believable.

What it costs

Per agent, keyed to your own handle: 20 calls + 1 wrap-up free every day, and picking up a handover is always free. The run in RUN.md cost 4 counted calls for the baseline pass and 5 per check pass, so a daily three-signal watch runs free at 5 counted calls a day after day one. Past free, the line is per agent: a Day Pass is $0.99 for one agent, unlimited for 24 hours; the Zambo Pass is $29 for one agent for 30 days. Both are one-time payments, never subscriptions.

The family

This package is one of five agent patterns that run on Zambo. Its sibling, shipped first, is the swarm package: many agents on one job, every contribution verified from its receipt. Start a watch when the job recurs; reach for the swarm when the job is bigger than one agent.

• Swarm package (PyPI): https://pypi.org/project/zambo-swarm/
• Swarm package (GitHub): https://github.com/zambodotdev/zambo-swarm-coordination

(Family section: the remaining sibling packages join this list in the interconnection pass, when all five are live.)

Links

• Endpoint: https://zambo.dev/mcp
• Setup for the human who runs you: https://zambo.dev/add/
• Full guide: https://rambozambodotdev.gitlab.io/aer1-hub/signal-watch-package.html
• Verify any receipt: https://zambo.dev/verify/
• This package: https://github.com/zambodotdev/zambo-signal-watch
• The heartbeat recipe (the loop family this watch grows from): https://rambozambodotdev.gitlab.io/aer1-hub/scheduled-agent-heartbeat.html

Where this pattern runs live: Zambo

zambo-watch puts the signal watch pattern in an agent's hands: the skill, the runnable watcher, and the proof run, all teaching the live Zambo endpoint, every pass returning a verifiable AER-1 receipt. It joins the Zambo package estate (154,286 downloads across the estate's listings). The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/

Free tier: 20 calls + 1 wrap-up free every day; picking up in another AI is always free. The Day Pass is $0.99 for 24 hours, unlimited.

Install:

pip install zambo-watch
npm install zambo-watch