AI agent cost per successful task is the total cost of every attempt divided by the number of tasks completed correctly. Include model tokens, tool calls, retrieval, execution, retries, monitoring, and human review. A workflow that spends $0.10 per run but succeeds only 60% of the time costs about $0.17 per successful task before fixed engineering costs.
That denominator changes the buying decision. Token prices tell you what the model charges. They do not tell you whether the workflow finishes the job, how often it retries, or how much review a person must do. This guide gives you an AI agent cost calculator method that works across hosted APIs, agent platforms, and self-hosted infrastructure.
Use the worksheet below to make four decisions:
- whether the workflow has a viable cost per outcome;
- whether retries or tool calls are driving waste;
- what belongs in your AI agent cost per month forecast;
- which control to change before switching models.
What counts in AI agent cost?
An AI agent is a software workflow that uses a model to choose steps, call tools, inspect results, and continue until it reaches a stopping condition. The model is one cost layer. A browser session, database lookup, sandbox, search request, or approval queue can add cost around it.
Separate variable costs from fixed costs before comparing vendors. Variable costs scale with work. Fixed costs exist even when the agent is idle. Mixing them makes a small test look expensive or a high-volume deployment look cheap.
| Cost layer | Typical unit | What makes it grow |
|---|---|---|
| Model inference | Input, cached input, reasoning, and output tokens | Long context, verbose answers, repeated loops |
| Tools | Search, API, transaction, browser, or code call | More steps, failed calls, large results |
| Retrieval and memory | Embeddings, vector search, storage, database reads | Large collections and frequent refreshes |
| Execution | Container, browser, sandbox, or GPU time (see GPU cost per million tokens) | Long-running tasks and concurrency |
| Review and support | Human minutes, evaluation, incidents | Low confidence, risky actions, edge cases |
| Fixed operations | Platform, logging, backups, engineering | Production requirements and retention |
Provider pricing pages expose different pieces of this stack. Anthropic separates input, cache writes, cache hits, and output. Google separates input, output, context caching, and storage. The worksheet keeps those units visible instead of pretending one token rate represents the whole product. (Source: Anthropic pricing, Google Gemini pricing)
The AI agent cost per successful task formula
Use this formula for an outcome that has a clear pass or fail state:
Cost per successful task = total cost of all attempts ÷ successful tasks
Total cost includes every attempt, including attempts that time out, call the wrong tool, exceed a token limit, or reach a human. Successful tasks are the runs that meet your acceptance test without hidden correction work. Usage, latency, throughput, and input/output mix all affect the allocated cost of an inference workflow. (Source: NVIDIA inference TCO)
Here is a simple calculation. Suppose a month contains 100 initial attempts, 25 retry attempts, and 80 successful outcomes.
| Component | Calculation | Cost |
|---|---|---|
| Initial model and tool work | 100 × $0.06 | $6.00 |
| Retry model and tool work | 25 × $0.04 | $1.00 |
| Retrieval and execution | 100 × $0.01 | $1.00 |
| Human review | 20 × $0.10 | $2.00 |
| Total | $6 + $1 + $1 + $2 | $10.00 |
| Cost per successful task | $10 ÷ 80 | $0.125 |
The figures are an arithmetic example, not a market quote. The important result is the method. A dashboard that reports $0.08 per attempt would hide the $0.125 outcome cost because it ignores retries and the 20 review events.
AI agent cost calculator worksheet
Start with a ledger that records one row per task or one aggregate row per fixed workload. Do not estimate success rate from a few impressive demos. Use a defined acceptance test, such as a valid JSON result, a correctly updated record, or a human-approved answer.
| Input | Example | How to capture it |
|---|---|---|
| Initial attempts | 100 | Count task IDs entering the workflow |
| Retry attempts | 25 | Count every additional model or tool cycle |
| Successful tasks | 80 | Apply the acceptance test after the final step |
| Input tokens | 2.0 million | Provider usage response |
| Output tokens | 0.4 million | Provider usage response |
| Cached tokens | 0.8 million | Provider cache usage fields |
| Tool and API spend | $1.20 | Vendor invoices or request logs |
| Execution and storage | $0.80 | Container, browser, GPU, and database bills |
| Review minutes | 40 | Approval and correction records |
| Review rate | $0.10/minute | Loaded internal cost assumption |
For model costs, store input, output, and cached usage as separate fields. OpenAI exposes cached-token usage in the response, and Langfuse supports separate usage and cost details for input, output, cached tokens, and other usage types. Inferred prices are useful, but provider-reported usage and cost should win when both exist. (Source: OpenAI prompt caching, Langfuse cost tracking)
Add a stop_reason and task_status field. Useful statuses include completed, corrected, escalated, timed_out, and failed. Those fields show whether a cheap model is creating expensive downstream work.
AI agent cost per month: three planning scenarios
Monthly forecasting starts with successful tasks, not raw requests. Multiply the measured cost per successful task by the number of outcomes you need, then add fixed platform and operations costs. Separate peak demand, uptime, and fixed infrastructure from per-task usage so the forecast does not hide idle capacity. (Source: NVIDIA inference TCO)
| Monthly plan | Successful tasks | Cost per successful task | Fixed operations | Illustrative monthly cost |
|---|---|---|---|---|
| Pilot | 1,000 | $0.08 | $120 | $200 |
| Team workflow | 5,000 | $0.12 | $300 | $900 |
| Customer-facing | 20,000 | $0.18 | $900 | $4,500 |
These are planning examples, not predictions. The higher unit cost in the last row models a tool-heavy workflow with more review and support. Your measured result may fall as utilization improves, or rise when concurrency creates queueing and more retries.
Keep three forecasts beside each other: normal volume, a 3× spike, and a degraded-quality month. The degraded case matters because a provider outage, changed tool schema, or larger context can increase attempts without increasing successful outcomes. NVIDIA's TCO method also treats throughput, latency, peak demand, uptime, and input/output mix as cost inputs rather than optional details. (Source: NVIDIA inference TCO)
AI agent cost optimization that protects success rate
The best AI agent cost optimization changes waste while preserving the acceptance test. Start with the largest measured cost bucket. Provider usage data can expose cached input and output separately, which makes it easier to test whether a prompt or model change actually lowers spend. (Source: OpenAI prompt caching)
- Cap steps, tokens, elapsed time, and spend per task. Stop the run or request approval when a limit is reached.
- Route classification, extraction, and simple tool selection to a lower-cost model. Reserve a stronger model for ambiguous or high-risk cases.
- Keep stable instructions and tool schemas at the start of the prompt. Cache repeated context when the provider's terms make the reuse profitable, and run the prompt caching cost reduction break-even before assuming a cache pays for itself.
- Limit tool output. A search response that returns ten pages of irrelevant text can cost more in follow-up tokens than the search request itself.
- Track retries by reason. A retry caused by malformed JSON needs a different fix from a retry caused by a slow external API.
- Sample human review by risk and confidence. Review every payment action, but sample low-risk read-only tasks.
Langfuse notes that usage buckets must be mutually exclusive. If a provider reports inclusive input tokens plus cached tokens, subtract the cached portion before storing the ordinary input bucket. Otherwise your cost report can count the same tokens twice. (Source: Langfuse cost tracking)
When is an AI agent cheaper than a human?
Compare the agent with the fully loaded human cost for the same accepted outcome. A useful human baseline includes wage, benefits, management, software, waiting time, correction work, and the percentage of tasks that need escalation.
For a quick test, divide the loaded hourly cost by 60, then multiply by the minutes a person needs for one accepted task. A person costing $30 per hour and taking six minutes has a $3.00 variable baseline. An agent costing $0.45 per accepted task looks cheaper only if its quality, support, and fixed costs keep the final number below that baseline.
Inference: an agent should not be called profitable because its token bill is small. It is profitable when the value of the accepted outcome exceeds model, tools, infrastructure, review, support, and allocated build cost. Retool's discussion of hybrid human and AI workflows reaches the same practical point: the economic unit should reflect completed work, not an isolated API call. (Source: Retool AI pricing)
FAQ
What is the 30% rule in AI?
There is no universal provider or accounting standard called the 30% rule for AI agents. If a team uses a 30% assumption for success rate, review reduction, or savings, record it as a planning assumption. Replace it with measured task outcomes, retries, and review minutes before pricing a production workflow.
How much do AI agents cost to run?
AI agents can cost fractions of a dollar or much more per accepted task, depending on model usage, tools, retrieval, execution, retries, and review. Measure total spend across all attempts, divide by successful tasks, then add fixed platform and operations costs for a monthly forecast. Provider usage records and infrastructure metrics are the reliable inputs for that calculation. (Source: Langfuse cost tracking, NVIDIA inference TCO)
How much do agentic AI agents cost?
Agentic AI agents cost more than a single model response when they plan, call tools, retrieve data, run code, or ask for approval. The right estimate is workload-specific. Record tokens, tool calls, execution time, retries, and final task status instead of using a generic per-message price.
Is making AI agents profitable?
Making AI agents profitable depends on the value and repeatability of the accepted outcome. Compare that value with cost per successful task, fixed operations, support, and ongoing engineering. A lower token bill does not create profit if the agent fails often or sends too much work to human reviewers.
Related coverage
For trace design and model-cost instrumentation, see our Langfuse vs Opik observability comparison. For the infrastructure input, see GPU cost per million tokens. To cut the model layer first, see prompt caching cost reduction.
References
- Anthropic pricing - https://docs.anthropic.com/en/docs/about-claude/pricing
- Google Gemini pricing - https://ai.google.dev/gemini-api/docs/pricing
- Langfuse cost tracking - https://langfuse.com/docs/observability/features/token-and-cost-tracking
- NVIDIA inference TCO - https://developer.nvidia.com/blog/llm-inference-benchmarking-how-much-does-your-llm-inference-cost/
- OpenAI prompt caching - https://openai.com/index/api-prompt-caching/
- Retool AI pricing - https://retool.com/blog/cost-of-ai-agents-hourly-pricing-model
