Amazon Bedrock AgentCore bills across 12 separate components, but two of them — Memory and Runtime — carry roughly 80% of the AgentCore line items in a typical conversational workload. Runtime costs $0.0895 per vCPU-hour and $0.00945 per GB-hour; Memory costs $0.25 per 1,000 new events, $0.50 per 1,000 retrievals, and $0.75 per 1,000 long-term records stored per month (AWS AgentCore pricing). Model tokens bill separately through Amazon Bedrock, and whether they dominate your invoice or not depends entirely on which model you picked — the arithmetic below shows both outcomes.

Scope note: this article is SKU mechanics only. For the build-plus-twelve-month-run picture across agent archetypes, see AI agent build and run cost in 2026. For per-token model math, see AWS Bedrock pricing explained.

What are all 12 billable AgentCore components?

AgentCore's pricing page splits its charges across five distinct billing patterns. Mixing them up is the single most common source of bad forecasts: a spreadsheet that models everything as "per session" will be wrong on Memory (a compounding stock), and a spreadsheet that models everything as "per request" will be wrong on Runtime (wall-clock and CPU-dependent).

Gateway is where your MCP servers land; if you are still deciding how to expose tools, where MCP servers fit on AWS covers the architecture rather than the meter.

Which two AgentCore components drive most of the bill?

Memory and Runtime. In a reference conversational agent, Memory takes ~64% of the AgentCore subtotal and Runtime ~16% — together 80.3%. Here is the workload, stated explicitly so you can swap in your own numbers.

Three things fall out of this that the pricing page will not tell you.

A memory retrieval costs 100× a Gateway tool call. $0.50 per 1,000 retrievals is $0.0005 each; $0.005 per 1,000 Gateway invocations is $0.000005 each. Teams instinctively optimise tool-call chattiness and leave retrieval fan-out alone. It should be the reverse.

Self-managed long-term memory is a 67% cut. $0.25 per 1k records/month versus $0.75 for built-in extraction strategies. If you already own your summarisation logic, that is the single largest available discount in the AgentCore catalogue.

Evaluations is the sleeper. At 10% sampling it costs $0.001320 per session — already within 3% of your entire Runtime line. Raise sampling above ~10.4% and Evaluations overtakes Runtime. Run built-in evaluators on 100% of traffic and Evaluations alone ($0.0132/session) exceeds every other AgentCore component combined by 1.5×. Batch evaluation's 25% discount exists precisely because AWS expects this to hurt.

Why do naive vCPU-hour estimates overshoot AgentCore Runtime cost?

Because agents spend most of their session doing nothing, and AgentCore does not charge CPU for it. AWS states in the AgentCore FAQ that agentic workloads "typically spend 30-70% of time in I/O (input/output) wait periods for LLM responses, tool calls, or database queries," and that with AgentCore Runtime, "I/O wait and idle time is free—you're only charged for actual resource consumption calculated at per-second increments."

If you estimate sessions × wall-clock × vCPU × $0.0895, you are billing yourself for time AWS gives away:

The counterweight matters just as much: memory is billed on peak consumption across the full session lifetime, idle or not. CPU is metered on use; GB-hours are metered on wall-clock. For a long, memory-fat session the GB-hour line wins outright — an 8 GB agent running a 10-minute session at 70% idle pays $0.004475 in CPU and $0.0126 in memory, making memory 2.8× the CPU cost.

Practical consequence: right-sizing peak memory allocation is a bigger lever than shaving execution time, and the usual instinct (optimise the hot path) is aimed at the smaller number.

What does an AgentCore bill look like at 100, 10,000 and 1,000,000 sessions?

Same reference workload, scaled. Token lines assume 25,000 input and 3,000 output tokens per session, priced against Claude Sonnet on Bedrock at $6.00 / 1M input and $30.00 / 1M output, and against Amazon Nova Lite at approximately $0.06 / 1M input and $0.24 / 1M output (Amazon Bedrock pricing).

Read the pilot column carefully: at 100 sessions per month your AgentCore bill is under a dollar, and CloudWatch observability is your largest AgentCore-attributable cost. Proof-of-concept budgets fail on engineering time, not SKUs. Do not let a $0.86 forecast anchor your production expectations.

One caveat on the 1M column: long-term memory storage is cumulative. Two million new records a month means month two carries month one's stock as well. At $0.75 per 1,000 records/month with no eviction policy, that $1,500 line becomes $18,000/month by month twelve. Write a TTL before you write the forecast.

Do model tokens or AgentCore SKUs dominate your bill?

It depends on the model, and the swing is enormous. AWS publishes no official infrastructure-versus-inference split, so treat any single percentage you read as unverified — including ours. What the arithmetic above does support:

• With Claude Sonnet at 1M sessions: $240,000 tokens versus $8,548 AgentCore. Tokens are 96.6% of spend. AgentCore is a rounding error and optimising it is wasted effort.
• With Nova Lite at 1M sessions: $2,220 tokens versus $8,548 AgentCore. AgentCore is 79.4% of spend. Now every retrieval and every evaluation sample is worth arguing about.

The practical rule: the cheaper your model, the more AgentCore's platform SKUs matter. Teams that migrate to a small model to cut costs and then find savings disappointing have usually run into exactly this inversion. Token-level optimisation — caching, batch mode, context trimming — is covered in AWS Bedrock pricing explained.

When is AgentCore the wrong answer?

High-QPS stateless inference. If your "agent" is a single model call behind an API with no memory, no tools and no multi-turn state, you are paying for session isolation you never use. Lambda or a container behind an ALB is cheaper and simpler.

Small-model, very-high-volume workloads. As the Nova Lite column shows, AgentCore SKUs can become the majority of the bill. At that point, self-hosting the orchestration layer starts to pencil out — the trade-off is laid out in OSS versus managed multi-agent platform pricing.

Long-running batch work on Instances. The 12% management fee on EC2 On-Demand rates buys you managed session lifecycle. If you already operate ECS or EKS competently, that is margin you may not need to pay.

Portability requirements. AgentCore Memory, Gateway and Policy are proprietary interfaces. Migrating off them is real work. Check regional availability against your data-residency obligations before committing, since AgentCore is not offered in every AWS region.

We design, build and operate agent platforms on AWS — including the unglamorous parts: memory TTL policies, evaluation sampling strategies, and the FinOps tagging that makes a per-session cost number trustworthy. If you have a forecast you want stress-tested against a real production bill, we are happy to look at your spreadsheet.

FAQ

How much does Amazon Bedrock AgentCore cost per session?

For a typical 90-second conversational agent with 1 vCPU, 2 GB peak memory, 12 tool calls and 12 memory operations, the AgentCore SKUs total roughly $0.0085 per session — excluding model tokens and CloudWatch observability. Memory operations account for about 64% of that figure and Runtime about 16%. Your number will move most with retrieval count and evaluation sampling rate, not with tool-call volume.

Is AgentCore Runtime billed while the agent waits for the LLM?

CPU is not; memory is. AWS states that with AgentCore Runtime, "I/O wait and idle time is free—you're only charged for actual resource consumption calculated at per-second increments." However, memory charges are based on peak consumption across the session lifetime, so GB-hours continue accruing during idle wait. At 60% I/O wait, a naive full-wall-clock vCPU estimate overstates your CPU line by 2.5×.

Why is AgentCore Memory more expensive than Runtime?

Because memory operations are priced per record, not per second, and agents generate many records per session. A single retrieval at $0.50 per 1,000 costs $0.0005 — one hundred times a Gateway tool invocation at $0.005 per 1,000. Switching long-term storage from built-in strategies ($0.75 per 1,000 records/month) to self-managed ($0.25) cuts that line by 67% if you already own your extraction logic.

Does AgentCore have a free tier?

There is no dedicated AgentCore free tier or trial period. AWS states that the AgentCore harness is "free of extra charge — you pay only for the underlying resources you use," and that new AWS customers receive up to $200 in Free Tier credits. Several components do carry standing free allowances, notably Agent Registry (first 5,000 records, 1M Search invocations and 2M List/Get invocations per month) and Identity when consumed through Runtime or Gateway.

How is AgentCore Gateway pricing calculated for MCP servers?

Gateway bills $0.005 per 1,000 API invocations, and every MCP operation counts — including ListTools and Ping, not just CallTool. Semantic tool discovery via the Search API is five times more expensive at $0.025 per 1,000, and indexed tools carry a standing $0.02 per 100 tools per month. Data egress to customer VPCs adds $0.006 per GB. In practice Gateway is the cheapest component in most agent workloads, typically under 1% of the AgentCore subtotal.

What is AgentCore Evaluations pricing, and when does it become the biggest line?

Built-in evaluators cost $0.0024 per 1,000 input tokens and $0.012 per 1,000 output tokens; custom evaluators cost $1.50 per 1,000 evaluations; batch evaluation carries a 25% discount. Because the cost scales with sampling rate rather than session count, a 10% sample sits roughly level with Runtime — but at 100% sampling, Evaluations can exceed every other AgentCore component combined. Set your sampling rate deliberately and move continuous evaluation to batch mode.