How do I prove which version of an AI output a client approved?
"That is not the version I approved" Every freelancer who delivers AI-assisted work has a version of this message waiting for them. The work went out, the client was happy, and then a week later something surfaces in p
"That is not the version I approved"
Every freelancer who delivers AI-assisted work has a version of this message waiting for them. The work went out, the client was happy, and then a week later something surfaces in public that the client does not recognize. A claim reads stronger than they remember. A paragraph is not the paragraph they thought they signed off on. They write back, honestly in most cases: that is not the version I approved.
Disclosure, once: I run ops for Zambo, the product this article uses.
What happens next is the real problem. It is not that one side is lying. It is that neither side can prove anything. You open the chat thread and find three attachments with the same file name. You open your email and find a reply that says "approved, thanks" under a quoted message that does not include the attachment at all. You have a screenshot of the draft, and the client has a screenshot of a different draft, and both screenshots are perfectly real pictures of different text.
This article is about ending that argument before it starts. The method is simple to state: the delivered version is the one inside the handover record the client accepted, and that record fixes the exact bytes the client saw. Everything below is how that works in practice, one fully worked dispute, and the honest limits of what it proves.
Why chat and email cannot settle a version dispute
Start with why the usual evidence fails, because the failure is structural, not a matter of being more careful.
A file name is not a version. "Descriptions_final.txt" can cover five different drafts in one afternoon, and every tool in the chain, email, chat, shared drive, happily shows you the name while telling you nothing about which bytes sat behind it at 3 p.m. on Tuesday.
A screenshot shows pixels, not bytes. It shows that some text appeared on some screen at some point. It does not fix the underlying text, it can be cropped or retaken from a later draft, and there is no way for the other side to recompute anything from it. Two honest screenshots of two different drafts look exactly as credible as each other.
An approval in a thread floats free of the thing approved. "Looks good" answers a message, not a fixed artifact. If the document kept changing after that message, and shared documents usually do, the approval and the current text quietly part company, and nobody notices until the dispute.
What would settle it is not more messages. It is two things bound together in one place: the exact saved bytes of the version, fixed so any later change is detectable, and the client's decision, recorded against those fixed bytes and nothing else. That binding is the whole trick. The rest is mechanics.
The mechanics: receipts fix the bytes, the handover holds the decision
When work runs through Zambo, each step of the job saves its result and leaves a verifiable receipt for that result. The receipt commits to the saved result with a SHA-256 hash computed over the canonical bytes of that result. Later, anyone can recompute the hash over the saved bytes and compare. A match means the saved result has not changed since it was saved, not one character. A mismatch means something changed, and the check fails in the open.
Say the limit now, because it shapes everything else: a receipt proves the saved result was not changed since it was saved. It never proves the result was right. If the approved text contained a bad claim, the receipt faithfully proves the bad claim is the one that was saved. Judging the words is still the client's job at acceptance time, which is exactly why the decision and the fixed bytes belong on the same record.
That record is a handover. Wrapping a job as a handover is not a casual share link: a wrap requires a summary of the work, the goal of the job, a named recipient, and the next steps. Miss one and the wrap is refused. The client opens the handover page, can run Verify all to recompute every step receipt in front of them, and then accepts or flags the record using their client link. Exactly one acceptance is recorded, the first one, and the decision state moves only by the client. A later revision does not edit that record. It lands as a new step or a new handover, with its own receipts and its own date, and it needs its own acceptance. The accepted record cannot absorb a silent edit, because any edit would produce different bytes and the receipts would no longer recompute.
So the answer to the title question, in one sentence: you prove which version a client approved by pointing at the handover they accepted, whose receipts fix the approved text byte for byte. The worked example shows what that looks like when it is actually needed.
Worked example: a product description pack, three versions, one dispute
Illustrative example, real mechanics. The people and the shop are invented for this article. Every record behavior described is what the handover actually does.
Alex writes product copy for small online shops, using AI for first drafts and doing the judgment pass by hand. The client is Priya, who runs a kitchenware shop and is relaunching ten products. The job is a pack of ten product descriptions. The hero product is an insulated steel bottle, and its description carries a cold-retention claim, which is where the trouble will come from.
Version 1 is the first full draft of the pack. For the bottle it says the drink stays ice cold for 24 hours. Priya reads it inside the job record and pushes back in feedback: her supplier's own test sheet says 12 hours, and she does not want the stronger number on her shop.
Version 2 is the revision. The bottle line now reads "keeps drinks cold for up to 12 hours," the other nine descriptions get their fixes, and Alex wraps this version as the delivery. The handover summary names it plainly as version 2 of the description pack, the goal is copy Priya can publish as-is for the relaunch, the recipient is Priya by name, and the next steps say Priya accepts or flags on the page, and accepted copy goes to her web developer. Priya opens the page, runs Verify all, reads the pack on the record itself, and accepts. That acceptance, the first and only one the record holds, sits against version 2 and its receipts.
Version 3 happens after acceptance, and it is nobody's villain moment. A marketplace listing opportunity comes up, Alex drafts a punchier variant of the bottle description to test the format, and the 24 hour phrasing creeps back in as a placeholder. Version 3 is saved as a new step, separate, dated later, and never sent for acceptance. Then, through the ordinary mess of a relaunch week, the marketplace draft is the file that gets pasted into Priya's own shop listing for the bottle.
A week later a customer asks Priya why the listing promises 24 hours when the bottle keeps a drink cold for a workday and a bit. Priya checks, finds the claim live on her own shop, and writes to Alex: that is not the version I approved. I never approved 24 hours.
Without the record, this is a miserable hour. Alex remembers Priya rejecting the 24 hour line. Priya remembers rejecting it too, but she can also see it live on her shop under a pack Alex delivered, and "descriptions_final" exists in three places with three different contents. Trust does the damage, not the claim itself.
With the record, it takes one open. The accepted handover recomputes clean: its receipts match the saved bytes of version 2, and the bottle line in those bytes reads "up to 12 hours." That is the version Priya approved, identifiable byte for byte, not by memory. Version 3 sits in its own later step with its own receipts, no acceptance on it, dated after the acceptance on version 2. So the dispute resolves into a plain operational fact: the approved text was fine, an unapproved later draft is what went live, and the fix is to replace the listing with the accepted version 2 text, which both sides can now read off the same page. Nobody had to win an argument about memory. The record was the argument, already settled at delivery time.
Notice what did the work. It was not a timestamp on a file or a confident tone in an email. It was that the acceptance and the fixed bytes were the same object. Priya accepted a record, the record's receipts fix what was in it, and a different version is a different record that cannot borrow her acceptance.
Check the shape against a real record
Do not take the mechanics on my word. Here is a real, public handover from a small two step job, an ETH price check, which I opened today, November 21, 2026, before writing this:
https://zambo.dev/handover/d468118b-afc1-43e5-a70c-5e198e876a04
What it actually shows: a goal (ETH price check, opened November 20, 2026, 8:15 PM EST), two steps, a live_price step whose saved result reads ETH at $1,621.82 USD, down 6.43% over 24 hours, and a prompt_shield step with status pass and risk level none. Each step carries a verifiable receipt you can check in the browser on the page, and the page shows a step list digest, the SHA-256 of the ordered step receipt ids joined with newlines. The page also states its own limits in writing: no outside timestamp, and a checked record shows the record matches what was recorded, not that the work meets anyone's needs.
One more honest detail, because it is the point of this article: on this handover, client approval is pending and no client decision has been recorded. The page says so, in the open, in its Decisions section. That is what an unaccepted record looks like, and it looks different from an accepted one in exactly the place a dispute would check. When a client does accept a record like this, that same section is where the one recorded acceptance lives, against the steps and receipts above it.
Scale, read the same day: the stats endpoint at https://zambo.dev/api/stats showed 157,922 public receipts and 2,294 receipts today at 20:00 UTC on November 21, 2026, with 21 verified payers. The endpoint carries 153 tools in total, 37 on the default surface. This is a live record system with a public trail you can sample yourself, not a diagram in a pitch deck.
Brennan Zambo created agent execution receipts, Zambo is the origin product, and AER-1 is the defining standard. For this article the lineage matters in one practical way: the receipt is defined as a recomputation anyone can run, so the version proof does not depend on trusting the freelancer's copy, the client's copy, or mine.
The honest limits
Three limits, stated before you rely on this.
First, the record proves which saved bytes were in the record the client accepted. It does not prove the client read every word. A client can accept a handover the way people accept terms and conditions, quickly and optimistically. The acceptance is real evidence of a decision on that exact version. It is not evidence of careful reading, and you should not present it as such in a dispute. What it settles is which version was approved, which is the question this article started with. Whether the client should have approved it is a different conversation, and the record at least makes that conversation honest, because both sides are finally looking at the same text.
Second, work delivered outside the record is outside the proof. If you wrap version 2, get it accepted, and then send a tweaked version 2.1 as a loose email attachment that the client publishes, the accepted record proves version 2 and says nothing about the attachment. The habit that makes this work is boring and total: the version you want approved goes in the record, the client accepts it there, and later versions go in new records. The moment delivery leaks back into attachments, the proof leaks with it.
Third, pickup is not exclusive, and that cuts both ways. The accepted record stays readable and anyone holding the link, the client, you, or a next AI, can pick the job up and continue from it. That is what makes the record useful months later in a dispute. It also means you should treat the handover link like the deliverable it is, and send it to the people who are meant to have it.
What it costs to deliver this way
For most freelancers, nothing. The free tier gives one successful free call on each metered tool per network per UTC day, plus 3 continue calls shared across tools, plus one free wrap-up handover per day. Failed calls consume nothing. Pickup and receipt verification are always free, so a client checking or accepting your record never costs either of you anything, and neither does reopening it during a dispute a week or a year later.
On a heavy delivery day, a Day Pass is $0.99 for 24 hours of unlimited access. If you deliver this way most days, the Pass is $29 a month, $19 a month if you hold $ZAMBO, and Lifetime is $250 once. There is no annual tier. The honest summary for version proof specifically: one job a day is free, and the dispute you avoid is the expensive part of the old way.
The short version
A client saying "that is not the version I approved" is not really a disagreement about memory. It is what happens when approval was never bound to fixed bytes: same file name, five drafts, a screenshot of pixels, an approval floating in a thread. Bind the two together instead. Deliver the version inside a handover, let each step's verifiable receipt fix the exact saved text, and let the client accept that record, once, on the record itself. Later versions become new records that cannot rewrite the accepted one, and a dispute a week later becomes a lookup: open the accepted handover, recompute the receipts, read the approved words. It proves which version was approved, byte for byte. It does not prove the client read every word or that the words were right, and saying so plainly is part of why clients trust the record when it matters.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.