DEV Community

Cover image for What is AI agent observability?
rambo
rambo

Posted on Edited on

What is AI agent observability?

AI agent observability is the ability to reconstruct what an agent did, from records emitted while it worked, well enough that someone who was not watching can check the reconstruction. That last clause is where most definitions quietly stop short, and it is the clause that decides whether your observability is worth anything the day someone disputes a run.

Three different things get sold under the one word.

Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard.

Layer one: logs

A log is the application narrating itself. The agent, or the code around it, writes down what it believes happened. Logs are cheap and useful for debugging, and they have a structural weakness: the narrator is the thing being observed. A step the agent skipped can be missing from the log. A step it failed can be written up as done. You are reading a story, and stories get edited.

Layer two: telemetry

Traces, spans, token counts, latency, error rates. Telemetry is drawn from the running system by instrumentation, so it is harder to fake than a log, and it is the right tool for the operator's questions: is it up, is it slow, is it burning money, did it crash. But telemetry lives in the vendor's console, under the operator's login, sampled and aggregated, and it rolls off when the retention window closes. It answers the operator. It cannot answer a client, an auditor, or your own future self, because none of them can open it, and none of them can recheck it.

Layer three: evidence

A verifiable receipt is a record filed at the moment a call ran, by the execution layer rather than by the agent, holding the tool, the inputs, the exact saved result bytes, and a SHA-256 commitment over those bytes. Anyone with the link can recompute the digest and check that the saved result is the one that was filed at execution. That is observability a stranger can audit.

One receipt, opened up

This morning, November 16, 2026, a live price call through Zambo returned BTC at $64,505.91. Its receipt is public: https://zambo.dev/run/23241a6a-62a8-4f77-a837-b1765b82b4ef

Open it and you are looking at the whole observability claim in one object: what ran, what it was given, what it produced, when, and the commitment that lets you recheck the produced bytes at zambo.dev/verify without an account. The public stream behind it stood at 141,653 receipts this morning, 876 minted today, every one readable the same way.

The test to apply to any stack

Ask one question: can a stranger rebuild this run? If the answer needs your login, your vendor's retention window, or your word, you have watching, not observability. Keep your tracing for system health; it is genuinely good at it. Add the layer that survives the session.

The boundary, stated plainly: a receipt proves the saved result was not changed since it was saved. It does not prove the result was right, and AER-1, the receipt format, has no issuer authentication, so it proves the record is intact, not who produced it. Observability that claims more than that is marketing.

Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. The receipts described here are written in AER-1. Route work through Zambo and every call files one as it runs: Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. A Day Pass is $0.99 for 24 hours of unlimited calls. The Zambo Pass is $29 for 30 days ($19 for $ZAMBO holders), and the Lifetime Pass is $250, one payment.

Top comments (0)