Agents that do real work: Part 3 of 3
How to measure AI agents and decide when they can act alone
Any account of how to measure AI agents should start small. Every evening one of our agents at Motif Platforms logs the day's outcomes into our back-office tracker. One line of it reads "Readback: 11 of 11 found." The agent wrote eleven records, then asked the system for them and counted what came back.
That line is the smallest useful measurement we run. Part 2 (opens in a new tab) showed why it is far from enough: three of my requests sat unanswered for up to two days while every receipt was clean, and I found out by asking.
This part covers what we measure today, what those numbers cannot show, the four measures we are adding, and how a job should earn the right to act without asking me. Part 1 (opens in a new tab) covers the design behind it.
The short answer
Start by measuring an AI agent on four things: whether every run happened, whether what it wrote can be read back from the system it changed, how many runs in a row succeed, and whether it stayed inside its approval rules. Grant autonomy one job at a time, on that record.
What we measure today
These readings come from one week of the two-agent setup.

- Run coverage: did every scheduled job run? One receipt per run, with gaps counted each morning. Claude's morning check reported 0 missed runs for its own jobs on each day it checked, November 12 to 14. ChatGPT's jobs are counted separately.
- Write verification: did what the agent wrote land? Readback from the system of record found every record on each night it ran: 7 of 7, 10 of 10, 11 of 11 and 11 of 11.
- Request handling: were my requests picked up? The hourly watcher's first run found 3 and handled 3, two of them partly.
- Handoff closure: did requests between Claude and ChatGPT complete? 2 of 9 closed, and 1 failed two mornings running.
- Learning rate: is the system writing down what it learns? 20 entries in five days.
An executive can read that list in a minute, and each line maps to a question worth asking of any agent deployment.
What can these numbers not show?
The agent grades its own work. Readback is a real check because it reads system state. Most other lines in a receipt are the agent's account of itself. Laksh Advani's study of false success (opens in a new tab) found that in two customer-service domains 45% to 48% of failed runs still closed with a claim of completion, and that five LLM judges given those transcripts could not separate true from false completion well. A confident receipt is weak evidence.
One run says little. Agents vary from run to run. A job that worked on Tuesday has shown that it can work.
The sample is small. One week and a few dozen runs per job tell me where to look. They do not support a claim that the setup is reliable.
The earlier series (opens in a new tab) made the same argument about training: a grader that rewards the wrong signal teaches the wrong behavior. In production, a metric that rewards the wrong signal buys false comfort.
Four measures to add next
1. Reliability across runs
Anthropic's guide to agent evals (opens in a new tab) separates two numbers. pass@k is the chance that at least one of k attempts succeeds. pass^k is the chance that all k succeed. The guide's worked example: an agent that succeeds 75% of the time passes three runs in a row only about 42% of the time.

For a daily job, k is the calendar. A week of clean, verified runs is one observed streak, not a measured pass^7. pass^7 estimates the chance that seven independent trials all succeed: at a constant 95% per trial, about 70%. On a scorecard I want both, per job: the current streak of verified runs and the per-run success rate, rather than the success rate alone. Sierra's τ-bench (opens in a new tab) reports agents this way for the same reason: customers meet the agent many times.
2. Outcomes graded from system state, with policy checks on the path
The same guide defines the outcome as the final state of the environment: whether the reservation exists in the database, whatever the agent said. It also warns against grading the exact sequence of steps, because agents find valid routes nobody planned.
We are keeping one kind of path check: policy. Our contracts list actions that need my approval, such as sending email, spending and publishing. ST-WebAgentBench (opens in a new tab) calls the idea completion under policy: a task counts only if the agent finished it and broke no rule on the way. Our version tracks two numbers: requests that reached a verified outcome within policy and ask-first actions attempted or taken without a recorded yes. A request blocked while it waits for my yes counts as a policy success and an unfinished request. The target for the second number is zero, and one violation moves a job down the ladder described below.
3. A second model as reviewer, calibrated against a person
Models tend to rate their own writing kindly. Panickssery, Bowman and Feng showed that LLM evaluators recognize and favor their own generations (opens in a new tab). We have two agents from two vendors, so each can review the other's work.
A reviewer needs calibrating too. Hamel Husain's guide to LLM judges (opens in a new tab) recommends aligning the judge to one domain expert's pass or fail decisions before trusting it. At Motif that expert is me, and the calibration set is the corrections I have already made. I'll set aside a separate batch of examples, label them before seeing the reviewer's answers, and check how often it misses an error or flags acceptable work.
We draft with one model and have the other review against a rubric: factual accuracy, strength of argument, gaps against current thinking, and tone. On this series, that review caught that a clean week is one observed streak, not a measured pass^7, and turned my promotion rule into a trigger for review.
4. Failure patterns from production
Replit's account of evaluating its agent at scale (opens in a new tab) describes three layers: an offline benchmark, production A/B tests, and a system that clusters production traces into recurring issues. Anthropic's guide suggests starting far smaller, with 20 to 50 tasks drawn from real failures.
We have the raw material for the small version. Both agents write learnings in one format, and Part 2's six failures are the first six test cases. The next step is a weekly pass that groups the log by cause and turns each recurring cause into a check a job must pass before its contract changes.
How should an agent earn autonomy?
Most discussion of agent autonomy treats it as a setting. I think of it as something a job earns, one job at a time, and can lose.

- Draft: the agent prepares work for a person to send or post. Today: LinkedIn posts, outreach notes.
- Act and report: it completes reversible internal work, then posts a receipt. Today: market map updates, email-authentication checks.
- Act, verify and report: it writes to a system of record, reads it back and posts the result. Today: the nightly outcome log.
- Act on the ask-first list: it sends, spends, publishes or deletes without a prior yes. Today: nothing.
Others have built similar scales. Feng, McDonald and Zhang define five levels of autonomy (opens in a new tab) by the role the person keeps: operator, collaborator, consultant, approver, observer. The Cloud Security Alliance proposes six levels (opens in a new tab) modeled on the scale used for self-driving cars. Ours differs in one respect: the rung belongs to the job, and the job has to earn it.
Three rules govern movement. They are our working hypothesis until the measures above have run for longer.
- Up on evidence. A job moves up after a sustained run of verified outcomes at its current rung. For a low-risk job, 20 consecutive verified runs and zero policy violations trigger a review, not a promotion. Before a job gains a new permission, we test that exact action against edge cases and define how to revoke it. I expect to revise the number.
- Down on a single breach. One ask-first action without a yes, or one false "Done," returns the job to the rung below.
- Longer tasks need more proof. Salesforce's CRMArena-Pro (opens in a new tab) reports agents completing about 58% of single-turn tasks and about 35% of multi-turn ones. Reliability falls as work gets longer, so the bar should rise with the length of the task.
Rung 4 stays empty until the measures above exist and have run for a while. Being able to defend a promotion with numbers matters more to me than the hours saved.
What to do next
If you run agents today, or are about to:
- Add a receipt to every run and count the gaps each morning.
- Make every job that writes something read it back from the system of record.
- Report each job's current streak of verified runs and its per-run success rate.
- Write the ask-first list, count violations, and tie each job's autonomy to that count.
Then ask the question that caught us: if a request to your agents went unanswered for two days, what would tell you?
For practitioners
- Grade from state wherever you can. Use a model judge only for what code cannot check and calibrate it against a named person.
- Give partial credit. "Partly done" with a stated remainder is more useful than a binary result.
- Read transcripts every week. Anthropic's guide makes the point that you cannot tell a failing agent from a faulty grader without reading runs.
- Use the other vendor's model as the reviewer when you have one.
- Keep the failure log in a fixed format so it can become a test set.
----
Daljeet Saran (dsaran@motifplatforms.com) is the founder of Motif Platforms, where he builds AI and data systems for commercial teams. He currently spends most of his time on pre- and post-training data and evaluation for AI agents that do real knowledge work.
Earlier series: Teaching machines to do real work (opens in a new tab), on how AI agents learn knowledge work in training.
Open source: the templates and figures from this series are on GitHub as agents-that-do-real-work (opens in a new tab). The templates are under the MIT License, and the summaries and figures are under CC BY 4.0, so you can use and adapt them with attribution.
Resources
- Advani, L. (2026). From Confident Closing to Silent Failure: Characterizing False Success in LLM Agents. arXiv. (opens in a new tab)
- Anthropic. (2026). Demystifying evals for AI agents. (opens in a new tab)
- benchflow-ai. awesome-evals (reading list). GitHub. (opens in a new tab)
- Feng, K. J. K., McDonald, D. W., Zhang, A. X. (2025). Levels of Autonomy for AI Agents. arXiv. (opens in a new tab)
- Furman, D., Zhong, P., Li, Z., Catasta, M. (2026). Closing the loop: Evaluating and improving Replit Agent at scale. Replit. (opens in a new tab)
- Huang, K., et al. (2025). CRMArena-Pro. arXiv. (opens in a new tab)
- Husain, H. Creating an LLM-as-a-Judge That Drives Business Results. (opens in a new tab)
- Levy, I., et al. (2024). ST-WebAgentBench. arXiv. (opens in a new tab)
- Panickssery, A., Bowman, S., Feng, S. (2024). LLM Evaluators Recognize and Favor Their Own Generations. arXiv. (opens in a new tab)
- Reavis, J. (2026). Leveling Up Autonomy in Agentic AI. Cloud Security Alliance. (opens in a new tab)
- Vvkmnn. awesome-ai-eval (reading list). GitHub. (opens in a new tab)
- Yao, S., et al. (2024). τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains. arXiv. (opens in a new tab)