AI Agent Cost Benchmarks and Cost per Completed Task

An AI agent cost benchmark needs a defined workload and an outcome, not just a model's token price. Calculate the spending across every call and retry, then relate that spending to successfully completed tasks. Two agents with the same token price can have different operating costs if one takes more attempts or fails more often.

The FinOps Foundation distinguishes resource efficiency metrics, such as cost per token, from business unit metrics tied to outcomes. For an agent workflow, cost per completed task can connect those views. FinOps unit economics.

The example below uses synthetic data and assumed rates. It is a reproducible calculation, not measured model performance or a current provider price comparison. Use the AI cost calculator for planning scenarios, and replace assumptions with observed usage before setting operational budgets.

Calculate each call without double counting

For ordinary input and output billing, calculate:

call cost = input tokens / 1,000,000 × input rate
          + output tokens / 1,000,000 × output rate
          + separately billed tool or request charges

Use the units stated by the provider. Separate cached input, batch rates, reasoning-token billing, and other charge classes where they have different treatment. A single blended token rate can obscure those differences.

Sum the costs of every model and tool call in the attempt. If your token totals already include all steps, do not multiply them by step count again. If instead you estimate tokens per step, label that assumption and sum the estimated steps explicitly.

Retries and delegated calls belong in the total. Infrastructure, external APIs, storage, and human review may also belong in your business cost metric; state the inclusion policy rather than silently mixing a token-only estimate with a fully loaded operating cost.

A reproducible synthetic example

Assume input costs $2 per million tokens and output costs $8 per million tokens. These rates are chosen for this calculation and do not represent a named provider's list price. Token totals below are cumulative across each attempt's calls. There are no tool or infrastructure charges in this example.

The cost per completed task is $0.0364 divided by 2, or $0.0182. The unsuccessful attempt still consumed resources and remains in the numerator. Excluding it would produce a different, less complete metric: cost of successful attempts only.

Reproduce the calculation with Python's standard library:

from decimal import Decimal

input_rate = Decimal("2")
output_rate = Decimal("8")
rows = [
    {"input": 1000, "output": 100, "completed": True},
    {"input": 8000, "output": 800, "completed": True},
    {"input": 4000, "output": 400, "completed": False},
]

costs = [
    (Decimal(row["input"]) * input_rate
     + Decimal(row["output"]) * output_rate) / Decimal("1000000")
    for row in rows
]
completed = sum(row["completed"] for row in rows)
total = sum(costs)
print("Total token cost:", total)
print("Cost per completed task:", total / completed if completed else "undefined")

The output is 0.0364 total token cost and 0.0182 per completed task. With no completed tasks, the metric is undefined; reporting zero would imply a successful outcome at no cost.

Define completion before the run

A tool call succeeding is not necessarily a task completing. For a support workflow, completion might require a correct answer grounded in the approved source and no prohibited disclosure. For a coding workflow, it might require a specified test suite passing and a reviewer accepting the change.

Define those criteria before evaluating the agent. Record partial outcomes, timeouts, rejected actions, and unknown outcomes explicitly. If a retry succeeds, count one completed business task and include all of its attempts in the cost. Do not count every successful retry as a new completed task.

Keep success rate, latency, and review effort beside the cost metric. A cheaper run that fails the task or requires more manual work may be a worse operating choice.

What a measured benchmark should publish

A reader should be able to understand what was measured and reproduce the calculation:

• Workload definition, input dataset, and whether the data is synthetic or representative of production.
• Model, agent, tool, and relevant configuration versions.
• Completion criteria, evaluator, number of tasks, and treatment of ambiguous outcomes.
• Call counts, retries, token charge classes, tool usage, latency, and raw task outcomes.
• Pricing source and observation date, currency, billing units, discounts, and excluded charges.
• Calculation method, aggregate results, and variation across task types and repeated runs.

Use the same workload and outcome criteria for a comparison. Keep provider list-price arithmetic distinct from actual billed cost. A small illustrative dataset cannot establish a population-wide cost advantage or a typical monthly bill.

Turn measurements into budget controls

Start with observed volume and the distribution of task costs, rather than a universal headroom multiplier. Decide which actions can stop safely, how unresolved work is handled, and which limits need an operator override. Revisit the estimate when prompts, models, tools, or task mix change.

Alerts can help identify drift; enforcement needs a control at the point where additional spending can be prevented. Review concurrent calls and retries so a limit cannot be bypassed by several requests starting together. See budgets versus rate limits and how to set budgets for AI agents.

Praesidia combines agent identity, cost attribution, and budget policy. Evaluate the supported enforcement path for your workflow and retain the limits described in the AI FinOps guide. A planned estimate is useful, but observed outcomes and actual usage are what make the next budget decision defensible.

Common questions

Is the example a measured benchmark? No. Its task rows and rates are synthetic. It demonstrates correct arithmetic and the treatment of failed attempts.

What is a typical monthly agent cost? There is no useful universal figure without a workload, volume, success criterion, and billing basis. Calculate your completed-task cost and include the additional costs relevant to your operation.

Should failed attempts count? Yes in the total spending used to calculate cost per completed task. Keep failure rates visible alongside that metric.

How often should a benchmark be repeated? Repeat it when the workload, model, prompt, tools, evaluator, or pricing basis changes enough to affect the decision. Record those changes so comparisons remain interpretable.