How Much Do AI Agents Cost to Run in Production Monthly?

Most founders obsess over the cost to build an AI agent, then get blindsided by the monthly bill to keep it running. The development cost is a one-time expense. The operational cost recurs every single month, and it scales with usage in ways that traditional SaaS infrastructure does not.

A customer support agent handling 10,000 conversations per month can easily cost $1,500 to $3,000 in pure operational expenses. A sales SDR agent running outbound campaigns might cost $400 to $1,000. A coding assistant serving a 10-person engineering team could run $200 to $600. These numbers catch people off guard because they are 5x to 20x higher than the equivalent traditional software infrastructure costs.

The reason is simple: every time your agent processes a request, it calls a large language model. That LLM call has a per-token cost that adds up fast. On top of that, you are paying for vector databases, compute infrastructure, monitoring tools, memory storage, and external tool executions. If you have not mapped out all of these cost categories before launch, you are flying blind.

We have operated dozens of production agents at Kanopy Labs across a range of use cases and scales. The numbers in this guide come from real invoices, not estimates. If you are still in the planning phase, our guide to AI agent development costs covers the upfront build, while this article covers everything that comes after deployment.

LLM API spend typically accounts for 50% to 80% of your total monthly agent cost. The price depends on which model you use, how many tokens each request consumes, and how many requests your agent handles per month. Here is the current pricing landscape for the most commonly used models in production agents.

Anthropic Claude Models

• Claude Opus: ~$15 per million input tokens, ~$75 per million output tokens. Best for complex reasoning, multi-step planning, and tasks where accuracy is critical. Use sparingly.
• Claude Sonnet: ~$3 per million input tokens, ~$15 per million output tokens. The workhorse for most production agents. Excellent reasoning at a reasonable price point.
• Claude Haiku: ~$0.25 per million input tokens, ~$1.25 per million output tokens. Ideal for classification, routing, simple extraction, and high-volume low-complexity tasks.

OpenAI Models

• GPT-4o: $2.50 to $10 per million input tokens depending on the variant. Strong general-purpose model with competitive pricing.
• GPT-4o Mini: $0.15 per million input tokens. Excellent for lightweight tasks and high-volume classification.

Google Gemini Models

• Gemini 1.5 Pro: $1.25 to $5 per million input tokens. Competitive pricing with a massive context window (up to 2M tokens).
• Gemini 1.5 Flash: $0.075 per million input tokens. One of the cheapest options available for simple tasks.

What This Looks Like in Practice

A typical customer support agent conversation uses 2,000 to 4,000 input tokens (system prompt + conversation history + retrieved context) and generates 300 to 800 output tokens. Using Claude Sonnet, that is roughly $0.01 to $0.02 per conversation. At 10,000 conversations per month, your LLM API cost is $100 to $200. That sounds manageable until you factor in multi-turn conversations, tool calls that require additional LLM invocations, and retry logic. In practice, a support agent making 3 to 5 LLM calls per conversation with Sonnet costs $0.05 to $0.15 per conversation, or $500 to $1,500 per month at 10,000 conversations.

If you are using Opus for complex reasoning steps within those conversations, the cost can triple. This is why model routing is not optional at scale.

LLM APIs get all the attention, but infrastructure costs add 20% to 40% on top of your API spend. These are the line items that show up on your AWS, GCP, or Azure bill every month.

Vector Database ($50 to $500/month)

If your agent uses RAG (retrieval-augmented generation), you need a vector database to store and search document embeddings. Pinecone starts at $70/month for a basic pod. Weaviate Cloud runs $25 to $300/month depending on storage and query volume. Qdrant Cloud starts around $30/month. Self-hosted pgvector on a dedicated instance costs $50 to $200/month for compute and storage. For most production agents processing fewer than 100,000 documents, a managed pgvector instance at $50 to $100/month is sufficient and avoids vendor lock-in.

Compute for Agent Runtime ($20 to $300/month)

Your agent code needs to run somewhere. Serverless options like AWS Lambda, Google Cloud Run, or Vercel Functions are cost-effective for agents with variable traffic. At low volume (under 50,000 invocations per month), you are looking at $20 to $50/month. At moderate volume (50,000 to 500,000 invocations), $50 to $150/month. For high-volume or latency-sensitive agents, a dedicated container on ECS, Cloud Run, or a small Kubernetes cluster runs $100 to $300/month.

Memory and State Storage ($10 to $100/month)

Agents that maintain conversation history, user preferences, or long-term memory need persistent storage. Redis for session state and short-term memory costs $15 to $50/month on managed services like Upstash or Redis Cloud. PostgreSQL or DynamoDB for long-term memory and conversation logs adds $10 to $50/month. If your agent uses a dedicated memory framework like Mem0 or Zep, their cloud services start at $20 to $50/month.

External Tool Execution ($0 to $200/month)

Agents call external APIs as part of their workflows: search engines (Tavily, SerpAPI at $50 to $100/month), email sending (SendGrid at $15 to $50/month), CRM APIs (Salesforce, HubSpot API limits), calendar APIs, and database queries. Each tool integration carries its own cost. A sales agent calling Clearbit for lead enrichment at $0.05 per lookup adds $250/month at 5,000 lookups. These costs are easy to overlook and hard to predict until you are in production.

Running an AI agent without observability is like operating a server without logging. You will not know when things go wrong until customers complain, and by then you have burned through budget on failed or low-quality responses.

LLM Observability Platforms

Helicone is one of the most popular options for LLM monitoring. The free tier covers 100,000 requests per month, which is enough for early-stage agents. The Pro plan at $80/month adds advanced analytics, custom dashboards, and alerting. LangSmith (by LangChain) offers a free tier for development and a $39/month Plus plan with production-grade tracing and evaluation tools. Braintrust charges based on usage, starting around $50/month for moderate volume. Arize Phoenix is open-source and can be self-hosted for the cost of compute alone.

What You Need to Monitor

• Cost per conversation/task: Track this daily. If your average cost per conversation spikes from $0.08 to $0.25, you need to know immediately.
• Latency: P50 and P99 response times. Slow agents lose users. Target under 3 seconds for interactive agents.
• Token usage: Input and output tokens per request, broken down by model. This is where you catch prompt bloat and unnecessary context stuffing.
• Error rates and fallback triggers: How often does your agent fail, retry, or escalate? A healthy production agent should have a sub-2% error rate.
• Quality scores: Automated evaluation using LLM-as-judge, user feedback signals, or domain-specific metrics. Quality degradation is a cost problem because low-quality responses lead to retries and escalations.

Budget Alerts

Every production agent should have spend alerts configured at 80% and 100% of your monthly budget. Anthropic and OpenAI both support usage limits in their dashboards. Helicone and LangSmith can alert on anomalous spending patterns. A runaway loop or prompt injection attack can generate thousands of dollars in API calls in minutes. Budget caps are not optional.

Theory is useful, but real numbers are better. Here are three production agent archetypes with detailed monthly cost breakdowns based on systems we have built and operated.

Customer Support Agent: $800 to $3,000/month

Handles 10,000 conversations per month. Uses RAG to search a knowledge base of 5,000 documents. Escalates to human agents when confidence is low. Multi-turn conversations averaging 4 exchanges per session.

• LLM API (Claude Sonnet + Haiku routing): $400 to $1,500/month. Haiku handles intent classification and simple FAQs (60% of queries). Sonnet handles complex troubleshooting and multi-step resolutions.
• Vector database (pgvector on RDS): $80 to $150/month
• Compute (Cloud Run): $60 to $120/month
• Monitoring (Helicone Pro): $80/month
• Memory/state (Redis + PostgreSQL): $40 to $80/month
• Embedding generation: $10 to $30/month
• Tool APIs (Zendesk, internal APIs): $50 to $100/month

Sales SDR Agent: $200 to $1,000/month

Sends personalized outbound emails to 3,000 leads per month. Researches each prospect using web search and LinkedIn data. Handles initial replies and books meetings. Lower volume but higher per-request cost due to research steps.

• LLM API (Claude Sonnet for personalization, Haiku for classification): $100 to $500/month
• Web search API (Tavily/SerpAPI): $50 to $150/month
• Lead enrichment (Clearbit/Apollo): $50 to $150/month
• Compute (Lambda): $20 to $40/month
• Email sending (SendGrid): $15 to $30/month
• Monitoring (LangSmith Plus): $39/month

Coding Assistant Agent: $50 to $500/month per Developer

Integrated into the development workflow via IDE plugin or CLI. Handles code review, bug detection, test generation, and documentation. Usage is bursty, with heavy use during feature development and minimal use during meetings and planning.

• LLM API (Sonnet for code gen, Haiku for linting/formatting): $30 to $300/month per developer
• Codebase indexing and vector search: $10 to $50/month
• Compute: $10 to $50/month
• Monitoring: $20 to $50/month (shared across team)

The wide ranges reflect the difference between a well-optimized agent and one that has not been tuned. An unoptimized customer support agent that sends full conversation history plus 10 RAG chunks to Claude Opus on every turn can easily hit $5,000 to $8,000/month at the same volume.

To make budgeting easier, here is a consolidated view of monthly costs at three different scale tiers. These assume a general-purpose business agent (customer support, sales, or operations) with RAG, tool use, and monitoring.

Starter Tier: Under 5,000 Requests/Month ($200 to $600/month)

• LLM API: $50 to $250
• Vector DB: $30 to $50 (pgvector on small instance)
• Compute: $20 to $50 (serverless)
• Monitoring: $0 to $50 (free tiers)
• Storage/Memory: $10 to $30
• Tools/APIs: $20 to $50

Growth Tier: 5,000 to 50,000 Requests/Month ($600 to $3,000/month)

• LLM API: $250 to $1,500
• Vector DB: $50 to $200
• Compute: $50 to $200
• Monitoring: $50 to $150
• Storage/Memory: $30 to $100
• Tools/APIs: $50 to $200

Scale Tier: 50,000 to 500,000 Requests/Month ($3,000 to $15,000/month)

• LLM API: $1,500 to $8,000
• Vector DB: $200 to $500
• Compute: $200 to $500
• Monitoring: $100 to $300
• Storage/Memory: $50 to $200
• Tools/APIs: $100 to $500

At the Scale tier, LLM API costs dominate everything else. This is the point where aggressive optimization becomes a business requirement, not a nice-to-have. A 40% reduction in LLM costs at this tier saves $600 to $3,200 per month.

Every production agent should implement at least three of these optimization strategies. The compounding effect is significant: model routing alone saves 40 to 50%, caching adds another 20 to 30%, and prompt optimization contributes 10 to 20%. Combined, you can reduce your monthly LLM spend by 60 to 70%.

Model Routing (Save 40 to 50%)

Route each request to the cheapest model that can handle it. Use Haiku or GPT-4o Mini for classification, intent detection, simple extraction, and formatting. Use Sonnet or GPT-4o for reasoning, summarization, and content generation. Reserve Opus for multi-step planning, complex analysis, and tasks where accuracy is worth the premium. A well-tuned router sends 60 to 70% of traffic to the cheapest tier. Our model routing guide walks through the implementation in detail.

Semantic Caching (Save 20 to 40%)

Many agent queries are semantically similar. "How do I reset my password?" and "I forgot my password, how do I change it?" should return the same cached response. Implement semantic caching using embeddings and a vector similarity threshold of 0.95 to 0.98. Customer support agents typically see 30 to 50% cache hit rates. Sales agents see 15 to 25%. Even a 25% hit rate cuts your LLM spend by 25%, and the cache lookup costs fractions of a cent.

Prompt Optimization (Save 10 to 20%)

Audit your system prompts quarterly. Most prompts grow over time as developers add instructions to handle edge cases. A prompt that started at 500 tokens can balloon to 2,000 tokens without anyone noticing. Compress your system prompts. Remove redundant instructions. Use concise formatting directives instead of verbose explanations. For RAG agents, limit retrieved context to the top 3 to 5 most relevant chunks instead of sending 10 to 15. Every token in the input costs money on every single request.

Request Batching (Save 10 to 15%)

If your agent processes items in bulk (analyzing support tickets, scoring leads, generating reports), batch multiple items into a single LLM call. Processing 10 emails in one call is cheaper than making 10 separate calls because you pay for the system prompt and instructions only once. Batching also reduces latency for batch operations.

Context Window Management

For multi-turn conversations, do not send the full conversation history on every turn. Summarize older exchanges into a compact context block. A 20-turn conversation with full history can use 8,000+ input tokens per turn. Summarizing turns older than 5 exchanges into a 500-token summary keeps input tokens predictable and costs stable.

Before deploying any agent to production, build a cost model. Estimate your monthly request volume, average tokens per request (input and output), your model mix (what percentage goes to each model tier), and your infrastructure requirements. Multiply it out and add a 30% buffer for the first three months while you tune and optimize.

Here is a simple formula to estimate your monthly LLM cost: (monthly requests) x (average input tokens per request) x (cost per input token) + (monthly requests) x (average output tokens per request) x (cost per output token). Run this calculation for each model tier separately, then sum them. This gives you the LLM API portion. Add 25 to 40% for infrastructure, monitoring, and tool costs to get your total monthly spend.

Start with conservative estimates and optimize aggressively in the first month of production. Most teams find they can cut their initial monthly costs by 40 to 60% within the first 6 to 8 weeks through the optimization strategies covered above. The key is to measure everything from day one. You cannot optimize what you do not measure.

If you are planning a production AI agent and want a precise cost estimate tailored to your use case, volume, and quality requirements, we build and operate agents for companies ranging from early-stage startups to enterprise. Book a free strategy call and we will walk through the numbers with you.