Quick verdict
Amazon Bedrock AgentCore uses consumption-based pricing across modular services. You are not buying a flat “agent host.” The short version:
- Runtime, Browser, and Code Interpreter share active-compute style rates (commonly published around $0.0895 per vCPU-hour and $0.00945 per GB-hour as of mid-2026 — verify at aws.amazon.com/bedrock/agentcore/pricing). CPU is billed for active cycles; I/O wait for LLM/tool calls is not billed as CPU. Memory bills on peak footprint while the session lives.
- Gateway, Memory, Identity, Policy, Evaluations bill as separate request/storage/token meters when you enable them.
- Foundation model tokens are a separate Bedrock line — AgentCore does not replace Converse/Invoke pricing.
- Biggest surprise we see: teams budget Runtime and forget Memory extraction + Gateway tool volume + model tokens on every turn.
Read this alongside AgentCore vs Daytona vs E2B (where code should run) and Bedrock pricing explained (the model/KB/Guardrails stack).
Last updated: July 2026. Component rates change; re-verify AWS pages before budgeting.
At-a-glance: AgentCore meters
| Component | Billing shape (directional) | What drives cost |
|---|---|---|
| Runtime | Active vCPU-hour + peak GB-hour per second | Session length, idle timeout, cold starts, peak memory |
| Browser / Code Interpreter | Same active compute family as Runtime | How long sandboxes stay up; how often you re-run work |
| Gateway | Per 1,000 invocations / searches + tool indexing | Tools per turn; semantic tool search usage |
| Memory | Events, long-term records/month, retrievals | Strategies enabled; how often you write and retrieve |
| Identity | Often included via Runtime/Gateway; else per token/API-key request | Whether you call Identity outside the included path |
| Policy | Per authorization request (+ authoring tokens if used) | Tool calls gated per session |
| Observability | CloudWatch pass-through | Log volume and retention |
| Evaluations | Per tokens or per evaluation run | Online sampling rate; judge model size |
Why “I/O wait is free” still needs a memory budget
AWS’s AgentCore pitch is correct for CPU: agentic workloads often spend 30–70% of a session waiting on model responses or tool APIs. You are not charged for idle CPU during that wait. That is a real advantage versus pre-allocated instance billing.
Memory is different. Peak memory is billed for the session lifetime (with published minimums such as a 128 MB floor). A long session that sits mostly waiting can still accrue memory cost even when CPU is quiet. Cipher’s production rule: set aggressive idle timeouts, avoid holding Browser/Code Interpreter sessions open “just in case,” and cache intermediate results instead of re-running heavy sandboxes.
AWS’s own pricing examples illustrate the shape: a 60-second session with 70% I/O wait can show Runtime CPU + memory in fractions of a cent per session at published rates — but multiply by millions of sessions and add model tokens, and the monthly number is no longer a rounding error.
The bill stack Cipher models on every AgentCore build
- Model tokens (usually the largest line once reasoning models are on) — see Bedrock pricing.
- Runtime active compute for the agent loop.
- Tool surface — Gateway invocations × tools-per-turn.
- Memory strategies — each long-term strategy that extracts on every session adds write/storage/retrieve cost.
- Sandbox modules — Browser and Code Interpreter only when the task needs them.
- Policy + eval sampling — cheap per request, expensive if you sample 100% with a large judge model.
Unique insight from delivery work: turning on “all Memory strategies” and “online evals at 100%” during a pilot is the fastest way to make AgentCore look expensive relative to a thin LangGraph service on ECS. Start with short-term memory + one LTM strategy you can defend, and sample evals (for example 5–10%) until quality baselines exist.
Worked shapes (directional, mid-2026 published rates)
Figures below paraphrase AWS pricing-page examples and third-party breakdowns that cite the same unit rates. Re-run with your numbers.
| Workload | AgentCore-heavy drivers | Planning tip |
|---|---|---|
| Simple Q&A agent, no tools | Runtime + model tokens | Keep sessions short; Haiku/lite for routing |
| Tool-using ops agent | Runtime + Gateway + Policy + model tokens | Cap tools-per-turn; index only tools you need |
| Research agent with Browser | Browser compute + long sessions | AWS example-scale Browser sessions can dominate; terminate hard |
| Coding / analysis agent | Code Interpreter + model tokens | Reuse snapshots; avoid re-executing the same notebook steps |
AgentCore vs “just run agents on ECS/Lambda”
Self-hosting an agent loop on ECS or Lambda can look cheaper on a spreadsheet that only counts vCPU. You then re-implement session isolation, tool auth, memory stores, and policy checks. AgentCore’s price includes those productized modules. The fair comparison is AgentCore bill vs (compute + your engineering time + the incomplete security story you will otherwise ship).
For sandbox-only decisions (where untrusted code runs), compare AgentCore Code Interpreter against Daytona/E2B in our runtime comparison — different category from full AgentCore platform pricing.
AU/SG ownership checklist
- Deploy in the customer AWS account and Region that matches residency commitments.
- Wire IAM so agents get ephemeral credentials; do not bake long-lived secrets into Runtime sessions.
- Put CloudWatch cost and error alarms on AgentCore dimensions in week one, not after the first scary invoice.
- Document which Memory strategies and eval sampling rates are approved for production.
Related: Bedrock Agents vs AgentCore + Strands · Strands vs Mastra vs LangGraph vs CrewAI · Applied AI Engineering
FAQ
Is AgentCore Runtime billed while waiting on Claude/GPT responses? Active CPU during pure I/O wait is not billed; peak memory for the live session still is. Confirm current wording on the AgentCore pricing page.
Does AgentCore price include Bedrock model tokens? No. Model inference is billed under Bedrock model pricing separately.
Is Identity free? AWS states Identity has no additional charge when used through Runtime or Gateway; other call paths can bill per token/API-key request.
How do we keep AgentCore costs predictable? Cap session TTL, limit tools-per-turn, enable only needed Memory strategies, sample evals, and alert on Gateway and Runtime spend daily during ramp.
Who helps implement AgentCore without a surprise bill? Cipher Projects designs and ships production AgentCore systems for Australian and Singapore teams — architecture, IAM, cost shape, and ownership under your AWS accounts.
Conclusion
AgentCore pricing is modular on purpose. Budget Runtime honestly, but never alone: model tokens, Gateway chatter, Memory strategies, and long-lived Browser/Code sessions are what turn a cheap demo into a loud invoice. Instrument those meters before you scale concurrent sessions.