AI agent cost in 2026: what one agent costs to build, run and buy

The three bills behind any AI agent cost

Every quote you'll get for an agent is one of three bills, and each arrives in a different unit.

A finished task is one piece of the job done end to end: a ticket closed, an invoice posted, a request answered. Count the tasks the agent finishes alone and the ones a person finishes after it hands over, because you pay for both. Our guide to AI agents for business prices agents by job, and enterprise AI agents prices the big platforms in their own units.

How we priced everything on this page

We read the pricing pages of the three model makers (Anthropic, OpenAI and Google), the agent vendors' pricing pages that our two agent guides use, and US public pay data from the Bureau of Labor Statistics, all on 27 September 2026. We also quote one Reddit thread, one person's published cost diary, the agency cost guides on the first page for "ai agent development cost", two surveys and an analyst's release; those are their authors' figures, not prices, and the page says so where they appear. Every calculation is ours and shows its inputs. Where a size isn't published, such as how long your instructions are, how many model calls your agent makes or how many weeks a build takes, it is labelled as an example assumption for you to substitute with your own figure. We tested nothing in a trial account, and all prices are in US dollars.

Meronym builds custom AI agents, sells none of the products priced here and has no referral or partner deal with the companies that do.

What buying an agent costs: the unit is the price

A vendor's price means little until you know what counts as one unit. Salesforce's Agentforce pricing shows the problem in one place: $0.10 an action through Flex Credits (bought at $500 per 100,000 credits), $2 a conversation, $2 a resolution for Help Agent, or $125 a user a month for employee add-ons, and one org can't run Flex Credits and conversations side by side. HubSpot's customer agent has charged $0.50 a resolution since 14 April 2026, and $0.50 a minute on voice. Fin charges $0.99 an outcome, at most one per conversation. Zendesk includes five automated resolutions per agent a month on its Support Team plan, then charges $1.50 each on a commitment or $2.00 pay-as-you-go.

Credits hide the price twice: of the vendors in the credit row, only Microsoft says what one credit costs, and Workday and SAP sell theirs by the year, so the only way to compare is to get the credit price in writing and multiply by the credits one of your tasks uses. Glean's own figures show why the rate per task matters as much as the credit price: a typical agent run uses about 7 credits, but a run at the 90th percentile uses about 114.

Minimums matter at low volume. Fin used on another helpdesk bills at least 50 outcomes a month, so $49.50 before your first ticket, and a per-user plan costs the same whether the agent does one task or a thousand. Our page on the AI customer service agent sets the per-resolution prices side by side, from about $0.20 (the standalone version of Tidio's Lyro) to $2.00 a resolution.

Voice is priced by the minute, and the minute is built in layers: Retell's $0.07 to $0.31 covers its voice infrastructure at $0.055 a minute, the voice and the model you pick. Our page on AI voice agents breaks down the time each layer takes.

What running your own agent costs: the model bill for one task

A chatbot's answer is one call to a model. An agent's task is several: one person who tracked every dollar of a self-hosted agent for three months, and who now recommends a managed host, found a moderately complex task could trigger "anywhere from 3 to 8 LLM calls" (dev.to, March 2026). The model keeps no memory between calls, so, in the diary's words, "Each call carries system prompts, tool definitions, conversation history, and the actual task payload", and a "simple" task "can easily consume 50,000 to 200,000 tokens", roughly three to eleven times the ticket worked below. The worksheet counts the same parts, only smaller: a shorter prompt, fewer tools, smaller tool results and four calls, each shown as an assumption you can substitute with your own figure. The diary's first month cost more for a different reason, an always-on agent that polls the model, "which eats tokens even when the agent is idle"; a support ticket handled once doesn't do that.

Tools add their own weight. Whenever tools are present, Anthropic's pricing page says its API "automatically includes a special system prompt for the model that enables tool use": 354 tokens a call on Claude Sonnet 5, 286 on Claude Opus 5.5 and 496 on Claude Haiku 4.5, on top of the tool definitions you write.

The cost-per-task worksheet: one support ticket

Replace the sizes in the first list with your own, keep the prices from the table above, and the two tables below give your cost per task.

Your numbers, as assumed here:

• Instructions and policy: 1,500 tokens, the same fixed prompt our LLM development services page prices for a month
• Tool definitions: four tools described in 1,000 tokens, plus Anthropic's 354-token tool-use prompt on Claude Sonnet 5
• The customer's message: 500 tokens
• Each tool result: 500 tokens (an order record, a payment, a refund confirmation)
• Output: 200 tokens for each tool call, 400 for the reply
• Thinking: none counted. A model that thinks before it answers bills those tokens as output, as Google's price table says, so its ticket costs more
• Calls: four: look up the order, look up the payment, issue the refund, write the reply

Input is 78% of the uncached bill, even though the agent writes only 1,000 tokens. That's why caching is the first thing to switch on, once the fixed part is long enough to cache: Anthropic says caching "pays off after one cache read for the 5-minute duration". Anthropic's own worked example for a customer support agent, about 3,700 tokens a conversation on Claude Haiku 4.5 and about $37 per 10,000 tickets, counts about a fifth of the tokens the worksheet's ticket sends, because that ticket looks things up and acts in four calls.

Four levers move this bill, each with a published size:

• Caching: a cache read costs a tenth of the input price on Claude Sonnet 5, GPT-6 Sol and Gemini 3.8 Flash, and a twentieth on Claude Opus 5.5, once the cached part reaches the model's minimum.
• Batch: work that can wait, such as an overnight backlog, costs half on all three makers' batch services.
• Routing: Claude Haiku 4.5 costs half as much per token as Sonnet 5, but at these sizes it can't cache the fixed part, so its ticket comes to $0.02318 against $0.02468 for Sonnet 5 cached, 6% less. Routing pays when the smaller model's prompt reaches its caching minimum, or when the task needs fewer calls; our LLM page works caching and routing through a whole month, from $12,000 to $5,565.
• Where it runs: keeping inference in the US adds 10% on Claude 4.6 and later models, OpenAI's data residency adds 10% on models released from 5 March 2026, and OpenAI's Fast mode (called Priority until 30 July 2026) doubles the price.

The rest of the running bill, and the people it still needs

Hosting barely registers per task. On AgentCore, a task that holds one vCPU and half a gigabyte for an assumed 30 seconds costs $0.000785 on v1 and $0.00113 on v2, about a tenth of a cent either way. Substitute your own duration when calculating your workload. The diary above paid $15 a month to monitor one small agent, which is one person's figure, not a rate card, and a line you'll need either way.

For a support agent, the people are the biggest line. The median US customer service representative earned $21.53 an hour in May 2025 (BLS), and wages are 68.5% of what an employer pays for a full-time private-sector worker (BLS, June 2026). That makes $31.43 an hour with benefits, about $0.52 a minute. At 10,000 tickets a month, every percentage point of tickets the agent hands to a person, at ten minutes each (your number), costs $524 a month: more than twice the model bill for all 10,000 tickets with caching on. HubSpot says its customer agent resolves 70% of conversations on average, and its top teams 90%, a vendor's figure for its own product; its April pricing post gave 65%, across more than 8,000 customers. At 70%, the 30 points handed over cost about $15,715 a month, about 64 times the cached model bill. The share handed over, and how long a person then spends, sets the running cost far more than the choice of model. Even the dearest model in the table, GPT-6 Astra, runs the worksheet's ticket for $0.12200 with caching, less than a quarter of one staff minute.

This isn't true everywhere. Where no person sits behind the agent, or a task runs for hours, tokens become the bill: in the diary's self-hosted agent, tokens were 64% of $560 over three months.

Upkeep keeps the agent working after launch: rerunning the evaluation set whenever the model or a prompt changes, fixing a connector when a system changes, watching for drift and covering incidents. Say two engineer-days a month (your number): at the $3,818 engineer-week in the next section, that's $1,527 a month, or 24% a year of the worked build there, inside the 15 to 25% a year DestiLabs' cost guide tells readers to plan for. Our managed tier is the same work bought as a service; its fee is in the build-or-buy section.

What building an agent costs, and where the money goes

A build pays for four stages, the ones our AI agent development services page publishes:

The in-house cost of that time is public. The median US software developer earned $135,980 in May 2025, and the top tenth more than $214,670 (BLS). At the median that's $65.38 an hour over 2,080 hours, $95.44 with benefits at the 68.5% share, so about $3,818 an engineer-week and $198,511 a year; for an engineer in the top tenth, at least $6,027 an engineer-week.

Here is one worked build for the ticket agent above. The team size and weeks are example assumptions to substitute with figures from your scope; they are not a quote.

What moves the total, biggest first, as our hub weighs it:

• The systems it writes to, not just reads: each one is a connector, a permission model and a way to undo a wrong write.
• Systems with no usable API, where the integration becomes most of the build.
• No labelled history to build an evaluation set from, so the first version has to be made by hand.
• Regulated actions that need dual approval, retention rules or hosting in one region; keeping Claude's inference in the US adds 10% to every token on Claude 4.6 and later.
• Voice, which adds telephony and a per-minute layer: $0.055 a minute for Retell's voice infrastructure, before the model and the voice.
• One named owner on your side who can decide takes more cost out than anything else.

The seven agency cost guides we read from the first page for "ai agent development cost" publish build ranges from $350 for a simple reflex chatbot (DevCom) to more than $800,000. Two show how a figure was reached: DevCom builds its component ranges from the hours each component takes, and DestiLabs describes one anonymised project, an order-management agent built for $52,000. A Reddit thread that Google's AI overview cited for this search on 25 September 2026 puts freelancers at "$1-5K to configure one chatbot" and agencies at "$5-25K for multi-agent setups that take 12 weeks". Its author builds agents for their own businesses and, later in the thread, offers setups through their own firm, so those are a seller's figures, not a rate card. A range without a scope can't be checked against your job, so ask for the scope first and the price second.

Build or buy: the break-even per finished task

The break-even is one line: the months a build takes to pay back equal the build, divided by what the vendor would charge you in a month less your own running cost and upkeep for that month. Take the worksheet's 10,000 tickets a month, with the agent resolving an assumed 70% without a person, HubSpot's published average and a figure to substitute with your own. Per-resolution vendors bill only those 7,000; Salesforce's Flex Credits bill every ticket, at an assumed four actions each. Fin would also bill any hand-off it completes by a procedure you've set up, which this leaves out, and Zendesk's figure is before the resolutions its plans include. Your own agent runs on about $0.025 a ticket in tokens and hosting, $255 a month, plus $1,527 of upkeep: about $1,782 a month, which is about $0.18 a ticket, or $0.25 for each of the 7,000 it resolves, against the vendors' $0.50 to $2.00 a resolution.

Against a $2.00 resolution the worked build pays back in about six months; against HubSpot's $0.50 it takes about 44. Below the volume in the last column it never pays back: at 500 tickets a month the largest vendor bill in the table would be $700, less than the upkeep alone.

Buying wins when:

• The job starts and ends in one vendor's system, such as a case in Salesforce or a ticket in Zendesk, and its agent can already act there.
• Your volume is low, so the per-unit price never adds up to a build and its upkeep.
• No one has been assigned ownership of the agent after launch: its evaluation set, approvals and model upgrades all need a named owner.

Building wins when:

• Your volume makes the unit price cost more than owning the agent: above the table's last column, and far enough above it that the months are short.
• The job crosses systems that no vendor's agent reaches, such as a refund that touches the helpdesk, the payment provider and the ERP.
• The rules are yours: approvals, limits and data residency the vendor can't enforce in its product.

When a custom build is the better fit, that's the work we do. Our AI agent development services start with a two-week scope that ends in a fixed quote, followed by a pilot, a production build and a rollout your team can take over or ask us to run. The scope costs $4k–$12k, credited against the build; a pilot on one workflow is $8k–$35k and a production agent $16k–$82k to build, with the running cost quoted apart, from $9k a month if we run it. This guide does not cite a client result for our service. The tiers are on our AI agent development services page.

Does an AI agent pay back?

The published surveys disagree, mostly over what counts as a return. In Google Cloud's 2025 survey, "74% of executives report achieving ROI within the first year". IBM's 2025 C-suite study found "only 25% of AI initiatives have delivered the expected return on investment (ROI), and just 16% have scaled enterprise-wide". And Gartner predicts over 40% of agentic AI projects will be scrapped by the end of 2027, "due to escalating costs, unclear business value or inadequate risk controls". Any return counts in the first; only the return that was expected counts in the second.

Your own payback is simpler to work out than any survey. Take the tasks the agent finishes each month, times the minutes each took a person, times the loaded cost of a minute ($0.52 for the median customer service representative above). Subtract the running cost and the upkeep. Divide the build by what's left, and you have the months to pay back.

Worked through for the ticket above: 10,000 tickets a month, 70% finished by the agent, and ten minutes a ticket before it arrived (your numbers). The 7,000 tickets it finishes save about $36,669 of staff time a month. Its running cost is about $255 in tokens and hosting plus $1,527 of upkeep, which leaves about $34,887 a month, so the $76,360 worked build pays back in a little over two months. Those months are measured against people doing the work; the break-even table's 6 to 44 months answer the other question, against buying a vendor's agent that would finish the same 7,000. Change the share it finishes or the minutes a ticket took, and the months move with them.

That sum is only believable if you measured the minutes before the agent arrived. Microsoft's guidance on agent ROI starts there: "capture a telemetry baseline" before you build.

When an AI agent is not the right investment

Anushree Verma, a senior director analyst at Gartner, put it plainly in the same release: "Many use cases positioned as agentic today don't require agentic implementations." Her split is agents where decisions are needed, automation for routine workflows and assistants for simple retrieval. Three cases where the money is better spent elsewhere:

• The steps never change. If every case follows the same path with no judgement in it, a fixed workflow does the job for less and fails more predictably. See our business process automation services.
• A few hundred tasks a month. At that volume a build never pays back against any vendor in the break-even table, so a per-resolution plan, or no agent at all, is cheaper. If what your team wants is help drafting replies, a seat plan such as ChatGPT Business or Claude Team, $20 a seat a month billed annually for at least two seats, gives each person an assistant rather than an agent that works the queue.
• You can't say what a task costs you today. Without the minutes and the volume, no quote can be judged. Measure first, then price.

Your next step: eight questions before you sign

You can now put any quote, whether a vendor's unit or a builder's project, into the same number: the cost of one finished task at your volume. These are the questions that get you the inputs:

1. What counts as one unit, and who decides it happened? Ask too whether a hand-off to a person is billed; on Fin, one it completes by a procedure you set up is. A useful answer names an event you can find in a log, rather than a feeling such as a happy customer.
2. Is there a monthly minimum or a yearly commitment, and do unused credits expire? Salesforce's unused Flex Credits don't roll over, and SAP's AI Units expire after 12 months. Look for a commitment paired with a report of what you've used against it.
3. What does one credit cost in dollars? Look for a dollar value, not only a credit count.
4. What does one of our tasks cost at our volume, worked out? Look for the calculation, not only a broad range.
5. How are price changes notified, and how much notice do you get? Look for a dated price list and a clear notice period.
6. Are the build and the running cost quoted apart? Ask for separate figures so you can understand and compare them.
7. Which model does it run on, and what does a task cost in tokens? A useful answer names the model and shows the token assumptions.
8. Who owns the agent, its prompts and its evaluation set at the end? Make sure ownership is written clearly in your agreement.