Twelve billing components, token amplification you didn't budget for, and the alternatives most teams don't know about.
A startup founder I know budgeted $200 a month for his AI agent infrastructure on AWS. He'd read the AgentCore pricing page, done some napkin math on token costs, and felt confident.
His first month's bill was $847. Not because he'd built something complex. Because he didn't know about the twelve separate billing components, the token amplification from internal model calls, or the memory retention charges that compound silently even when user counts stay flat.
Here's what nobody tells you about AWS Bedrock AgentCore pricing. The per-token model costs everyone focuses on are typically only 30 to 50 percent of the total bill. The other 50 to 70 percent comes from infrastructure components most people don't price until they see the invoice.
What AgentCore actually charges for (all twelve lines)
Bedrock AgentCore bills across twelve distinct line items. Eleven are AgentCore-specific. The twelfth, the underlying Bedrock model invocation cost, is metered separately and typically dwarfs all other AgentCore lines combined.
Here's the breakdown that matters:
Runtime: $0.0895 per vCPU-hour and $0.00945 per GB-hour, billed at per-second granularity. CPU is charged on active use only, so I/O wait while the model thinks is free on the CPU meter. This sounds cheap until you run the math on an always-on agent.
Gateway: $0.005 per 1,000 tool invocations, plus semantic tool indexing costs. Every time your agent calls a tool, this meter ticks.
Memory: per event stored and per retrieval. Long-term memory retention compounds silently while user counts stay flat. This is the line item that surprises people most, because it grows even when nothing else about your usage changes.
Policy: $0.000025 per authorization request. Small per-unit, adds up at scale.
Guardrails: $0.15 per 1,000 text units (1,000 characters) for content filters and denied topics, charged separately for each guardrail type applied.
Flows: $0.035 per 1,000 node transitions, metered daily.
Knowledge Base: per retrieval query plus embedding model costs plus optional reranking at $1.00 per 1,000 queries.
Browser, Code Interpreter: same vCPU/GB-hour rates as Runtime for browser automation and sandboxed code execution.
Model invocation: billed separately on Bedrock's per-model token rate sheet. This is the big one.
The token amplification problem nobody budgets for
This is where most people get it wrong. You estimate token costs based on the user's prompt and the agent's final response. But that's not how AgentCore works internally.
A single user query can trigger multiple internal model calls: thinking, searching, tool calling, and summarizing. Agent workflows commonly consume 4 to 8 times the tokens you would estimate from looking at the user's prompt and the final response.
A user asks your agent "What were our top 3 deals last quarter?" You estimate maybe 500 input tokens and 200 output tokens. The agent actually makes four internal calls: one to parse the question, one to query the knowledge base, one to process the results, and one to format the response. Total tokens consumed: 2,000 to 4,000. Your budget assumed 700.
Multiply that by 10,000 queries a month and the gap between your estimate and your actual bill is enormous.
What's genuinely good about AgentCore
In fairness, AgentCore isn't all cost traps. Some things it does well.
Per-second billing on Runtime means you only pay for active CPU time. If your agent spends 60% of a session waiting on model responses, that idle time is free on the CPU meter. This is better than most cloud pricing that bills by the hour regardless of utilization.
Native AWS integration is real. If your data already lives in S3, your auth runs through IAM, and your team already knows CloudFormation, AgentCore plugs into the existing stack without a separate vendor relationship.
Scale ceiling is high. AgentCore is built for enterprise throughput. If you're running thousands of concurrent agent sessions, this is infrastructure designed for that volume.
But that's not even the real problem. The real problem is that most teams building AI agents don't need enterprise-scale infrastructure. They need one to five agents handling specific workflows, and paying for twelve billing components to run them is like renting a warehouse to store a bookshelf.
5 AgentCore alternatives that are simpler and cheaper
1. BetterClaw (no-code, managed, free plan)
If you're looking at AgentCore because you want a managed agent platform, BetterClaw gives you that without the twelve billing lines. Visual builder, 200+ verified skills, 25+ OAuth integrations, and 28+ model providers with BYOK and zero inference markup.
Pricing: Free plan with one agent and every feature, no credit card. Pro at $19 per agent per month with unlimited tasks. You bring your own API keys and pay the model provider directly.
Where it fits: teams that want managed agents without AWS expertise, CloudFormation templates, or twelve-component cost forecasting. Deploys in 60 seconds versus days of AgentCore configuration.
Where it doesn't fit: organizations that require deep AWS-native integration with existing S3, IAM, and VPC infrastructure. AgentCore wins there on ecosystem fit.
2. n8n plus Ollama (self-hosted, workflow-first)
For teams that want to run AI workflows without any cloud vendor dependency, n8n's open-source workflow engine paired with Ollama for local model inference gives you a fully self-hosted stack at near-zero marginal cost.
Pricing: n8n is free self-hosted with unlimited executions. Ollama is free. Your only costs are the VPS ($5-20/mo) and whatever cloud API calls you make for tasks that need a frontier model.
Where it fits: developer teams comfortable with self-hosting who want maximum control and minimal per-query costs. Our Ollama cloud fallback guide covers the architecture for running local-first with cloud as a safety net.
Where it doesn't fit: non-technical teams, anyone who needs managed infrastructure, or use cases that require persistent agent memory (n8n is workflow automation, not an autonomous agent platform).
3. LangGraph (developer framework, maximum flexibility)
LangGraph is the developer-first option for teams that want complete control over agent architecture. It's a graph-based framework for building stateful, multi-actor applications with LLMs.
Pricing: open source. Your costs are hosting (wherever you deploy) and model inference. No per-agent or per-invocation platform fees.
Where it fits: engineering teams building custom agent architectures with specific requirements that no managed platform covers. Maximum flexibility, steep learning curve.
Where it doesn't fit: teams without Python developers, anyone who needs a quick deploy, or use cases where building the agent framework from scratch isn't justified by the requirements.
4. CrewAI (multi-agent framework, growing ecosystem)
CrewAI is a multi-agent framework with 47,000+ GitHub stars and a growing enterprise tier. It's designed around role-based agent teams where each agent has a specific function.
Pricing: open source for the framework. Enterprise tier available with managed features. Your costs on open source are hosting and model inference.
Where it fits: teams building multi-agent systems where different agents play different roles (researcher, writer, editor). Strong prototyping speed.
Where it doesn't fit: non-technical teams, anyone who doesn't want to write Python, or single-agent use cases where the multi-agent overhead isn't needed.
5. OpenRouter (model routing gateway)
If your AgentCore cost problem is primarily model inference (the 50-70% of the bill), OpenRouter gives you a single API endpoint that routes to 200+ models from OpenAI, Anthropic, Google, Meta, Mistral, and others, with per-token pricing and no monthly commitment.
Pricing: per-token, model-dependent, with a small routing markup. No platform fees.
Where it fits: teams that want to swap models without changing code, compare pricing across providers, and implement the model-routing pattern from our token cost optimization guide without building the routing layer themselves.
Where it doesn't fit: teams that need the full agent platform (memory, tools, scheduling, guardrails), not just a model gateway.
The real cost comparison at 10,000 queries a month
| Platform | Monthly cost at 10K queries | Setup time | AWS expertise needed |
|---|---|---|---|
| AgentCore | $300-900+ (12 components) | Days to weeks | Yes |
| BetterClaw Pro | $19 + LLM costs (~$30-80) | 60 seconds | No |
| n8n + Ollama | $5-20 VPS + cloud fallback | Hours | No |
| LangGraph | Hosting + LLM costs | Days (development) | No |
| CrewAI | Hosting + LLM costs | Days (development) | No |
| OpenRouter | LLM costs only (~$30-100) | Minutes | No |
The AgentCore range is wide because the final bill depends on which of the twelve components you use, how much memory retention accumulates, and how much token amplification your specific workflows generate. Most teams don't know their actual number until the first invoice arrives.
If you're spending more on forecasting your AgentCore bill than you would spend on the agent itself on a simpler platform, that's the signal.
When AgentCore is actually the right choice
Being honest: AgentCore makes sense in specific situations.
You're already deep in AWS. Your data is in S3, your auth is IAM, your team writes CloudFormation in their sleep. The twelve billing components are annoying but your team knows how to forecast AWS costs because they do it for everything else.
You need enterprise-scale concurrency. Thousands of simultaneous agent sessions with sub-second latency guarantees. That's infrastructure AgentCore is genuinely built for.
Compliance requires AWS. Your organization has a mandate to run everything on AWS. The choice is AgentCore or building your own agent infrastructure on AWS from scratch, and AgentCore is the faster path.
If none of those describe you, the twelve-component billing model is overhead you're paying for infrastructure capabilities you'll never use.
If any of this resonated and you're looking for managed agents without the complexity of forecasting twelve billing lines, give BetterClaw a try. Free plan with one agent and every feature. $19 a month per agent for Pro. Zero inference markup, BYOK, 28+ model providers, and a pricing page that fits on one screen. Your first deploy takes about 60 seconds. We handle the infrastructure. You handle the interesting part.
Frequently Asked Questions
What does AWS Bedrock AgentCore actually cost per month?
AgentCore bills across twelve separate components: Runtime ($0.0895/vCPU-hour), Gateway ($0.005/1K tool invocations), Memory (per event), Policy ($0.000025/request), Guardrails ($0.15/1K text units), Flows ($0.035/1K node transitions), Knowledge Base, Browser, Code Interpreter, Identity, Evaluations, and model invocation (billed separately). For most teams running a few agents at moderate volume, total monthly costs land between $300 and $900, though the range depends heavily on memory retention and token amplification.
How does AgentCore pricing compare to simpler alternatives?
AgentCore's twelve-component billing makes it significantly more complex and typically more expensive than alternatives for small to mid-size agent deployments. BetterClaw Pro costs a flat $19/agent/month plus direct LLM costs. Self-hosted options like n8n plus Ollama can run for $5-20/month in VPS costs. AgentCore's pricing advantage only appears at enterprise scale where the per-second billing granularity and native AWS integration offset the forecasting complexity.
What is token amplification in AWS AgentCore?
Token amplification is when a single user query triggers multiple internal model calls (thinking, searching, tool calling, summarizing), consuming 4 to 8 times more tokens than you'd estimate from the user's prompt and the agent's final response alone. This is the most common reason AgentCore bills exceed forecasts, because most cost estimates only account for the visible input/output tokens, not the intermediate calls.
Is there a free tier for AWS Bedrock AgentCore?
AgentCore itself does not have a free tier. AWS offers a general Bedrock free trial for some model invocations, but the AgentCore infrastructure components (Runtime, Gateway, Memory, Policy) are billed from first use. For a genuinely free managed agent platform, BetterClaw offers a free plan with one agent, every feature, no credit card, and no expiration.
Is AgentCore worth it for a small team building AI agents?
For most small teams (under 10 engineers, fewer than 5 agents), AgentCore's twelve-component pricing model adds complexity and cost that exceeds what simpler alternatives charge. AgentCore is designed for enterprise-scale deployments within existing AWS ecosystems. If your team doesn't already operate on AWS or need enterprise concurrency, a managed platform like BetterClaw or a self-hosted framework like CrewAI or LangGraph will typically be both cheaper and faster to deploy.
