AWS Bedrock AgentCore Pricing (Oct 2026): 12 Meters, What It Costs and 5 Alternatives

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 October 13, 2026. AgentCore reprices often (two meters changed since our September check), so check before you commit budget.

AWS Bedrock AgentCore pricing, every line item

AWS now lists thirteen AgentCore features. Twelve of them bill on a meter of their own. The thirteenth, Optimization, has no meter yet: Insights is free during its public preview, Recommendations are free, and A/B tests bill the Runtime, Gateway and Evaluations they consume.

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 and memory consumption, with a 128MB memory minimum. The genuinely clever part is that idle CPU 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.

Runtime now comes in two microVM generations. v1 keeps the $0.0895 per vCPU-hour rate. v2 costs more per unit, $0.1276 per vCPU-hour and $0.0169 per GB-hour, but reclaims idle memory after 120 seconds within a session, which is what the higher unit price buys you on long sessions that mostly wait. A committed baseline at $0.0997 and $0.0132 is due by October 2026.

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 used to bill per event created; since October 6, 2026 it bills by volume instead, at $1.00 per GB ingested, $0.20 per GB retrieved and $0.10 per GB-month stored, so chatty agents with small events got cheaper and agents that stuff large payloads into events got more expensive. 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. AWS's current Runtime v2 example runs a customer support agent for one million sessions a month, ten minutes each with 90% of that spent waiting, and lands at $6,703: about $0.0067 a session.

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.0067 per session in the runtime example, so evaluating an interaction costs roughly 18 times what running a full ten-minute session 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. The head-to-head on setup time, security and a 10,000-conversation bill is in the AgentCore vs BetterClaw table further down this page.

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 compare it with seven other options in our Vertex AI Agent Builder alternatives guide.

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.

AgentCore vs BetterClaw

Here is how AgentCore compares with BetterClaw, the first alternative above, on the dimensions that actually decide it.

The rows where AgentCore wins are real. If your compliance team mandates GovCloud, or you need agents that pay for APIs on their own, the conversation is over. Everywhere else the gap is time: three weeks of engineering setup at $100 an hour is about $12,000 in labour, more than twenty years of BetterClaw Pro.

Frequently Asked Questions

What is AWS Bedrock AgentCore pricing based on?

AgentCore uses consumption-based pricing across twelve separately metered capabilities with no subscription or minimum fee. Runtime v1, Browser, and Code Interpreter bill at $0.0895 per vCPU-hour and $0.00945 per GB-hour, Runtime v2 at $0.1276 and $0.0169, and CPU is not billed while the agent waits on I/O, 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 on AgentCore's v1 microVMs: $0.0895 per vCPU-hour against $0.085 on Vertex. AgentCore's newer v2 microVMs cost $0.1276. 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 much does AgentCore cost per month for one agent?

For the 10,000-query support agent worked through on this page, expect roughly $195 to $325 a month, almost all of it model tokens. The model bill on Claude Sonnet 4.6 rates comes to $128 to $257 once token amplification is counted. Runtime adds about $67, using AWS's own Runtime v2 figure of $0.0067 per ten-minute session. Gateway calls at $0.005 per 1,000, short-term memory, and CloudWatch for observability add small amounts on top. Web Search ($7.00 per 1,000 queries) and Evaluations are the lines that can push one agent past that range. Prices checked October 13, 2026.

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, short-term memory gigabytes, memory records and 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.