AI agents · monthly cost · prompt caching · July 2026
How much does an AI agent cost per month?
A production AI agent handling ~1,000 conversations/day (8 turns each, with a 1.5K-token tool block) costs roughly $2,000–$10,000 per month on the models teams actually ship — $2,076 on Claude Haiku 4.5, $4,152 on Sonnet 5, $10,380 on Opus 4.8 — as of July 2026. The full spread runs $196 (GPT-4.1 nano) to $20,760 (Claude Fable 5). Prompt caching cuts that 47–59%.
Most "AI agent cost" answers quote a price per million tokens — a commodity number that tells you almost nothing about your bill. The real cost of an agent is different: LLM APIs are stateless, so every turn resends the whole conversation history plus the tool/function definitions as input. That resent context, not the raw token price, is what makes an agent expensive. Below is what it actually costs per month, per model, at real volumes — with the math shown.
Claude Haiku 4.5
Claude Sonnet 5
Claude Opus 4.8
prompt caching
By model
Monthly cost at 1,000 conversations/day
The reference agent is a fixed, reproducible unit (defined in Methodology): a support/ops agent that runs 8 turns per conversation, with a 2,000-token system prompt and a 1,500-token tool block resent every turn, plus 200 user and 500 assistant tokens per turn. That is 49,200 input tokens and 4,000 output tokens per conversation. At 1,000 conversations/day × ~30 days = 30,000 conversations/month. Click a column header to sort.
| Model | Provider | Input $/1M |
Output $/1M |
Cost / conversation |
Cost / month |
With caching / month |
Caching savings |
|---|---|---|---|---|---|---|---|
| GPT-4.1 nano | OpenAI | $0.10 | $0.40 | $0.0065 | $196 | $104 | 46.7% |
| Gemini 3 Flash | $0.50 | $3.00 | $0.0366 | $1,098 | $453 | 58.7% | |
| Claude Haiku 4.5 | Anthropic | $1.00 | $5.00 | $0.0692 | $2,076 | $1,044 | 49.7% |
| GPT-5.6 Luna | OpenAI | $1.00 | $6.00 | $0.0732 | $2,196 | $1,164 | 47.0% |
| Gemini 3.5 Flash | $1.50 | $9.00 | $0.1098 | $3,294 | $1,359 | 58.7% | |
| Claude Sonnet 5 | Anthropic | $2.00 | $10.00 | $0.1384 | $4,152 | $2,089 | 49.7% |
| Gemini 3.1 Pro | $2.00 | $12.00 | $0.1464 | $4,392 | $1,813 | 58.7% | |
| GPT-5.6 Terra | OpenAI | $2.50 | $15.00 | $0.1830 | $5,490 | $2,911 | 47.0% |
| Claude Opus 4.8 | Anthropic | $5.00 | $25.00 | $0.3460 | $10,380 | $5,222 | 49.7% |
| GPT-5.6 Sol | OpenAI | $5.00 | $30.00 | $0.3660 | $10,980 | $5,822 | 47.0% |
| Claude Fable 5 | Anthropic | $10.00 | $50.00 | $0.6920 | $20,760 | $10,443 | 49.7% |
All figures USD. "Cost / month" = cost per conversation × 30,000 conversations. "With caching" applies each provider's cache-read / cache-write rates to the stable prefix; output is never cached. Snapshot of published list prices, verified 2026-07-13.
By volume
How cost scales with conversation volume
Agent cost is linear in volume — the per-conversation number is fixed by the conversation shape and the model, so the monthly bill is just that figure times daily conversations times ~30 days. The jump from a pilot (100/day) to production (10,000/day) is a straight 100×.
| Model | Provider | 100 conv/day (pilot) |
1,000 conv/day (production) |
10,000 conv/day (scale) |
|---|---|---|---|---|
| GPT-4.1 nano | OpenAI | $20 | $196 | $1,956 |
| Gemini 3 Flash | $110 | $1,098 | $10,980 | |
| Claude Haiku 4.5 | Anthropic | $208 | $2,076 | $20,760 |
| GPT-5.6 Luna | OpenAI | $220 | $2,196 | $21,960 |
| Gemini 3.5 Flash | $329 | $3,294 | $32,940 | |
| Claude Sonnet 5 | Anthropic | $415 | $4,152 | $41,520 |
| Gemini 3.1 Pro | $439 | $4,392 | $43,920 | |
| GPT-5.6 Terra | OpenAI | $549 | $5,490 | $54,900 |
| Claude Opus 4.8 | Anthropic | $1,038 | $10,380 | $103,800 |
| GPT-5.6 Sol | OpenAI | $1,098 | $10,980 | $109,800 |
| Claude Fable 5 | Anthropic | $2,076 | $20,760 | $207,600 |
Monthly USD, no caching, same reference agent (8 turns, 2K system, 1.5K tool block). Caching would cut each figure 47–59%.
The hidden weight
Why the tool block is the quiet cost driver
Here is the part the per-token price never shows you. An agent's tool and function definitions — the JSON schemas that tell the model what it can call — sit in the input on every single turn, alongside the system prompt and the growing history. They are not "one-time" context; they are billed again on turn 2, turn 3, all the way to turn 8.
In the reference agent, the 1,500-token tool block is billed 8 times: 12,000 tokens per conversation, about 24% of all input. That is before a single tool is actually called. Add real tool results flowing back into context and the share climbs further.
- Trim it and you win on every turn. Cutting the tool block from 1,500 to 500 tokens removes 8,000 input tokens per conversation.
- At 1,000 conversations/day on Claude Opus 4.8, that trim alone saves roughly $1,000/month — just from tighter function schemas.
- Fewer tools, shorter descriptions, and enums instead of free-text params are the cheapest optimization you can make.
Want the exact number for your own schemas? Our Tool / Function Token Cost tool measures how many tokens your tool definitions add to every request.
Methodology
How the numbers are calculated
An LLM API is stateless: to continue a conversation the agent resends the entire history plus its tool definitions as input every turn. So the input tokens on turn t are system + tools + (t−1)·(user + assistant) + user. The reference agent fixes every variable so all models are compared identically:
- System prompt: 2,000 tokens (resent every turn)
- Tool / function block: 1,500 tokens (resent every turn)
- User message: 200 tokens per turn
- Assistant response: 500 tokens per turn
- Turns: 8 · Volume: 1,000 conversations/day × 30 days
That yields 49,200 input tokens and 4,000 output tokens per conversation. Cost per conversation prices those at each model's list rate; cost per month multiplies by 30,000. With caching, turn 1 writes the whole prefix and each later turn reads the prior prefix (at the provider's cache-read rate) and writes only the new user+assistant tokens (at the cache-write rate) — 40,600 cache-read and 8,600 cache-write token-equivalents across the conversation. Output is never cached, on any provider.
Without caching Input, turn 1 = 2,000 + 1,500 + 200 = 3,700 tok Input, turn 8 = 2,000 + 1,500 + 7x700 + 200 = 8,600 tok Total input over 8 turns = 49,200 tok -> $0.2460 (@ $5 / 1M) Total output over 8 turns = 4,000 tok -> $0.1000 (@ $25 / 1M) Cost per conversation = $0.3460 x 1,000 conv/day x 30 days = $10,380 / month With prompt caching Cache reads = 40,600 tok x 0.1 = 4,060 tok-equiv Cache writes = 8,600 tok x 1.25 = 10,750 tok-equiv Input (cached) = 14,810 x $5 / 1M = $0.0741 (input down 70%) Output (never cached) = $0.1000 Cost per conversation = $0.1741 x 30,000 conversations = $5,222 / month Saved by caching = 49.7% of total cost
Price sources (verified July 13, 2026)
List prices are a dated snapshot taken from each provider's official pricing page. Providers change prices without notice — always confirm against the source:
- OpenAI (GPT-5.6 Sol / Terra / Luna, GPT-4.1 nano): openai.com/api/pricing
- Anthropic (Claude Fable 5, Opus 4.8, Sonnet 5, Haiku 4.5): anthropic.com/pricing · prompt caching docs
- Google (Gemini 3.1 Pro, 3.5 Flash, 3 Flash): ai.google.dev/gemini-api/docs/pricing
Caveats. This is a planning estimate, not a bill. It assumes fixed average token sizes, exactly 8 turns per conversation, a cache hit on every turn (turns within the cache TTL), and standard synchronous pricing — no batch discounts, no context-length premiums, no Gemini per-hour cache storage fee, and no cost for tool results returning into context (which raises real bills). Reasoning/thinking tokens are billed as output and are not separately modeled here. Real agents vary — use this to size a budget and rank models, then verify against your provider's usage dashboard.
Optimization
Four ways to cut an agent's bill
Turn on prompt caching
Serves the repeated prefix at ~0.1× input price. Cuts the total agent bill 47–59% here, more on longer conversations. Almost always worth the wiring.
Shrink the tool block
Tool schemas are billed every turn. Fewer, tighter function definitions save on all 8 turns — ~$1,000/mo on Opus just from a 1K-token trim.
Right-size the model
The same agent costs 5× more on Opus 4.8 than Haiku 4.5. Send easy turns to a cheaper model and reserve the frontier model for hard ones.
Cut the system prompt and old turns
Both the system prompt and every earlier message are resent as input on every turn, so cumulative input grows with roughly the square of the turn count. Summarizing or dropping stale history, and tightening the system prompt, attacks the fastest-growing part of the bill. See our Conversation Cost Simulator to watch that curve for your exact shape.
Model your exact agent
These are numbers for one reference agent. Plug in your real turn count, system prompt, tool block and volume — and see the cost curve and caching savings live, in your browser.
FAQ
Common questions
How much does an AI agent cost per month?+
A production AI agent handling ~1,000 conversations/day (8 turns each, a 2,000-token system prompt and 1,500-token tool block resent every turn, 200 user + 500 assistant tokens per turn) costs roughly $2,000–$10,000/month on the models teams ship — about $2,076 on Claude Haiku 4.5, $4,152 on Sonnet 5, $10,380 on Opus 4.8, as of July 2026 list prices. The full spread runs $196/mo (GPT-4.1 nano) to $20,760/mo (Claude Fable 5). Prompt caching cuts these 47–59%.
Why are AI agents so expensive to run?+
Because LLM APIs are stateless: to continue a conversation the agent resends the entire history plus its tool/function definitions as input on every turn. One turn is only ~3,700 input tokens, but eight turns bill 49,200 — the same system prompt, tool block and early messages paid for again and again. The tool block alone is billed on every turn (12,000 tokens over 8 turns, ~24% of input). Multiply by thousands of conversations a day and it compounds fast.
How can I reduce the cost of an AI agent?+
Four levers: (1) Prompt caching serves the repeated prefix at ~0.1× input and cuts the bill 47–59%. (2) Trim the tool block — fewer, tighter schemas mean fewer tokens billed every turn. (3) Right-size the model — the same agent costs 5× more on Opus 4.8 than Haiku 4.5, so route easy turns to a cheaper model. (4) Shorten the system prompt and prune history, since both are resent every turn. Caching plus routing typically cut a production agent bill by more than half.
How much does prompt caching save on an AI agent?+
About 47–59% of total cost on the reference agent, depending on the provider. Caching discounts only the repeated input prefix — system prompt, tool block and already-seen history served at ~0.1× input — and never the generated output, so input savings are larger (~70–80%) but output tokens dilute the total. Gemini's cheaper cache writes give it the largest total-cost cut here.
How much does the tool or function-calling block add?+
A lot, because tool definitions are resent every turn. The 1,500-token tool block is billed 8 times — 12,000 tokens per conversation, ~24% of all input. Cutting it from 1,500 to 500 tokens removes 8,000 input tokens per conversation; at 1,000 conversations/day on Opus 4.8 that is roughly $1,000/month saved from the tool block alone.
How does agent cost scale with conversation volume?+
Linearly. On Sonnet 5 the reference agent costs ~$415/mo at 100 conv/day, ~$4,152/mo at 1,000/day, and ~$41,520/mo at 10,000/day. On Opus 4.8 the same volumes are ~$1,038, $10,380 and $103,800/mo. Cost per conversation is fixed by the shape and model; the monthly bill is that figure × daily volume × ~30 days.
More waynetools