AI agent pricing is unusually opaque, partly because the technology is new and partly because vendors benefit from the vagueness. Here is the structure underneath it.

Two separate costs

Build cost is one-off: working out what the agent should do, connecting it to your systems, constraining it, and proving it works.

Running cost is ongoing: mostly model tokens, plus modest hosting.

They behave differently. Build cost is driven by complexity. Running cost is driven by volume. A business with low volume and complex systems has the opposite problem to one with high volume and simple systems.

Where build cost actually goes

The proportions surprise most people:

Stage Share of effort
Process audit and scoping 25%
Integration work 30%
Guardrails, permissions, escalation 15%
Evaluation and testing 20%
Prompting and model work 10%

The part everyone imagines is the whole project is a tenth of it.

Integration is the biggest single item, and its size depends on your systems rather than on the agent. A CRM with a clean, documented API is a day. A system with no API, requiring an intermediate layer and scheduled sync, is weeks. This is why a credible quote requires someone to look at your actual stack first.

Audit and scoping is large because the real process is never the documented process, and the exceptions — which are where agents fail — are never written down anywhere.

Evaluation is the item most often cut to reduce price, and cutting it is a false economy. Without a test suite of real historical cases, you cannot tell whether a change improved the agent or quietly broke it.

What drives the build price up

  • Number of systems the agent must read from and write to
  • Absence of APIs on any of them
  • Regulatory review — healthcare, legal and financial contexts add real work
  • Scope breadth — each additional case category reduces reliability and adds testing
  • Data quality — messy inputs need normalisation before the agent sees them

What drives it down

  • One well-defined workflow rather than a broad remit
  • Modern systems with APIs
  • A process your team can actually describe
  • Historical examples with known correct outcomes, for the evaluation set
  • Willingness to start narrow and widen after launch

Running cost, concretely

Running cost is tokens consumed per task, and it varies with how much context the agent reads and how many steps it takes.

A simple classification — reading an email and routing it — consumes little. A multi-step agent that reads a long document, queries three systems and drafts a reply consumes considerably more. For most business workflows the per-task figure lands somewhere between a few cents and a few dollars.

That range is wide, which is exactly why you should insist on measuring it rather than estimating. During the build, instrument the agent and report cost per completed task. We do this as standard, because the economics should be clear before launch rather than discovered on the first invoice.

Reducing running cost

Applied together, these typically cut spend substantially versus sending everything to the largest model:

Model routing. Send simple classification to a small cheap model, reserve the large one for genuine reasoning. Most steps in most workflows do not need the frontier model.

Caching. Identical or near-identical requests should not be recomputed. In workflows with repetitive inputs this alone can be the largest saving.

Context discipline. Sending an entire document when three paragraphs would do multiplies cost on every run. Retrieval instead of stuffing.

Token caps and quotas. Per-request limits and per-user quotas prevent a runaway loop producing a runaway bill.

Batching. Where latency does not matter, batched processing is cheaper.

The payback calculation

Straightforward, and worth doing before you commit:

  1. Time the task properly — three times, measured, not estimated.
  2. Count monthly occurrences from a real system.
  3. Hours saved per month = minutes × occurrences ÷ 60.
  4. Value those hours at the loaded cost of whoever does them.
  5. Annual saving = monthly saving × 12, minus annual running cost.
  6. Payback = build cost ÷ monthly net saving.

If payback is under six months, it is usually an easy decision. Six to twelve months is reasonable for a workflow that will keep running. Beyond a year, you have probably picked the wrong first workflow — go back and score your candidates properly.

The cost people forget

Maintenance. Third-party APIs change. Models get deprecated. Your process evolves. An agent left untouched for a year will degrade, and most clients keep a small monthly retainer covering updates, monitoring and tuning.

Budget for it from the start. An agent is software, not a purchase.

When it is not worth it

We would talk you out of it when:

  • Volume is low. A task done twice a month will not recover a build cost.
  • The process cannot be described. Fix that first; it is valuable regardless.
  • The saving is in a role you would not change. If nobody's workload actually drops, the saving is theoretical.
  • An existing product does it. Plenty of workflows are covered by software you can buy for less than a custom build.

If you want this calculated against your own numbers rather than generic ranges, send us the process and the volume and we will work it through with you.