Every founder who asks us "how much will this cost?" gets a vague consultancy answer somewhere else: "it depends, let's scope". That's not useful. So here are the real numbers, from 40+ production AI projects we've shipped in the last 18 months. We'll cover three agent types, the build cost for each, the monthly running cost, and when each one pays back.
Short answer (TL;DR)
- Chatbot / FAQ assistant: $8k–$25k to build · $200–$800/month to run
- Workflow agent (one specific automation, e.g. tier-1 support): $30k–$80k to build · $600–$3,500/month to run
- Autonomous agent (multi-step, tool-using, decision-making): $80k–$250k to build · $2k–$15k/month to run
If your project doesn't fit one of these buckets, it's probably 2–3 of these stacked together. Multiply accordingly. Now the long version.
What we mean by "AI agent"
This is the first place cost conversations go sideways. Three things commonly called "AI agents" are wildly different:
- Chatbot — answers questions from a knowledge base. Single-turn or short-conversation. No actions, no integrations beyond reading docs. Examples: help-center bot, internal Q&A tool.
- Workflow agent — receives an input, runs a defined sequence of steps (often calling tools or APIs), produces a defined output. Examples: a tier-1 support agent that resolves tickets, an inbox triager, an invoice generator.
- Autonomous agent — given a goal, decides what to do, takes multiple actions, recovers from failure, knows when to escalate. Examples: a research agent, an operations agent that runs your warehouse on its own, a SDR that books meetings.
The cost gap between #1 and #3 is roughly 20×. Be precise about which one you actually need.
Build cost: the one-time number
Chatbot / FAQ assistant — $8k–$25k
Why this is cheap now: the pattern is well-understood, the tooling is mature, and you mostly need someone to wire up RAG over your docs, build a clean UI, and ship a basic eval set. A solo senior engineer can ship this in 2–3 weeks. We charge $12k–$20k for a polished version. You can do worse for cheaper. You can do better for more.
Workflow agent — $30k–$80k
This is where most real ROI lives. The build cost reflects the integrations (Shopify, Zendesk, Gorgias, CRM, custom internal systems), the eval discipline (a real test suite), and the confidence-scoring layer that decides when to escalate. Our 30-day sprints for these typically land between $40k and $65k.
Autonomous agent — $80k–$250k
Autonomy is expensive because the failure modes are exponential. You need: tool-use frameworks, recovery logic, careful prompt engineering, extensive evals, observability, kill-switches, and someone who can debug "why did the agent decide to do that?" at 2am. We've shipped these for clients in regulated industries (finance, healthcare-adjacent) and they always cost more than people expect. If you're quoted under $80k for true autonomy, ask hard questions about what's being skipped.
Monthly running cost: the bill that doesn't stop
This is the line item most teams underestimate. There are four buckets to budget for:
1. LLM token costs
The piece everyone obsesses over and is actually the smallest most of the time. As of Q2 2026:
- Claude Sonnet 4: ~$3 per million input tokens, ~$15 per million output tokens
- Claude Haiku: ~$0.25 / ~$1.25 per million
- GPT-4o: ~$2.50 / ~$10 per million
- Open-source (self-hosted Llama 70B): ~$1–$3 per million all-in including GPU time
For a workflow agent handling 5,000 conversations/month at ~3k tokens each: that's ~$200–$400/month in tokens. For a chatbot doing 50,000 short queries/month: ~$100–$200/month. Real talk: unless you're at huge volume, tokens are a small line item.
2. Infrastructure
- Hosting (Vercel, Fly.io, AWS): $50–$500/month
- Database + vector store (Supabase / Neon with pgvector): $25–$500/month
- File storage (R2 / S3): negligible for most
3. Observability + evals
The single line item that pays for itself the fastest, and the one most teams skip:
- LLM observability (Langfuse self-hosted): $50–$300/month
- Error monitoring (Sentry): $25–$200/month
- Eval runs (CI + LLM-as-judge): $50–$300/month
4. Human-in-the-loop ops
Even an autonomous agent has someone watching it. Usually 0.1–0.3 of a person's time on monitoring, prompt tuning, escalation review, and weekly eval review. At blended ops salary, budget $1,500–$5,000/month of internal time.
The unglamorous secret of AI economics: the LLM is the cheap part. The ongoing observability, eval discipline and prompt iteration is what makes the system stay good — and that's where teams under-invest.
The full picture: TCO across 12 months
Putting it all together for a typical workflow agent (e.g., AI tier-1 customer support):
- Build: $50,000 (one-time)
- Tokens: $300/month → $3,600/year
- Infrastructure: $200/month → $2,400/year
- Observability + evals: $250/month → $3,000/year
- Internal ops time: $2,500/month → $30,000/year
12-month TCO: ~$89,000. Most teams compare this to "the LLM bill is only $300/month, so it's cheap." Don't do that.
ROI: when does it pay back?
The economics are usually obvious once you do the math honestly. Take support automation: the average company we work with has a support team where a fully-loaded agent costs ~$60k–$80k/year. A workflow agent that resolves 70% of tier-1 traffic typically eliminates 1.5–2 full headcounts of growth (you don't fire anyone; you stop hiring the next two). That's $90k–$160k/year of avoided cost against an $89k/year TCO.
Operator.io's economic outcome was $340k/year in avoided headcount — against a build cost of $65k. Payback was under three months.
The payback math isn't the same in every industry. Here's a rough heat map of where workflow agents pay back fastest in our experience:
- Fastest payback (1–3 months): high-volume support, sales SDR functions, content/copy production at scale
- Mid payback (3–6 months): internal ops, data sync, reporting agents, lead qualification
- Slower but strategic (6–12 months): in-product AI features that protect or grow ARR (different math — link this to retention/expansion)
Five hidden costs nobody talks about
- Prompt iteration time. Your first prompt will be 70% of where you need it. Getting to 95% takes weeks of iteration. Budget for this.
- Eval suite construction. A real test set (50–200 representative cases) takes 1–2 weeks to build properly. Skip it at your peril.
- Model migrations. Models change every 3–4 months. Your prompts need to be revalidated.
- Edge case backlog. The 5% of weird user inputs that break things. Plan for 0.1 of a person ongoing.
- Compliance / data residency. If you're in finance, healthcare, EU, add 15–30% to build cost.
How to lower your bill (without skipping eval discipline)
- Route by model. Use Haiku for classification + first-pass; Sonnet for the hard stuff. We've seen token bills drop 60–80% with proper routing.
- Cache aggressively. Anthropic and OpenAI both support prompt caching — use it on system prompts and large retrieval contexts.
- Don't fine-tune unless you must. Sonnet 4 + a great prompt + RAG beats most fine-tuned models for 90% of business use cases.
- Self-host only if you're at scale. Self-hosting Llama 70B starts paying off above ~$3k/month in API cost. Below that, just use APIs.
What to ask any vendor or agency quoting an AI agent
- What does the 12-month TCO look like, not just the build cost?
- Who owns and maintains the prompts and eval suite after handoff?
- What's your eval methodology — show me a real eval report from a past project
- What's the kill-switch / rollback story?
- What happens to my costs if the underlying model deprecates?
Want a real cost estimate for your specific workflow? Book a 30-minute audit. We'll go through your operation, scope what an agent would actually do, and tell you a realistic number — including the ongoing line items most quotes skip.