The question "how much does an AI agent cost" sounds like a price-list inquiry, but it’s really a question about architecture. The same business outcome can be delivered cheaply and unpredictably or slightly more expensively, but with a cost that can be planned a year in advance.
What the cost consists of#
- Implementation (project CAPEX) — process analysis, designing the agent’s steps, integrations with your systems (CRM, email, databases), testing, and deployment.
- Variable model costs (OPEX) — either payment for tokens in the cloud or amortization of your own infrastructure. Here, the choice is between API or sovereign infrastructure.
- Maintenance — quality monitoring, prompt and logic fixes, adding new skills as the process changes.
We don't quote a single number, because it would be made up — the cost grows with the number of integrations and the volume of tasks. Below are orientational ranges; we calculate the real quote on your own process.
| Component | Nature | What drives the range |
|---|---|---|
| Implementation | CAPEX (one-time) | A simple task-based agent: from a few thousand PLN. A production agent integrated with company systems: typically on the order of PLN 30,000–80,000, depending on the number of integrations and rules; we calculate the real quote on your own process. |
| Variable model costs | OPEX (monthly) | Task volume × calls per task × cost per call in the API, or amortization of your own infrastructure. Matching the model to the task can change this item several times over. |
| Maintenance | OPEX (monthly) | The scale of process changes, the number of handled paths, and the required level of quality monitoring. |
What actually drives up the bill#
The most expensive part isn’t the model itself — it’s unpredictable calls. An agent that invokes the largest cloud model for every step generates a bill that grows with usage. That’s why we route model access through a router that selects the right model for the task: small and cheap for classification, powerful only where truly needed. This is usually the biggest single cost lever.
How to calculate unit cost#
Instead of asking about the price of an agent, calculate the cost of completing one task: how much it costs to handle one lead, classify one document, or answer one query. This metric can be directly compared to the cost of a human performing the same work — and only then does it show whether the agent is cost-effective.
Calculation scheme (an example, not a price list — we compute the real figures on your own data):
- Variable cost with an API = number of tasks per month × number of calls per task × cost of a single call (which itself depends on the number of input and output tokens and on how large a model handles the given task). In a multi-step agent, one task is often several to a dozen calls (each step of the ReAct loop is a separate LLM call), so don't assume that 1 task = 1 call — that's the most common mistake that understates the bill for agents.
- Prompt caching — on the input side, the biggest lever for a RAG agent is caching the fixed system prompt and RAG context headers: these are usually the majority of input tokens, and caching them cuts the input cost by 20–40% without changing the logic (how to optimize token cost).
- Unit cost with self-hosting = (hardware amortization + electricity + maintenance) ÷ number of tasks. The larger and more stable the volume, the lower the cost per task.
- Break-even point is the volume at which these two numbers meet — below it the API is cheaper, above it your own infrastructure wins. The crossover shifts with every price-list change and hardware generation, which is why we calculate it on real load rather than upfront.
Order-of-magnitude example (rates from mid-2026, verify against the current price list): for a mid-tier model (about USD 0.30 per 1M input tokens and about USD 1.20 per 1M output tokens), a task consuming ~1k input tokens and ~0.5k output tokens costs about USD 0.0009 per call — at 50k tasks per month that's on the order of a few dozen USD per model. On the self-hosting side, a GPU box spread over amortization is a range of about USD 600–1,200/month, so the break-even point usually sits around 0.5–2M calls per month. We calculate the exact breakdown on your own volume; we lay out the threshold details in cost: local model vs API.
You can calculate your own ranges in our tools: the ROI calculator shows whether a task pays off against manual work, and the inference cost calculator estimates the variable cost per task. We break down the API-vs-own-model threshold in cost: local model vs API, and the FinOps side with ongoing bill monitoring in LLM cost monitoring. When you want a figure tailored to your own process rather than a calculator estimate — describe your case and we'll calculate a quote.
When own infrastructure pays off faster#
At low volume, cloud API is cheaper (no entry cost). With steady, high workloads, self-hosting models and BGE-M3 embeddings start to win on cost and provide predictability. The break-even point depends on volume — that’s why we tailor the option to real workload, not maximum hardware.
Try it live#
Describe your case, and the model will estimate the cost breakdown (implementation, variable model costs, maintenance) and the unit cost per task (playground: PII masked, zero retention):
FAQ#
What determines the cost of an AI agent?#
Three factors: process complexity (number of steps and integrations), volume (how many tasks per month), and the choice between cloud API and own infrastructure. The strongest impact on the ongoing bill comes from matching the model to the task.
Is it cheaper to use a ready-made API or your own model?#
At low volume — API. With steady, high workloads, self-hosting models delivers lower and predictable unit costs. The threshold depends on the number of monthly tasks.
How to avoid overpaying for an agent?#
Measure the cost per completed task, route all calls through a router that selects the right model for the job, and start with one narrowly defined process instead of an "agent for everything."