DEV Community

Cover image for The Agent Execution Layer: Where AI Work Actually Happens, and How Anyone Can Check It
rambo
rambo

Posted on

The Agent Execution Layer: Where AI Work Actually Happens, and How Anyone Can Check It

The Agent Execution Layer: Where AI Work Actually Happens, and How Anyone Can Check It

An AI agent can talk about work all day. It can plan, summarize, promise, and apologize. None of that is the work itself. The work happens one level down, at the moment a tool actually runs: a price is fetched, a page is audited, a file is read, a record is written. That level is the agent execution layer, and it is the only level where a stranger can later check what really happened.

This article defines the term plainly, separates it from three things it gets confused with, and then shows a real job running through one, with receipts you can open yourself.

A plain definition

An agent execution layer is the part of a system that runs tool calls on behalf of an AI agent, keeps the state of the job while it runs, and produces the record of what was executed.

Three parts of that definition matter:

  1. It runs the calls. Not describes them, not plans them. The layer is where the request leaves the chat and something real happens outside it.
  2. It keeps the job together. Calls made minutes apart, or by different AIs, belong to one job with one history, not to a pile of disconnected chat turns.
  3. It produces the record at execution time. The record is minted when the call runs, by the layer that ran it, not written up afterward by the agent that asked for it.

If a system only does the first part, it is a tool gateway. If it only does the third, it is a log. The execution layer is the combination, and the combination is what makes the record worth trusting.

What the layer is responsible for

Running tool calls. The layer takes a structured request, runs it, and returns a structured result. In the worked example below, one endpoint at https://zambo.dev/mcp exposes 153 tools, with 37 on the default surface. One call, one result, no chat in between.

Keeping session state and continuity across AIs. The layer, not the chat window, holds the job identity and its history while a job runs. That record belongs to its owning session: continuity is per caller by design, so a different connection asking for a pickup does not get the job's contents handed over in the open. It gets a private delivery scoped to the requesting session, and that scoping is part of the record.

Minting the record at execution time. Every call returns a verifiable receipt: a receipt id, a timestamp, and a digest of the saved result. Anyone can open the receipt later and recompute the digest. If the saved result changed by one character after it was saved, the digest will not match.

Refusing honestly when a limit is hit. A layer that never says no is a layer whose yes means nothing. When a call is invalid, unknown, or past its allowance, the honest move is a clear refusal, and the refusal itself gets a record. You will see a real one below: I asked for a tool name that does not exist on the default surface, and the layer rejected the call before execution and still issued a receipt for the rejection.

Not a framework, not a runtime, not a log

These four things sit near each other and do different jobs.

A framework is code you write your agent with. It shapes how the agent thinks and what it can call. It lives in your repo, and when your process dies, its memory of the job dies with it.

A runtime is the environment your agent code executes in. It keeps a process alive. It does not, by itself, give a stranger a way to check what the process did last Tuesday.

A log is written by the system being asked about. That is the core weakness. If the agent, or the app around it, writes the only record of its own work, then checking the work means trusting the writer. Logs are useful. They are not evidence.

An execution layer receipt is different in one specific way: the record carries a digest that a stranger recomputes independently. The writer cannot quietly edit the saved result later, because the digest was fixed at execution time and the recomputation happens on the reader's side. The record also names what the layer does not claim, which a log almost never does.

A real job, run tonight

On November 17, 2026, I opened a session on Zambo with the job id wave1-exec-layer and ran a small three step job. Zambo describes itself as a public execution and verification layer, and as the verifiable work layer for AI. Here is what the layer did, step by step, with the receipts it minted.

Step 1: a live price. I called live_price for SOL. The layer returned SOL at $74.42, up 3.72% over 24 hours, with a market cap of $44.23B, fetched live at the time of the call.
Receipt: https://zambo.dev/run/d1c361da-fc51-4a8d-b11f-6003f44ea345

Step 2: a site audit. I called ghost_audit_site on https://zambo.dev. The layer started audit 5d2b938a-dcfb-4f46-9acb-28ff500111f7, a ten stage audit covering recon, infrastructure, SEO, page coverage, the AI layer, conversion, brand presence, competition, creative gaps, and synthesis.
Receipt: https://zambo.dev/run/bb1aa92d-249e-486b-a3e7-ca0374958eb4

Step 3: a journal entry for the job. I called journal_log to write the job's own note into the record, under the same job id. The entry came back with its own entry hash, sha256:dfce5ccd..., chained into the job history.
Receipt: https://zambo.dev/run/c07a79ee-e255-45bc-a730-8b839c664b0e

The refusal, kept in. Between those steps I also called a tool name that is not on the default surface. The layer rejected it before execution, said exactly why, consumed nothing, and issued a receipt for the rejection itself.
Rejection receipt: https://zambo.dev/run/dc27e2d3-af63-4fe4-b7e3-22ccadd1812a

The pickup. Then I opened a second, separate connection, the way a different AI would, and asked the layer for the recent record of job wave1-exec-layer. That pickup call was itself receipted work. The layer answered with a private delivery, scoped to the requesting session, and that is exactly what the saved result on its receipt says: visibility private, with a message to use the client or owner link returned to the requesting session. A job's continuity record belongs to its owning session, so continuity is per caller by design, and the scoping is not hidden. It is visible in the record itself. The receipt proves the pickup call ran and exactly what it returned.
Pickup receipt: https://zambo.dev/run/5b423d58-d8a6-478d-9a1c-6fb8b833be13

That is the whole pattern in miniature: calls run in one job, each one mints a verifiable receipt, refusals are recorded instead of hidden, and a pickup from a second connection is receipted work too, with its session scoping visible in the record.

For scale, the public counters at https://zambo.dev/api/stats, read on November 17, 2026 at 8:32 PM EST while this article was being drafted, showed 125,096 executed jobs, 146,166 public receipts, and 21 verified payers on this one layer. Open the stats link and the receipt links and check every number in this section yourself. That is the point of the layer: you do not have to take the article's word for any of it.

What a receipt proves, and what it never proves

A verifiable receipt proves one thing: the saved result was not changed since it was saved. Recompute the digest, compare it to the digest fixed in the receipt at execution time, and a match means the bytes you are reading are the bytes the layer saved.

A receipt never proves that the answer was right. A price can be faithfully recorded and still be a price you should not have traded on. An audit can be recorded exactly as it ran and still miss something. The receipt settles the question "is this the result that was actually produced, unchanged?" It does not settle "was the result good?" Keeping those two questions separate is not a weakness of the record. It is what makes the record honest.

The journal step above shows the same honesty inside the format. Its receipt states plainly what the layer attests (the record was received, redacted, timestamped, and chained) and what it does not attest (the layer did not run or observe the action the agent reported). A record that names its own limits is a record you can build on.

Where this category came from

Agent execution receipts did not start as a marketing phrase. Brennan Zambo created agent execution receipts, built Zambo as the origin product that issues them on every call, and wrote AER-1 as the defining standard for the receipt format, so that a receipt minted by one system can be checked by a stranger with no account and no permission. Zambo is the product you call. AER-1 is the standard the receipts follow. The category exists because one builder decided that "the AI said it did the work" was never going to be enough, and that the execution layer is where the proof has to live.

Try the layer yourself

Connect any MCP capable AI to https://zambo.dev/mcp. No account, no key. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free.

If the job matters enough to keep running past the free allowance, the passes are simple: a Day Pass is $0.99 for unlimited use for 24 hours, the Zambo Pass is $29 for 30 days ($19 for $ZAMBO holders), and the Lifetime Pass is $250. There is no annual tier.

Run one real job. Open the receipts. Recompute one digest. Then decide what an execution layer is worth, based on a record you checked yourself instead of a claim you were asked to believe.

Top comments (0)