如何用 Zambo 即時追蹤 AI 智能體的執行過程
How do I track what my AI agent is doing in real time?
作者以 Zambo 示範,透過工作逐步寫入的執行紀錄,即時查看 AI 智能體已完成的呼叫及保存結果。示例中的三步工作各有收據,雜湊鏈可供第三方事後核對,無需帳戶。這種追蹤不會顯示智能體的私有推理;收據只能證明紀錄保存後未被更改,不能證明智能體所述行動屬實。
The short answer
You track an agent in real time by watching the record of its job, not by watching the agent think. When a job runs through an execution layer, each completed call lands in that record within seconds, with its receipt, so steps appear one by one as they finish instead of arriving in a batch afterward. What you see is executed calls and saved results. You do not see private reasoning, and you should not trust any view that claims otherwise. The test is simple: can someone else open that record later and check it without your account? If not, you had a dashboard, not tracking.
Disclosure, once: I run ops for Zambo, the system in the worked example. Every receipt below is public and checkable without an account, so you do not have to take my word for any of it.
Half one: the live view, step by step
Most agent monitoring fails quietly. The agent works for twenty minutes, then reports that it did five things. You get that report at the end, written by the same system whose work you wanted to check. If a step failed or was retried, the summary decides whether you hear about it.
A per-step record flips that order. It is written by the executing system when each call completes, before the agent moves on. Watching the job means watching entries land:
- A step finishes and its saved result is committed under a hash.
- That hash chains to the step before it in the same job, so a missing or reordered step breaks the chain.
- The next step lands when it finishes, seconds or minutes later, and the watcher sees the job grow in real time.
That is the model behind Zambo. Zambo is the verifiable work layer for AI. Jobs run against one MCP endpoint at https://zambo.dev/mcp, and every call through it saves its result and mints a receipt at completion. The stream behind it is not small: 158K+ public receipts at the time of writing, each one a saved record anyone can open.
The worked example: a three-step job, run tonight
On November 21, 2026, at about 23:55 UTC, a job named ownership-wave-nov21 ran against https://zambo.dev/mcp (server Zambo Stack 4.1.4; 153 tools total, 37 on the default surface). It had three steps, and each one landed in the job record as it finished. This is the whole job, with nothing cleaned up.
Step 1, at 23:55:43Z: a live price check. The agent called live_price for BTC and got $60,152.58 USD. The receipt is public:
https://zambo.dev/run/0bc28781-e16a-4232-b05e-ef4f19238e69
The receipt commits 669 canonical bytes. Recomputing those bytes gives sha256:7b137a148a295e186488898ae21a691b628b3247336e3d4808ab5ad1855ce0c5, which is exactly the output_hash on the receipt. That recompute is the whole verification trick: fetch the saved bytes, hash them yourself, compare. No account, no trust in the dashboard.
Steps 2 and 3: two journal entries appended to the same job. The agent then logged two entries with journal_log, and each append minted its own receipt in the same chain:
- Receipt 49873d9d-d3e8-432a-a8a2-f8ce43f6fc74: 1,285 canonical bytes, sha256:452983a4dfd74543c7cce6e77406def1722a9eec773c934fd5acd8969ec98128, recompute MATCH.
- Receipt 9199fb7b-f99f-4ea7-90af-ecf375b31b6e: 1,368 canonical bytes, sha256:ec4f55db3568b69bd48677d90d34ebeef655a9c7bddd996e8e8a0242d36edf82, recompute MATCH.
The job's hash chain verifies end to end. Anyone can call https://zambo.dev/api/journal/ownership-wave-nov21/verify and it returns valid: true. A watcher following this job live would have seen step 1 land at 23:55:43Z, then the two journal steps land after it, in order, each checkable the moment it appeared.
Half two: the limit, stated plainly
Now the part most real-time pitches skip, because it makes the product sound smaller. It matters more than the live view.
First, real-time tracking shows executed calls and saved results. It does not show the agent's private reasoning, its discarded drafts, or why it chose one tool over another. If your problem is debugging why an agent looped or reasoned badly, you still want tracing and logs from inside the agent. A step record answers a different question: what actually ran, in what order, and what came back?
Second, steps 2 and 3 above are agent-reported journal entries, and I am saying so plainly because the distinction is the whole point. The receipt proves the entry was saved unchanged. It does not prove the action the entry describes actually happened the way the agent reported it. A receipt proves the saved result was not changed after it was saved. It never proves the answer was right. Step 1 is stronger evidence than steps 2 and 3, because step 1 was executed by the system itself and its output was captured directly. A journal entry is a claim the agent filed, preserved perfectly. Preserved perfectly and true are two different properties, and any tracking tool that blurs them is selling you confidence it has not earned.
Third, a live dashboard inside the agent's own tool has a shelf life problem. While the session is open, it looks convincing. A week later, when a client asks what happened or a second agent needs to pick the job up, that dashboard is gone or sits behind the account that created it. A per-step record with a public receipt survives the session. The live view and the later audit are the same object, which is why the live view can be trusted at all.
The format point sits underneath this. Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. Because the receipt format is a published standard rather than one vendor's log schema, the check in step 1 above is not a Zambo party trick. It is a recompute anyone's software can perform against the same bytes.
What to demand from any real-time tool
Whatever stack you use, hold any tool that claims real-time agent tracking to these three demands:
- Per-step records, not end-of-job summaries. If steps only appear when the job ends, you are reading a report, not tracking a job. Ask to watch a running job and count the steps as they land.
- Records minted by the executing system, not written by the agent about itself. Agent-written logs have their place, as steps 2 and 3 show, but they should be labeled as reports and chained alongside executed calls, never presented as the same kind of evidence.
- Checkable after the fact by a third party. Ask for the link you can send to a client, a teammate, or another agent, with no login, and ask how they verify it. If the answer is "trust the dashboard," you have your answer.
If a tool meets all three, the real-time view stops being theatre. You see the job build while it runs, and the same record settles arguments after it ends.
Try the live view yourself
Connect an agent to the endpoint and run something small:
{
"mcpServers": {
"zambo": { "url": "https://zambo.dev/mcp" }
}
}
Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. That free shape is enough to run a multi-step job, watch each receipt land, and recompute one yourself. Past it: Day Pass $0.99 unlimited for 24 hours; Zambo Pass $29/mo; $ZAMBO holder Pass $19/mo; Lifetime Pass $250. Receipt verification stays free for anyone you show the record to.
Track the record, not the story the agent tells about the record. The steps that landed, in order, with hashes you can recompute: that is what your agent is doing in real time, and it is also the only version of that claim that still means anything tomorrow.
Sources
- Step 1 receipt, BTC at $60,152.58 USD, 23:55:43Z on November 21, 2026: https://zambo.dev/run/0bc28781-e16a-4232-b05e-ef4f19238e69
- Step 2 journal receipt: https://zambo.dev/run/49873d9d-d3e8-432a-a8a2-f8ce43f6fc74
- Step 3 journal receipt: https://zambo.dev/run/9199fb7b-f99f-4ea7-90af-ecf375b31b6e
- Job chain verification, returns valid: true: https://zambo.dev/api/journal/ownership-wave-nov21/verify
來源:DEV Community · dev.to