Personalized AI infrastructure
Cost Per Completed Agent Task: How to Measure Real Unit Economics
Learn how to calculate cost per completed AI agent task, including failed attempts and human review time, so you can compare agents on real unit economics.

Cost per completed agent task is the total cost of bringing one piece of work to an accepted result, divided by the number of results that were accepted. The total includes model and tool usage, failed and retried attempts, hosting and maintenance, and the human time spent reviewing, correcting and approving output. Measured this way, an agent can be compared with a person, a template or another tool on the same unit economics.
Key takeaways
- Divide total cost by accepted completions, never by tasks started.
- Count failed attempts, retries and escalations in the numerator, because they are part of the real price of the work.
- Put human review and correction time into the calculation, logged per task and valued at an internal hourly rate.
- Break the figure down by task type, since an average can hide the one workflow that keeps failing.
- Recalculate each month on a fixed definition of completion, so a change in the number means a change in the work.
Why the usual cost figure misleads
Most teams start with the invoice from their model or platform provider and divide it by the number of runs. That number is easy to obtain and weak for decisions. It ignores runs that produced nothing usable, ignores the reviewer who rewrites half a draft, and ignores the hour an engineer spends repairing a connector after a tool changed its response format. An agent can look inexpensive per run and still be expensive per accepted outcome. The reverse also happens: an agent that costs more per run but finishes work without review can be the cheaper option overall.
The fix is not a more complicated spreadsheet. It is an agreement on what counts as finished, a log that records what happened to each task, and a cost model that includes the people who check the output.
Define "completed" before you count anything
"Completed" cannot mean that the agent returned an answer. It has to mean that the output meets acceptance criteria written in advance. For a support reply, the criteria might be that the correct order is identified, the policy cited is current, and the reply is sent through the approved channel. For a supplier quote, the criteria might be that every line matches the current catalog and the approval threshold was respected.
Write down who decides acceptance and what happens to partial work. A partly finished task is not a completion. It is rejected, escalated to a person, or abandoned, and each outcome carries its own cost. A corrected output counts as completed once a reviewer accepts it, and its review time stays in the numerator. Keep the outcome labels short and fixed, so the log can be filtered without interpretation.
A task that was started but not accepted is still a cost, just not a unit of output.
The formula and the steps to measure it
Use one formula across every agent and every task type:
Cost per completed task = (usage cost + hosting and maintenance share + human review cost + cost of failed attempts) divided by the number of accepted completions in the same period.
- Tag every run with a task ID, a task type, a start time and one outcome label: completed, corrected, escalated, rejected or abandoned.
- Pull model and tool usage for each run from the provider and platform records, including retries and repeated tool calls.
- Record human time per task from the moment it enters review to the moment a decision is logged, and split it into reading, editing and rework sent back to the agent.
- Allocate platform, hosting and integration maintenance to each period using the same rule every month.
- Divide the total for each task type by its accepted completions, then compare the result with the cost of the same task done by a person under the same definition.
If your platform emits traces, the OpenTelemetry concepts of traces and spans give each run a structure you can filter. Its generative AI conventions also define fields for model and token counts, which many tools already record.
How do you measure human review time without guessing?
Reviewers underestimate the time they lose to context switching and overestimate the time spent on checks they consider important. Use timestamps instead of memory. The review queue records when an item arrives and when it leaves, and the edit history shows what changed. Where the tools cannot capture this, a short manual time log kept for two weeks gives a usable baseline.
Track rework separately. When a reviewer sends an item back to the agent, that cycle is a cost of the agent, even if the final output is good. Review time should not be the only quality signal, because it falls when reviewers stop checking. Pair it with a sampled audit of accepted outputs. Anthropic's guidance on evaluating agents describes combining outcome checks with transcript review, which is a practical pattern for building that sample.
Illustrative scenario: an operations lead runs an agent on 100 order-status requests in one month. The agent completes 80 with no edits, 12 need a reviewer to correct the reply before it is sent, and 8 are escalated before any reply goes out. Reviewers spend six hours in total on the 20 items that needed attention. Accepted completions are 92, the 80 clean ones plus the 12 corrected ones. The numerator must still include usage for all 100 runs, the six review hours and the maintenance share, because the 8 escalated runs also consumed resources. Leaving them out would make the figure look better than the operation really is.
Compare the agent with the human baseline
A fair comparison uses the same definition of completion for both sides. If a person handles the same request and the reply is accepted on the first pass, that is the baseline. If the team has no record of manual cost, run both methods for a short period on the same task type and log them the same way. Do not compare an agent's accepted output with a person's unreviewed first draft.
Keep waiting time separate from the unit figure when you measure it, such as the time a customer waits for a reply, so the cost per task stays comparable. Pricing structure also changes the numerator, because usage, seat and retainer arrangements spread costs differently as volume grows. The guide on AI agent pricing models explained shows how each structure behaves at different volumes. For the questions a finance reviewer will ask about this kind of figure, see AI business case for finance.
Keep the cost stable as the agent changes
Costs move when memory, tools or approvals change. A larger context filled with old notes raises usage on every run. A tool with vague descriptions causes extra calls and retries. A new approval step can reduce rework while adding review time. Record each change with the before and after values for the same task type, measured over periods of the same length.
Two levers matter most. First, keep context to what the task needs. Anthropic's guide on context engineering describes the goal as the smallest set of high-signal material that produces the desired behavior. Second, where a large, stable instruction block repeats across runs, check whether prompt caching from your model provider applies, since it lowers the usage line without changing the work. Route every change through a documented request and approval, as described in how to request and approve changes to a managed AI agent, so the before and after numbers can be trusted.
How Be Human's managed approach handles this
Be Human's managed operations set the completion criterion and outcome labels during the first engagement, configure the task log that each run writes to, and report cost per completed task beside quality, escalations and permission events in recurring evaluations. When a change to memory, tools or approvals moves the figure, the change request records the before and after values for the affected task type. Monitoring, integration maintenance and periodic permission review keep the cost inputs current, and the work is delivered remotely in English or Portuguese. If you are not sure which of your tasks deserves an agent first, the free Be Human AI diagnostic will help you find the first task worth handing to an agent.
Frequently asked questions
How is cost per completed agent task different from cost per run? Cost per run divides spend by every attempt, including attempts that were rejected, escalated or abandoned. Cost per completed task divides the full cost, including human review time, by only the tasks that reached an accepted result. The second figure reflects what the business actually receives, so use it for decisions and keep the per-run figure as a technical signal.
Should we count human time if the person would have done the work anyway? Yes, because the agent changes where that time is spent. Checking outputs, correcting errors and handling escalations are part of the cost of running the agent. Compare the result with the same task done manually under the same completion definition, so the comparison is fair in both directions.
How often should the figure be recalculated? A monthly calculation is a practical default for operations teams, using the same completion definition and allocation rule each time. Pair it with a sampled audit of accepted outputs, so a falling review time is not mistaken for better quality. When memory, tools or approvals change, calculate the figure for the affected task type before and after the change.
Do we need a specialized platform to start measuring? No. A task log with a task ID, task type, timestamps, usage per run and one outcome label is enough for a first measurement. Platform tracing becomes useful as volume grows and runs involve several tools, because it shows where calls and retries accumulate.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


