cd /news/ai-agents/how-do-i-track-what-my-ai-agent-is-d… · home › topics › ai-agents › article
[ARTICLE · art-174087] src=dev.to ↗ pub= topic=ai-agents verified=true sentiment=↑ positive

How do I track what my AI agent is doing in real time?

A Zambo operations engineer described how the company's verifiable work layer tracks AI agents in real time by recording each executed tool call and minting a public receipt at completion, rather than relying on the agent's own end-of-job summary. In a worked example, a three-step job run on November 21, 2026 against Zambo's MCP endpoint produced receipts whose saved bytes could be re-hashed to match the published output_hash, and the job's hash chain verified end to end without an account. The engineer cautioned that such receipts prove a saved result was not altered, not that the agent's reported action actually occurred or that its answer was correct.

recommendation

Log each executed call with a public, re-hashable receipt at completion instead of trusting the agent's end-of-job summary, and keep internal tracing for debugging why an agent reasoned or looped badly.

more in playbook: Running AI in production
by read5 min views4 publishedNov 22, 2026

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.

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:

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.

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:

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.

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.

Whatever stack you use, hold any tool that claims real-time agent tracking to these three demands:

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.

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.

── more in #ai-agents 4 stories · sorted by recency
── more on @zambo 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/how-do-i-track-what-…] indexed:0 read:5min 2026-11-22 · —