The cost of running an AI agent per user per month is driven mainly by how many model calls each user triggers and how much context, including tool outputs and conversation history, gets fed into the model each step, since agentic workflows often make several model calls per single user action. A lightweight agent handling occasional, simple requests might cost a small fraction of a dollar per month in raw inference per user, while a heavily used agent that performs multi-step reasoning, calls several tools, and retrieves substantial context on each turn can cost several dollars or more per active user per month. Using a smaller or cheaper model for routine steps like tool selection or formatting, while reserving a larger model for genuinely hard reasoning, is one of the most effective ways to control cost without hurting user experience. Caching repeated context, such as system prompts and tool definitions, and capping how much conversation history gets replayed on each call also meaningfully reduces per-user spend. Actual usage patterns vary widely by agent design and user behavior, so a per-user estimate should come from measuring calls and tokens per session during a pilot rather than assuming a flat rate. Nanobase AI instruments AI agent deployments to track actual per-user cost from day one so budgets stay predictable as adoption grows.
Per-user cost is a multiplication, not a lookup
Estimating AI agent cost per user by dividing total infrastructure spend by user count produces a number that is technically correct on average and useless for planning, because agent cost is driven by how actively each user engages, not by how many users exist. The right way to estimate per-user cost is to build it from the ground up: calls per session, tokens per call, and sessions per month, multiplied together and priced at the applicable rate, then segmented by usage tier because a light user and a heavy user can differ by an order of magnitude.
The formula
Cost per user per month = (calls per session x average tokens per call x price per token) x sessions per month.
Agentic workflows often make several model calls per single user action, since a typical agent step involves reasoning about what to do, calling a tool, interpreting the result, and deciding the next step, which multiplies the call count well beyond what a simple chat interaction would need.
A worked example across usage tiers
Using illustrative token and call figures only, not real prices, to show how the tiers diverge:
| Usage tier | Calls per session (illustrative) | Tokens per call (illustrative) | Sessions per month (illustrative) | Relative monthly cost |
|---|---|---|---|---|
| Light user | Few | Low, simple requests | Occasional | Small fraction of a dollar to low single dollars |
| Medium user | Moderate | Moderate, some tool context | Regular | Several dollars |
| Heavy user | Many, multi-step reasoning | High, substantial retrieved context | Frequent | Materially higher, potentially many dollars |
The gap between a light and a heavy user is rarely linear, because heavy users tend to trigger longer multi-step reasoning chains with more tool calls and more context per call simultaneously, so their cost compounds across all three variables in the formula rather than just one. A budget built on an average user figure will understate cost for a product that attracts a disproportionate share of heavy users.
The two highest-leverage cost controls
- Model tiering by step type: routine steps like tool selection or output formatting rarely need the most capable model available, while genuinely hard reasoning steps do; routing appropriately can meaningfully reduce blended cost without a noticeable quality drop for most users.
- Context discipline: capping how much conversation history and tool output gets replayed on each call, and caching repeated context like system prompts and tool definitions, directly reduces tokens per call, which is one of the three multipliers in the cost formula.
Why a pilot measurement beats an upfront estimate
Actual usage patterns vary widely by agent design and user behavior in ways that are difficult to predict before real users interact with the product. A short pilot that instruments calls and tokens per session, segmented by user, gives a far more reliable per-user cost figure than any upfront estimate, and it also reveals which usage tier the majority of the user base actually falls into, which is the input that matters most for budgeting at scale.
Frequently asked questions
Does agent cost per user grow linearly with total user count?
No, total cost scales with total usage, not user count directly, so a growing user base with a stable mix of light and heavy users grows cost roughly linearly, but a shift toward more heavy-usage behavior can grow cost faster than user count alone would suggest.
Should context caching be applied to tool definitions as well as system prompts?
Yes, tool definitions are often sent on every single call in an agentic workflow and rarely change between calls, making them one of the most reliable candidates for caching alongside static system prompts.
How much does multi-step reasoning increase cost compared with a single chat response?
It varies by agent design, but a workflow with several sequential reasoning and tool-calling steps per user action inherently makes several times more model calls than a single-turn chat response, so cost per interaction should be estimated per full task, not per single model call.
Is it worth instrumenting cost tracking before launch, or after seeing initial usage?
Before launch is preferable, since retrofitting per-call and per-token tracking after the fact makes it much harder to reconstruct accurate historical cost data, and early instrumentation lets the team catch a runaway cost pattern before it scales with the user base.
How Nanobase AI helps
Nanobase AI instruments AI agent deployments to track actual per-user cost from day one, segmented by usage tier, so budgets stay predictable as adoption grows rather than being based on an average-user assumption. This connects to reducing LLM inference costs without losing quality and MCP server integration for agent tool calls.
Ready to discuss your project? Contact Nanobase AI or email hello@bumu.tech.