AWS Bedrock AgentCore Pricing: What It Costs and 5 Alternatives (2026)

Twelve billable AgentCore capabilities, a thirteenth meter on the model bill, one free harness, and an invoice that arrives in pieces. Here is every line item, where it escalates, and what to run instead.

The first AgentCore invoice is never the number you modelled. Not because AWS hid anything, but because you priced the runtime and forgot that twelve other services were also counting.

If that sounds like a lot of meters for one agent answering one question, you have already found the problem this article is about.

Every figure below was pulled from AWS's own pricing page and re-verified there on September 16, 2026. AgentCore reprices often, so check before you commit budget.

AWS Bedrock AgentCore pricing, every line item

Two things missing from that table on purpose. Foundation model inference is not included anywhere in it, and it is usually the largest line on the bill. Network data transfer bills at standard EC2 rates, with egress to your own VPC at $0.006 per GB. If you have not priced the model side yet, our comparison of the cheapest AI models for agents covers the tier that sits under every row above.

What each line item is actually charging you for

Runtime is the one people understand. It bills per second on actual CPU consumption and peak memory, with a 128MB minimum. The genuinely clever part is that idle time is free: agents spend 30 to 70% of a session waiting on model responses and tool calls, and AgentCore does not bill CPU during that wait. AWS's own comparison says pre-allocated compute would cost up to 3.3x more on CPU for the same workload.

Gateway turns your APIs into agent-callable tools and bills per operation. Listing tools, invoking a tool, health checks, all of it counts.

Memory splits three ways, and this is where the config file becomes a pricing decision. Short-term memory bills per event created. Long-term storage bills per record per month, and the rate triples depending on which extraction strategy you pick.

Built-in memory strategies cost $0.75 per 1,000 records. Built-in with override, or self-managed, costs $0.25. Same feature, 3x the price, one dropdown.

Policy is almost free per unit, at $0.000025 per authorization request, which is exactly why nobody watches it and why it is fine.

Evaluations is the opposite. It bills on tokens processed during evaluation, and evaluation prompts carry the whole conversation.

Where the costs escalate, using AWS's own examples

You do not have to take my word on any of this. AWS publishes worked examples, and they are more revealing than any third-party estimate.

Runtime scales gracefully. Ten million sessions a month, 60 seconds each, works out to $7,235. For ten million sessions that is genuinely cheap.

Evaluations does not. AWS's example evaluates 15,000 interactions a month, 5,000 from a CI/CD pipeline plus 10,000 sampled from production at 2%, using three built-in trace-level evaluators and one custom one. It lands at $1,804.50. That is $0.12 per interaction against $0.00072 in the runtime example, so evaluating an interaction costs roughly 165 times what running it did. Sampling rules exist for a reason.

Web Search is the line item that ambushes people. At $7.00 per 1,000 queries, AWS's own market-research example runs 200,000 queries a month and spends $1,400 on search against $3.00 for the 600,000 tool calls that carried them. One SKU is 99.8% of a $1,403 bill.

Gateway punishes semantic tool search. Their HR assistant example runs 50M interactions, which becomes 50M Search calls and 200M InvokeTool calls, and pays $2,250.04 a month. Of that, $1,250 is Search API at $0.025 per 1,000 and $1,000 is the four-times-larger pile of actual tool invocations at $0.005 per 1,000. Invoking tools is cheap. Finding them is not.

Observability leaves the AgentCore bill entirely. Telemetry lands in CloudWatch and bills at CloudWatch rates, which means the cost of watching your agent shows up on a different page of the invoice from the agent itself.

Here is the pattern. AgentCore's compute pricing is honestly good. The expensive parts are the surrounding services: search, evaluation, and tool discovery. Those are exactly the services a naive cost model leaves out. Our breakdown of what an AI agent actually costs to run covers the token side that sits underneath all of it.

The thirteenth meter: token amplification on the model bill

Every row in that table is an AgentCore meter. The biggest number on the invoice usually is not one of them. Foundation model inference bills through Bedrock on its own rate sheet, and the reason it overshoots forecasts has nothing to do with the rate. It is the call count.

You estimate token cost from the user's prompt and the agent's final answer, because those are the two things you can see. That is not how an agent runs. One query fans out into internal calls: parse the question, pick a tool, read the result, decide again, summarise. Each of those calls resends the system prompt, the tool definitions, and whatever context has accumulated. Published measurements of agent workloads put the multiplier at roughly 4x a plain chat turn for a single agent, and several times that again for multi-agent setups where every member carries its own copy of the context.

Work it through. A user asks "what were our top three deals last quarter?" You budget 500 input tokens and 200 output, so 700. The agent actually makes four internal calls, one to parse the question, one to query the knowledge base, one to process the results, one to format the answer, and consumes somewhere between 2,000 and 4,000 tokens end to end. That is 3x to 6x your estimate on a question you would have called simple.

At 10,000 queries a month on Claude Sonnet 4.6 rates of $3 per million input and $15 per million output, the budgeted 700 tokens works out to $45. Hold the same rough 5-to-2 input-output split and the real 2,000 to 4,000 tokens costs $128 to $257. Same agent, same questions, three to six times the model bill, and none of it appears on any AgentCore meter.

The fix is not a cheaper platform. It is counting the internal calls before you forecast, which our guide to cutting agent token costs with context engineering works through step by step.

Five alternatives to AWS Bedrock AgentCore

1. BetterClaw, if you want a number instead of a model

We build this, so weigh it accordingly. Free is $0 with 1 agent, 100 credits a month, 3 connectors, and 7-day memory, no credit card. Basic is $19 a month for the same single agent with 500 credits and 10 connectors. Pro is $49 a month, or $39 on annual billing, for 5 agents and 12,000 credits. Business is $149 for 25 agents.

The relevant difference is not the price, it is the shape. There is no per-invocation meter, no memory record fee, no separate charge for finding your own tools. You bring your own key across 28 model providers and pay them directly with no markup on inference, which is the one cost AgentCore also does not mark up. If you want the head-to-head on setup time and security rather than the meter list, we wrote AgentCore vs BetterClaw separately.

What you give up: AWS-native IAM integration, VPC isolation on their terms, and the ability to expense it against an existing AWS commit. If your security team requires the agent to live inside your account, this is the wrong row.

2. Google Vertex AI Agent Builder, if you are already on GCP

Rebranded as the Gemini Enterprise Agent Platform in 2026, though the services are unchanged. Agent Runtime (formerly Agent Engine) is $0.085 per vCPU-hour and $0.009 per GiB-hour, with 50 vCPU-hours free each month, which undercuts AgentCore slightly. Sessions and Memory Bank moved to $0.30 per GiB-month of storage plus metered operations on September 1, 2026. Agent Search (formerly Vertex AI Search) runs $1.50 to $4.00 per 1,000 queries, which is meaningfully cheaper than AgentCore's $7.00 web search. Every meter is broken down in our Vertex AI pricing guide.

The free tier is the real draw for evaluation: 50 vCPU-hours and 100 GB-hours a month, plus $300 in credits for 90 days, plus an Express Mode that runs up to 10 agent engines without enabling billing. We compared the two platforms directly in our BetterClaw versus Vertex AI writeup.

Same architecture, same forecasting problem, different cloud.

3. n8n, if your workload is scheduled rather than autonomous

Community Edition is free with unlimited executions on a server you run, typically $5 to $7 a month. Cloud starts at €24 for 2,500 executions and €60 for 10,000, with unlimited workflows and users on every tier.

The honest caveat: n8n is workflow automation, not autonomous agents. No persistent memory across runs, no trust levels, no agent deciding its own next step. If what you actually need is "run this sequence when X happens," you are massively overpaying on AgentCore for capabilities you are not using.

4. LangGraph with LangSmith, if you want maximum control

The framework is free and open source. LangSmith, the observability layer, is where you pay: a free Developer tier with 1 seat and 5,000 base traces a month, then $39 per seat per month with 10,000 base traces included and pay-as-you-go beyond that, metered in LangChain Storage Units at $1.00 each.

Watch the trace accounting. Trace counts include every run inside a chain, not just top-level calls, so instrumenting per conversation turn instead of per session multiplies your bill by however many turns a conversation runs. A team of ten pays $390 in seats before a single trace lands.

5. CrewAI, if you have Python engineers and a multi-agent problem

The open-source framework is free, MIT licensed, and past 54,000 GitHub stars with two billion agent executions reported in the past year. The managed platform is a different story: the free Basic tier caps at 50 executions a month, and the $25 Professional tier disappeared from the public pricing page in spring 2026 along with the published overage rate.

What is public now is "Free" and "contact us." Reported enterprise contracts run well into five figures a year. Excellent framework, no longer a self-serve product.

Worth saying plainly, since we are one of the five: if the thing you actually want is an agent running by tonight without an architecture review, our free plan gets you one agent with no credit card and your own API key, so the token spend stays visible and unmarked-up from the first minute.

Migration notes, in the order things break

Your tool definitions move first, and they move cleanly. Gateway exposes tools over MCP, and every alternative here speaks MCP or has a connector equivalent. This is the easy part.

Memory does not port. AgentCore Memory stores short-term events and extracted long-term records in AWS's format. Every alternative has its own memory model. Plan to re-seed context rather than migrate it, and treat that as a feature, since most teams discover their long-term memory was 80% noise.

Identity is the real work. If you have wired AgentCore Identity to Cognito, Okta, or Entra for delegated access to third-party tools, you are rebuilding that flow. Managed platforms handle this with OAuth connectors, which is faster to set up and less flexible.

Observability changes shape entirely. You are moving from CloudWatch spans to whatever the new platform gives you. Export what you need for compliance before you turn anything off.

Budget a parallel run. Two weeks of both, same traffic, then compare invoices. The team that skips this is the team that discovers in month two that their new platform meters something the old one gave away. The same discipline applies whether you are leaving a hyperscaler or moving off a self-hosted OpenClaw setup, where the hidden cost is engineering hours rather than SKUs.

The verdict, by what you are actually building

Prototype or internal tool, under 10,000 tasks a month. Take a free tier and stop reading pricing pages. BetterClaw free, Vertex Express Mode, or n8n Community all cost nothing and none of them will surprise you.

Small team shipping something real. Flat pricing. The forecasting overhead of a thirteen-meter bill is a real cost even when the bill itself is small, and at this scale you do not have a FinOps person to absorb it.

High-volume production, already on AWS. Stay on AgentCore. The runtime pricing is genuinely competitive, idle time being free is a real structural advantage, and if you are on an AWS commit the discount math probably beats everything else here. Just sample your evaluations and watch Web Search.

Regulated, needs VPC isolation and audit trails. AgentCore or Vertex. The managed no-code platforms, ours included, are the wrong answer when the agent legally has to run inside your account.

Anything scheduled rather than autonomous. n8n, and you will save roughly 90%. Our rundown of the cheapest production agent stack for 2026 works through where that saving actually comes from.

If any of this resonated, start free with BetterClaw. One agent, 100 credits a month, no credit card, bring your own key with zero markup on inference. Pro is $49 a month for five agents and 12,000 credits, or $39 a month on annual billing, and every paid plan carries a 7-day money-back guarantee. Full pricing is here, all of it on one page, no calculator required.

Here is the thing worth carrying out of this. AgentCore is not expensive. It is unpredictable, and those are different complaints with different solutions. AWS built modular pricing because modular pricing is honest: you pay for exactly the capabilities you turn on. The catch is that honesty in a pricing model transfers the forecasting work to you, and forecasting is a skill most teams building their first agent have not developed yet. Pick the billing model that matches how much of that work you can afford to do.

Frequently Asked Questions

What is AWS Bedrock AgentCore pricing based on?

AgentCore uses consumption-based pricing across twelve separate capabilities with no subscription or minimum fee. Runtime, Browser, and Code Interpreter bill at $0.0895 per vCPU-hour and $0.00945 per GB-hour on active consumption only, and Runtime also offers dedicated instances at EC2 On-Demand plus a 12% management fee. Gateway, Memory, Identity, Policy, Evaluations, Web Search, Agent Registry, and Payments each have their own units, Observability bills through CloudWatch, and foundation model tokens are a thirteenth meter billed separately through Bedrock.

How does AgentCore pricing compare to Vertex AI Agent Builder?

Both are usage-based with no subscription, and the runtime rates are close: $0.0895 per vCPU-hour on AgentCore against $0.085 on Vertex. Vertex is cheaper on search, at $1.50 to $4.00 per 1,000 queries versus AgentCore's $7.00 per 1,000 web search queries, and its free tier is more generous with 50 vCPU-hours monthly plus $300 in credits. The tradeoff is which cloud you get locked into.

How do I estimate my AgentCore bill before I deploy?

Price one completed task end to end rather than one request: count runtime seconds, gateway invocations, memory events, memory retrievals, policy checks, and model tokens for a single task, then multiply by monthly volume. Add CloudWatch charges for observability and any evaluation sampling separately. AWS publishes worked examples per capability on its pricing page, which are the most reliable starting point available.

What is token amplification, and why does it break AgentCore forecasts?

Token amplification is what happens when one user query triggers several internal model calls, to parse the question, pick a tool, read the result, and summarise, each one resending the system prompt and tool definitions. Published measurements put single-agent workloads at roughly 4x the tokens of a plain chat turn, and multi-agent setups considerably higher. A query you budget at 700 tokens routinely consumes 2,000 to 4,000, and because model inference bills through Bedrock rather than AgentCore, the overage shows up on a different part of the invoice from every meter you were watching.

Is AWS Bedrock AgentCore cheaper than a flat-rate agent platform?

It depends entirely on volume. At low volume AgentCore is cheaper, since you pay close to nothing for an idle agent while a flat plan charges every month regardless. At steady production volume a flat plan usually wins, and it always wins on forecasting effort. New AWS customers get up to $200 in Free Tier credits, which covers a decent evaluation period either way, and Agent Registry has a standing monthly allowance of 5,000 records, 1M searches and 2M List/Get calls.

Is a managed agent platform secure enough to replace AgentCore for enterprise workloads?

For most workloads yes, but ask specific questions rather than accepting a compliance badge: per-agent execution isolation, encrypted credential storage, an approval gate before destructive actions, and an audit trail you can export. AgentCore's real advantage is that the agent runs inside your own AWS account under your existing IAM and VPC controls. If a regulator or your security team requires that, no third-party platform substitutes for it regardless of its security features.