Building AI Agents on Amazon Bedrock AgentCore: The Real Bill, Component by Component
A builder's breakdown of Amazon Bedrock AgentCore's pricing — Runtime, Gateway, Memory, Identity, Browser, and every other metered piece — plus a worked example, and what it's like trying to get the same clarity out of the nearest Azure alternative.
AI agents are the current frontier — and also the easiest place to lose track of a bill, because "running an agent" isn't one meter, it's a dozen small ones stacked together: compute for the agent loop, storage for what it remembers, calls to the tools it uses, checks on what it's allowed to do. Amazon Bedrock AgentCore is refreshingly explicit about this: instead of one blended rate, it publishes a price for every moving part. This is a walkthrough of what each one actually costs, and what happens when you go looking for the same breakdown on Azure.
The components, and what each one costs
AgentCore bills separately for every service an agent touches. As of September 2026:
Component | What it's for | Price |
|---|---|---|
Runtime (microVM) | The agent's execution environment | $0.0895/vCPU-hour + $0.00945/GB-hour |
Browser | Headless browser for web-using agents | $0.0895/vCPU-hour + $0.00945/GB-hour |
Code Interpreter | Sandboxed code execution | $0.0895/vCPU-hour + $0.00945/GB-hour |
Gateway (API calls) | Routing agent tool calls | $0.005 per 1,000 invocations |
Gateway (search) | Tool discovery | $0.025 per 1,000 invocations |
Identity | Token/auth requests | $0.010 per 1,000 requests |
Memory (short-term) | New conversation events | $0.25 per 1,000 events |
Memory (long-term storage) | Persisted facts across sessions | $0.75 per 1,000 records (built-in strategy) |
Memory (long-term retrieval) | Recalling stored memory | $0.50 per 1,000 retrievals |
Policy (authorization) | Permission checks | $0.000025 per request (first 100 policies free) |
Web Search | Built-in search tool | $7 per 1,000 queries |
Observability | Tracing and logs | Standard Amazon CloudWatch rates |
Billing on the compute components (Runtime, Browser, Code Interpreter) is per-second with a 1-second minimum — genuinely usage-based, not rounded up to the hour like a lot of managed compute.
Why this granularity matters
An agent that browses the web, runs code, and remembers past conversations touches at least five of these meters on a single task. That's not a flaw in the pricing model — it's an honest reflection of what an agent actually is: several AWS services wired together behind one abstraction. The alternative (a single flat "per agent run" price) would just be hiding the same costs one level up, with less room to optimize any single one of them.
Where this pays off in practice: a support agent that leans heavily on long-term memory but rarely touches the browser can see exactly where its money goes, and cut the Memory calls specifically — retrieving less context per turn, or caching frequently-recalled facts client-side — without guessing which part of a bundled fee to attack.
A worked example
Say an internal ops agent handles 5,000 tasks a month. Each task: 90 seconds of Runtime compute (1 vCPU, 2GB), 3 Gateway tool calls, 1 Identity check, 2 new Memory events, and 1 long-term Memory retrieval.
Component | Monthly usage | Cost |
|---|---|---|
Runtime (vCPU) | 5,000 × 90s = 125 vCPU-hours | $11.19 |
Runtime (memory) | 5,000 × 90s × 2GB = 250 GB-hours | $2.36 |
Gateway (API calls) | 15,000 invocations | $0.075 |
Identity | 5,000 requests | $0.05 |
Memory (short-term) | 10,000 events | $2.50 |
Memory (retrieval) | 5,000 retrievals | $2.50 |
Total | | ≈ $18.68/month |
For a workload this size, the bill is dominated by compute time, not by any of the agent-specific services — which is a useful sanity check before assuming AgentCore's metering will make a small agent expensive. It's the compute-heavy tasks (long browser sessions, code interpreter loops) where the per-second billing actually starts to matter.
Trying to do the same comparison on Azure
The natural comparison is Azure AI Foundry Agent Service. Here's where the comparison gets genuinely harder to make fair: Azure's own pricing page lists the categories — hosted agent compute (vCPU-hour, memory GiB-hour), Code Interpreter (per session), File Search storage (per GB/day, 1GB free), Web Search (per 1,000 transactions) — but the actual rates are marked "$-" pending region-specific quotes in the Azure portal, rather than published flat numbers.
Foundry-native agents (ones built purely from prompts and workflows, no hosted compute) are free to run — you only pay for the underlying model tokens. That's a real advantage for lightweight agents that don't need sandboxed execution. But the moment an agent needs hosted compute, a code interpreter session, or persistent storage — the same territory AgentCore prices transparently — Azure pushes you to the calculator rather than giving you a number to reason about upfront.
This isn't a knock on Azure's actual costs, which may well be competitive once you get a quote. It's a difference in how the two platforms let you reason about cost before you build: AgentCore's table above is enough to estimate a real workload from a blog post; Foundry Agent Service, for the hosted-compute components, is not.
The practical takeaway
If you're estimating what an agent will cost before writing a line of code, Bedrock AgentCore's published, per-component pricing lets you build that estimate directly from the rate card — no account rep required. Start by mapping your agent's actual behavior to the components table above (which tools does it call, does it need long-term memory, how much compute time per task), and the worked-example structure here will get you a real number, not a guess.
Sources:
- Amazon Bedrock AgentCore Pricing — AWS official pricing page, September 2026
- Amazon Bedrock AgentCore Pricing (2026): What Actually Drives the Bill — Cipher Projects
- Azure AI Foundry Agent Service — Pricing — Microsoft Azure official pricing page
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article