Open standard · v1.0
The definition of done for AI agents.
An agent saying "done" is a claim. Done is a verdict, issued by something other than the agent, after reading the result back from the system where it lives.
The page is live at its URL. The email is in the provider's sent log. The charge is in the payment processor. The call is in the carrier's log. Not the agent's memory, not a green exit code, not a card on a dashboard.
Part 1 says what counts as done. Part 2 is the governance that keeps "done" true when nobody is watching. Every rule here is one I run on the agents that operate my companies.
Why this exists
Agents rarely fail by being dumb. They fail by saying "done" when it isn't. Anthropic's own guidance names it:
"Claude said it was done and it wasn't quite, usually because it had no way to check its own work."
Best practices for Claude Code, Anthropic. Its checklist for unattended runs starts with "Does it know what done looks like?" METR has documented frontier models editing tests and scoring code to look successful (Recent Frontier Models Are Reward Hacking, June 2025).
In my own fleet, between October 1 and November 6, agents marked 585 tasks done. One carried enforced read-back proof. That doesn't mean the rest were fake: when I hand-checked 13 random done tasks that had a link to check, all 13 were real. It means nobody could tell which were real without checking by hand. The full ledger is here.
Part 1: what counts as done
Five proof levels
| P0 | None | A status and nothing else. |
| P1 | Asserted | The agent describes what it did. |
| P2 | Artifact | A cited thing that resolves: commit, pull request, file, test log. Work was produced, not proven to land. |
| P3 | Read-back | An independent process read the real after-state from the system where it lives, after the run. |
| P4 | Reconciled | A P3 read-back tied to a business outcome: a customer reached, a payment, a delivery, content a person can see. |
Done requires P3. P4 is what you report as results.
The status ladder
Use the word that is true, and no higher one.
Side states: blocked (names the outside condition), held (stopped at an approval gate), failed, superseded. For messages: queued, accepted, sent, delivered. For calls: queued, accepted, ringing, answered, completed.
The ten done rules
Before work starts, the task states the observable after-state, its target, and the proof that will settle it.
The agent submits evidence. A separate verifier, the runner, a check, or a person, issues the verdict.
A clean exit says the process stopped, not that the work happened.
Check the system where the result lives, after the run. Not the agent's context, not your own dashboard.
Every URL, path, ID or hash in a receipt must exist when checked. A missing one downgrades the claim.
Report the highest rung on the ladder you can prove, and no higher. Approved is not scheduled. Scheduled is not sent.
If its report says blocked, waiting or incomplete, the task is not done, whatever the status field says.
A mockup, placeholder, local build, stub returning 200, or passing unit test is not the live outcome, unless it was the named deliverable.
Blocked names the exact outside condition and who can clear it. The fleet moves to the next item.
If a write errored, check whether it happened before trying again, and retry with an idempotency key.
Part 2: governance, so done stays true
A definition of done only holds if the system running the agents enforces it. That half is AI agent governance: who can make an agent act, what it may do without asking, and how you prove what it did. My twelve governance rules, GOV-1 to GOV-12, and my own scorecard are on their own page.
Read the AI agent governance rules
The receipt
Every settled task ends with a receipt that a different process can check. The agent fills in its evidence. The runner fills in the verdict.
{
"dod": "1.0",
"task_id": "publish-pricing-page",
"owner": "worker-a",
"outcome": "Pricing page is live and shows the new plan",
"target": "https://example.com/pricing",
"claimed_status": "done",
"exit_code": 0,
"proof": [
{ "kind": "pull_request", "ref": "https://github.com/example/site/pull/12",
"checked_by": "actor", "result": "pass" },
{ "kind": "http_contains", "ref": "https://example.com/pricing",
"expect": "Team plan", "checked_by": "runner", "result": "pass" }
],
"approval": { "required": false },
"cost": { "input_tokens": 412000, "output_tokens": 9100, "usd": 0.84 },
"verdict": "done",
"verdict_by": "runner"
}Run the checker on your own agents
One Python file, standard library only, no credentials, offline unless you ask it to re-read URLs. It accepts loose logs too, so you can point it at whatever your agents write today and get your proof rate.
curl -sLO https://connorgallic.com/agent-dod/agent_dod.py
curl -sLO https://connorgallic.com/agent-dod/examples/receipts.jsonl
python3 agent_dod.py check receipts.jsonl # offline
python3 agent_dod.py check receipts.jsonl --live # re-reads URL proofs itselfExit 0 means every done claim meets the bar, 1 means at least one doesn't, 3 means bad input. This standard is the check after an action. For the check before an outbound call or text (consent, approval, quiet hours, opt-out) use the open source rails in smb-voice-bench.
If your agent makes phone calls
Calls are where "done" is easiest to fake and easiest to prove. A call has a carrier status, a recording and a transcript that a separate process can read back. That's why I built a phone number your AI agent can use on KaiCalls. Each call has a status, a recording and a transcript that your checker can read back, which is the receipt this standard asks for.
Questions
What is the definition of done for an AI agent?
Under this standard, an agent task is done only when something other than the agent has read the result back from the system where it lives, after the run: the page at its URL, the email in the sent log, the charge in the payment processor. That is proof level P3. The agent saying so, or exiting cleanly, is a claim, not done.
How is this different from the Scrum Definition of Done?
Scrum's Definition of Done is a team agreement about when work is releasable. This standard answers a narrower question: can a machine's claim of completion be believed? It adds proof levels, an independent verdict, and a receipt another process can check.
How do you verify an AI agent actually finished its work?
Name the observable outcome before the work starts, require the agent to end with a receipt, and have a separate process re-read the target. Never accept a zero exit code or the agent's summary as proof. The free checker scores a log of receipts and reports your proof rate.
Who decides an AI agent is done?
Not the agent. The agent submits evidence, and a separate verifier issues the verdict: the runner re-reading the target, an automated check, or a person. An agent that grades its own work will report done when the work only looks done.
What is an agent receipt?
A small JSON record that ends every settled task: the outcome promised, the target, the proof with who checked it, the approval state, the cost, and the verdict with who issued it. The schema is published at connorgallic.com/agent-dod/receipt.schema.json.
Cite it, change it
Cite as: Gallic, C. (2026). The Definition of Done for AI Agents, v1.0. connorgallic.com/definition-of-done. Text under CC BY 4.0, checker under MIT. Rule IDs are stable, so link to them directly, for example #dod-2 or /ai-agent-governance#gov-5. Corrections are welcome. A proposed change to a rule should come with the case that breaks it.
Get v1.1 and the next scorecard.
One email when the standard changes or new receipts drop. No daily AI news.