How much does it cost to build an AI agent in 2026?
The cost of building an AI agent depends on five things: how many systems it connects to, whether it takes actions or only reads, how it is evaluated, how it is secured, and how much volume it handles. As a general market range, a narrow prototype costs in the low tens of thousands of dollars and a production agent with several integrations runs from the mid tens of thousands into six figures. At Goldenroz, Build projects start at $25,000 with a fixed price per phase, and running costs (model usage, monitoring, maintenance) are billed separately from the build.

What you are paying for
An AI agent is software that uses a language model to decide what to do next, calls tools to do it, and repeats until the task is done. The model itself is rented by the token. The build cost is everything around the model: the connections to your systems, the rules about what the agent may do, the tests that prove it behaves, and the monitoring that tells you when it stops behaving.
That is why two projects described with the same sentence (“an agent that handles support tickets”) can differ in cost by a factor of ten. The sentence hides the scope. The five drivers below expose it.
If you are still deciding whether you need an agent or a simpler assistant, read AI agent vs chatbot first. A chatbot is usually the cheaper answer when nothing needs to be changed in another system.
The five cost drivers
1. Integrations
Each system the agent touches adds work: authentication, permission mapping, error handling, rate limits and test data. A CRM, an ERP, a ticketing tool and a SQL database are four separate pieces of engineering, and older systems without clean APIs cost more than modern ones.
A standard connection layer reduces the repeated work. We build integrations as MCP servers where it fits, so the same connector serves more than one AI application. See MCP vs API for when that is worth it.
2. Actions versus read-only
An agent that only reads can be wrong without causing damage. The worst case is a bad answer. An agent that writes (updates a record, sends an email, issues a refund) can cause damage, so it needs more engineering:
- Approval steps for risky actions, with a human in the loop.
- Idempotency, so a retried step does not charge a card twice.
- Limits on amounts, counts and scope.
- A log of every action with the inputs that led to it.
Write access adds substantial effort to every part of the project it touches. It is also where most of the business value is, so the usual plan is to launch read-only and add actions one at a time.
3. Evaluation
A demo works on the ten examples its builder tried. Production gets the ten thousand cases nobody tried. Evaluation is the work of closing that gap: a set of real, labeled cases, automated runs against that set on every change, and a review of failures.
Evaluation is the driver buyers most often leave out of a budget, and the one that decides whether the agent is trusted after month one. Plan for it as a line item. The effort grows with the number of distinct tasks the agent performs, not with the number of users.
4. Security
An agent reads text from customers, documents and web pages, and any of that text can contain instructions meant to hijack it. This is prompt injection. Defending against it means the agent’s permissions must be enforced outside the model: per-user access, masked personal data, allowlisted operations and audit logs.
Shai built these controls into an on-prem MCP gateway: read-only by default, approved queries only (the model never writes SQL), per-user permissions, PII masking and a full audit log. The more sensitive your data, the larger this part of the budget. An independent security audit is worth adding for agents that touch payments or personal data.
5. Volume
Volume affects both the build and the bill. At low volume a single process and simple logging are enough. At high volume the agent needs queues, retries, timeouts, a fallback model for when the primary model is slow, and cost tracking per task. Volume also sets your monthly model spend, covered below.
Project shapes by relative effort
The table compares common project shapes by effort relative to the smallest one. It shows proportions, not prices. Actual prices are set per project after scoping.
| Project shape | Integrations | Takes actions | Relative effort | Typical first phase |
|---|---|---|---|---|
| Internal Q&A assistant over one knowledge source | 1 | No | 1x | Working prototype on real documents |
| Customer support assistant with order lookup | 2 to 3 | No | 2x to 3x | Read-only launch on one channel |
| Support agent that issues refunds or edits orders | 2 to 4 | Yes | 3x to 5x | Read-only first, then one action with approval |
| Operations agent across ERP, CRM and email | 4 or more | Yes | 5x to 8x | One workflow end to end |
| Multi-agent system with long-running tasks | 4 or more | Yes | 8x and up | Architecture phase, then one agent |
As a hedged general market range, the first row is typically a project in the low tens of thousands of dollars, and the last two rows are typically six-figure projects. Quotes vary widely between vendors, and a quote far below these ranges usually excludes evaluation, security or maintenance.
Build cost versus running cost
The build is a one-time cost. Running the agent is a monthly cost with three parts.
Model API usage. Model providers bill per token, with separate prices for input and output, and larger models cost more than smaller ones. An agent makes several model calls per task, and each call resends context, so input tokens dominate the bill.
Monitoring and infrastructure. Hosting, logging, alerting and evaluation runs. For most agents this is small compared with model usage.
Maintenance. Models are updated and retired, the systems you integrate with change their APIs, and new failure cases appear in the logs. Someone has to own this. Budget recurring engineering time for it from the first month.
A worked example of model usage
This is a hypothetical example. The prices are placeholders chosen to keep the arithmetic simple. Check your provider’s current price list before using the result.
Assume a support agent handles 5,000 conversations a month. Each conversation takes 6 model calls. Each call sends 8,000 input tokens (instructions, tool definitions, history) and returns 500 output tokens. Assume $3 per million input tokens and $15 per million output tokens.
- Input: 5,000 x 6 x 8,000 = 240 million tokens. 240 x $3 = $720.
- Output: 5,000 x 6 x 500 = 15 million tokens. 15 x $15 = $225.
- Total: $945 a month, or about $0.19 per conversation.
Three levers move this number. Prompt caching reduces the cost of repeated context. Routing simple steps to a smaller model lowers the price per call. Trimming history and tool definitions lowers tokens per call. A well-built agent tracks tokens and cost per task from day one, so you see the bill before the invoice arrives.
Model usage is usually paid by you directly to the provider, from your own account. That keeps the keys, the data agreement and the spend under your control.
What Goldenroz charges
We publish one number for Build work: projects start at $25,000. Each phase has a fixed price that is agreed after a scoping call, and larger platforms run $100,000 and up. We do not sell hourly blocks.
A typical agent project is split into phases so that you can stop after any of them:
- Scoping. We pick one workflow, define what “correct” means and list the systems involved.
- Prototype on real data. A working agent, read-only, measured against real cases.
- Production. Permissions, logging, retries, fallbacks, cost tracking and deployment.
- Actions and expansion. Write access added one action at a time, each with limits and approval rules.
Shai does the engineering. The evidence for the estimate is work already in production: a WhatsApp ordering bot on Claude with a model fallback chain, timeouts, retries and deterministic fallback replies, durable agent loops with token and cost tracking, and the MCP gateway described above. Details are on the AI agent development page.
How to lower the cost
- Start with one workflow. A narrow agent that finishes one task is worth more than a broad agent that half-finishes five.
- Launch read-only. You get the evaluation data you need before any action carries risk.
- Give the builder real cases early. Fifty real tickets with correct outcomes save weeks of guessing.
- Reuse connectors. One MCP server per system serves every agent you build later.
- Decide who owns maintenance. An agent without an owner degrades quietly.
If your team wants to build in-house, the cheaper route may be training. Our Claude Code training program sets engineering teams up to build with AI coding agents safely.
What to do next
Write down one workflow, the systems it touches and whether the agent must change anything in them. That is enough for a useful first conversation. Book a free one-hour consultation through the AI agent development page and we will tell you which project shape you are looking at and what the first phase would cost. If you are not sure an agent is the right tool at all, start with AI consulting.