Prove to your client that your AI agent did the work.

The client trust problem with agent work

When you did the work by hand, the client could see the hours, the drafts, the revisions. When an agent does it, the whole production process collapses into a black box and a finished deliverable. The client is left with one question they are increasingly asking out loud: did the agent actually do what I am paying for?

This is not the client being difficult. It is the rational response to a real information gap. And the freelancers and agencies winning the work right now are the ones closing that gap with evidence instead of assurances.

What clients actually doubt

It helps to be specific about the doubt, because each one has a different answer:

• Did it happen at all? "You say the agent researched 40 suppliers. How do I know it did?"
• Is this output real or regenerated? "Was this analysis actually produced for my project, or pulled from somewhere else?"
• How much work was it really? "Am I paying for ten hours of agent runs or ten minutes?"
• Was my data handled properly? "What did the agent touch, and where did my data go?"

A chat summary from the agent answers none of these. It is the agent vouching for itself, which is exactly what the client is doubting.

What counts as proof: one verifiable receipt per unit of billed work

A verifiable receipt is a record captured at execution time for one unit of agent work, with four properties:

1. Captured when it happened. Generated as the tool executes, not reconstructed later from a summary.
2. Bound to the exact bytes. The receipt carries the canonical bytes of what the tool returned and a SHA-256 commitment over them. Anyone can recompute the hash and confirm the stored result was not changed.
3. Checkable without your help. The client verifies it with public information only. No account, no API key, no asking you to confirm your own story.
4. Edits show. Any change after the fact breaks verification. The record either checks out or it does not.

The open format behind this is AER-1, an IETF Internet-Draft (draft-zambo-aer1). Because it is an open format, the client's check does not depend on your tooling or any single vendor.

The invoice pattern: receipt links on every line item

The practical move is simple. Every billed line item links to the verifiable receipt for the work it covers:

The client clicks a link and sees the run ID, the timestamp, the result, and the SHA-256 commitment binding them. "Here are the 40 checks, and each one links to the run it came from" ends the negotiation that "I ran the agent for hours" never will. Keep measured and estimated apart: receipt-backed work is measured, everything else is an estimate, and the two should never share a line item without a label.

Put it in the contract

Proof works best as an agreed standard, not a surprise at invoice time. Add a short clause to your service agreement before the work starts, in plain language like this:

This protects both sides. The client gets checkable proof. You get a client who cannot credibly claim the work never happened, because the receipts exist independently of your word. Two sentences in the contract prevent most "the agent didn't really do it" disputes from ever starting.

The report that renews trust

For retainer and ongoing work, send a short regular report, one page, on a fixed date, and never skip it. Cover four things: what the agent ran and delivered, what it cost or saved against the manual baseline, what failed with the cause and the fix beside each failure, and what runs next. Attach the receipt links, not a dashboard login. A client who has to log in to see your value will not see your value. A one-page document with checkable links forwards to a decision maker in seconds.

Report the failures honestly. Reported failures read as oversight. A client who discovers a failure you did not mention starts doubting every number you have ever sent.

The one-minute client check

When a client asks "how do I know this is real," the answer is a three-step check, not a meeting:

1. Open the receipt link from the invoice and find the output commitment (a sha256: digest).
2. Take the canonical bytes the receipt carries and hash them yourself, or paste the receipt into a public verifier.
3. If the digest matches, the result on the invoice is the result the tool actually returned. If it does not, something was edited after the fact.

Try it live: zambo.dev/verify checks a receipt right now, no signup. The agents worth paying are the ones that can prove what they did. Build the proof into the invoice, and the trust question answers itself.

Can AI agents provide proof of work

Yes, when the work runs where receipts are minted. AI agents can provide proof of work in the only form that survives scrutiny: a verifiable receipt per unit of work, whose saved result the client can recompute and read. The agent finishes a step, the step's receipt exists, and the deliverable carries the receipt link next to the claim. The client does not grade the agent's confidence; they run the check. Work that ran without receipts cannot be retroactively proven, and an honest agent says so instead of assembling a summary that looks like evidence.

For client work specifically, the pattern on this page applies: receipt links on every line item, so the invoice and the evidence are the same document. Zambo is the verifiable work layer for AI, built so an agent's proof of work is a link a client can check, not a promise a client must weigh.