How Much Do AI Agents Cost to Run

The Cost Formula

The cost of an agent task is the sum of all model calls during the task. Each model call has a cost determined by the number of input tokens (the context window sent to the model) and the number of output tokens (the model's response). For a task with N iterations, the total cost is:

The critical insight is that the input cost grows with each iteration because the context window accumulates previous reasoning, tool calls, and tool results. The first iteration might send 3,000 input tokens (just the system prompt and the task). The fifth iteration might send 15,000 input tokens (system prompt, task, plus four rounds of reasoning and tool results). The tenth iteration might send 30,000 or more. This means later iterations are disproportionately expensive, and a task that takes 20 iterations costs far more than twice what a 10-iteration task costs.

To illustrate with concrete numbers at mid-2026 pricing: GPT-4o charges approximately $2.50 per million input tokens and $10.00 per million output tokens. Claude Sonnet 4 charges $3.00 per million input tokens and $15.00 per million output tokens. A 10-iteration agent task with an average context of 10,000 input tokens and 1,000 output tokens per iteration costs approximately $0.35 on GPT-4o and $0.45 on Claude Sonnet. For frontier reasoning models like GPT-o3 or Claude Opus, multiply these numbers by 5 to 10.

The Three Cost Drivers

Iteration count is the most direct cost driver because each iteration requires a model call. Reducing the number of iterations reduces cost linearly. Techniques that reduce iteration count include: giving the agent better tools so it gets the information it needs in fewer calls, writing clearer system prompts so the agent reasons more efficiently, providing relevant context from memory so the agent does not need to search for information it has already encountered, and using plan-then-execute patterns where the planning step reduces wasted iterations in the execution phase.

Context window size drives cost because every token in the window is paid for on every call, and the window grows with each iteration. An agent that starts with 3,000 tokens and adds 3,000 tokens per iteration has a window of 30,000 tokens by iteration 10. The total input token cost across 10 iterations is 3,000 + 6,000 + 9,000 + ... + 30,000 = 165,000 tokens. If the agent had managed its context to stay at a stable 8,000 tokens per iteration (by summarizing old tool results), the total would be 80,000 tokens, a 52% cost reduction. Context management is the single most effective cost reduction technique for agents.

Model pricing tier determines the per-token cost. Frontier reasoning models (GPT-o3, Claude Opus) cost 5 to 10 times more per token than their mid-tier counterparts (GPT-4o, Claude Sonnet). Mid-tier models cost 5 to 20 times more than small models (GPT-4o-mini, Claude Haiku). For many agent tasks, a mid-tier model performs well enough, and using a frontier model adds cost without proportional quality improvement. The exception is complex reasoning tasks where the frontier model's additional capability produces meaningfully better results, but these should be validated with testing rather than assumed.

Cost Reduction Techniques

Model routing: Use a frontier model for complex reasoning steps and a cheaper model for simple steps. The routing decision can be based on the step type (use the frontier model for planning and evaluation, the mid-tier model for tool calls and summarization), the iteration number (use the frontier model for the first iteration to set the strategy and cheaper models for execution), or the task complexity (route simple tasks to the small model entirely and complex tasks to the frontier model). Model routing can reduce costs by 40 to 70% with minimal quality impact when done well. The routing guide covers the implementation.

Context compression: Actively manage the context window by summarizing completed tool results, dropping irrelevant conversation history, and truncating large tool outputs. This keeps the window small across iterations, which reduces both the per-iteration cost and the quality degradation from context dilution. As noted above, maintaining a stable context window size can cut total input token costs by 50% or more. The context compression guide covers the techniques.

Caching: Cache tool results and model responses to avoid redundant API calls. If the agent searches for the same query twice, the cached result saves both the search API cost and the model call cost for processing the result. Prompt caching (available in the Anthropic API) caches the static prefix of the context window so that tokens that do not change between iterations are charged at a reduced rate. For agents with large, stable system prompts, prompt caching alone can reduce per-iteration input costs by 50% or more. The prompt caching analysis covers when this is effective.

Memory-based context reduction: Instead of keeping all intermediate results in the context window, store them in a memory layer and retrieve only the ones relevant to the current step. This keeps the context window lean (only current-step information) while giving the agent access to everything it has learned (through memory recall). Adaptive Recall is designed for exactly this use case: it stores agent findings with relevance metadata and retrieves the few that matter for each step, keeping context small and costs low. The memory for token reduction guide quantifies the savings.

Economic Viability

The question of whether an agent is economically viable depends on the comparison: what does the agent cost per task versus what the alternative costs? If the alternative is a human performing the same task, the comparison is agent cost per task versus human labor cost per task. If the alternative is not doing the task at all, the comparison is agent cost versus the value of having the task done.

For customer support, where human agents cost $15 to $35 per hour and handle 3 to 8 tickets per hour, the human cost per ticket is $2 to $12. An AI agent that resolves routine tickets for $0.10 to $0.50 each is 10 to 100 times cheaper. Even accounting for the 10 to 20% of tickets that require human escalation, the economics strongly favor AI agents for high-volume support.

For coding tasks, the economics depend on the task. A bug fix that takes a developer 30 minutes ($25 to $50 of labor) and costs $1 to $3 for the agent is clearly viable. A complex feature that takes a developer a full day ($200 to $400) and costs $10 to $20 for the agent (with human review) is also viable. The agent does not replace the developer, it compresses the work, but the cost savings are still significant.

For low-value tasks, agents may not be viable. If the task's value is less than the agent's cost (for example, classifying a single short text for $0.001 value at an agent cost of $0.10), a simpler non-agentic approach is better. The rule is: use agents for tasks valuable enough to justify multiple model calls, and use single-call AI for everything else.