AI Agents
Amazon Bedrock AgentCore Pricing: What One Agent Costs to Run
AgentCore Runtime costs about $0.0067 per 10-minute session. See every meter, a monthly bill at three volumes and the Fargate comparison.
In this article
- Amazon Bedrock AgentCore pricing at a glance: every meter in one table
- How much does AgentCore Runtime cost per session?
- Does AgentCore bill while the agent is idle?
- Runtime v1 vs v2 pricing: which rate card applies, and when v2 costs more
- The rest of the bill: Gateway, Memory, Observability and Policy
- Evaluations can cost more than the agent itself
- What a monthly AgentCore bill looks like at 10,000, 100,000 and 1 million sessions
- Is AgentCore cheaper than Fargate for agents?
- Runtime Instances: when EC2-backed pricing beats microVMs
- How AgentCore compares with Google and Azure agent runtimes
- Seven ways to lower an AgentCore bill
- How to estimate your own AgentCore bill in an afternoon
- Conclusion: price the shape of your agent, not the meter list
- Frequently asked questions
- Sources
Amazon Bedrock AgentCore pricing is consumption-based, and for a typical agent the runtime is the small line. On Runtime v2, AWS's own worked example, a 10-minute customer support session that keeps its CPU busy 10% of the time, costs about $0.0067. That is $6,703 a month at one million sessions. The line items around it (tools, memory, telemetry) add roughly 5%, quality evaluations can add far more, and the model tokens usually cost many times the runtime.
This guide goes through every AgentCore meter as of November 14, 2026, prices one reference agent at 10,000, 100,000 and 1 million sessions a month, and compares it with running the same agent on AWS Fargate. It also answers the questions that rank pages mix up: whether AgentCore bills while the agent is idle, which of the two Runtime rate cards (v1 and v2) applies to you, and when the EC2-backed "Instances" option is cheaper than microVMs.
All rates below are AWS list prices from the AgentCore pricing page unless noted. They change, and your Region, discounts and agent shape matter. Treat the totals as a model to adapt, not a quote.
Amazon Bedrock AgentCore pricing at a glance: every meter in one table
AgentCore has no minimum fee and no upfront commitment, and each capability is billed separately, so your bill is the sum of the meters you switch on. The table lists each meter, its unit, its list rate and what usually drives it.
| Capability | What you are billed for | List rate (November 2026) | Usually driven by |
|---|---|---|---|
| Runtime, v2 microVMs | vCPU-hours and GB-hours while the session holds them | $0.1276 per vCPU-hour; $0.0169 per GB-hour | Session length, active CPU time, memory held |
| Runtime, v1 microVMs | Same units, older rate card | $0.0895 per vCPU-hour; $0.00945 per GB-hour | Session length, peak memory |
| Runtime, committed baseline (v2) | Discounted v2 rate | $0.0997 per vCPU-hour; $0.0132 per GB-hour | Steady, always-on agents (launch unconfirmed) |
| Runtime, Instances | The EC2 instance plus a management fee | EC2 on-demand rate plus 12% (7.8% for G-series GPU families) | Long, CPU-heavy sessions |
| Browser tool, Code Interpreter | vCPU-hours and GB-hours | $0.0895 per vCPU-hour; $0.00945 per GB-hour | Sessions that browse or execute code |
| Gateway | API invocations; search; tool indexing | $0.005 per 1,000 invocations; $0.025 per 1,000 searches; $0.02 per 100 tools per month | Tool calls per session |
| Identity | Token or API-key requests | $0.010 per 1,000; free through Runtime or Gateway | Rarely a line item |
| Memory, short-term | Ingestion, retrieval, storage | $1.00 per GB ingested; $0.20 per GB retrieved; $0.10 per GB-month | Events per session (12 KB billable minimum) |
| Memory, long-term | Records stored and retrieved | $0.75 per 1,000 records per month (built-in); $0.25 (override or self-managed); $0.50 per 1,000 retrievals | Records kept, recalls per session |
| Observability | Spans, logs, metrics | Charged at Amazon CloudWatch rates | Spans per invocation |
| Evaluations | Tokens or evaluations | $0.0024 per 1,000 input tokens and $0.012 per 1,000 output tokens (built-in); $1.50 per 1,000 evaluations (custom) | Share of traffic you score |
| Policy | Authorization requests; authoring tokens | $0.000025 per request; $0.13 per 1,000 input tokens for natural-language authoring | Tool calls checked |
| Web Search / Web Answer | Queries or calls | $7.00 per 1,000 queries; $10 per 1,000 calls | Grounded lookups |
| Agent Registry | Records and API calls | First 5,000 records free, then $0.400 per 1,000 | Number of agents and tools registered |
Three of these deserve a warning before the details. The Runtime rate you pay depends on whether the runtime is on platform v1 or v2. The evaluation meter bills model tokens at a rate that makes scoring one conversation cost more than serving it. And model tokens for the agent itself are not an AgentCore line at all: AWS describes AgentCore as model-agnostic, so the model provider bills you separately.
Key takeaway: AgentCore is a bundle of independent meters. Price the agent by listing which meters it touches, then add model tokens, which AgentCore does not bill.
How much does AgentCore Runtime cost per session?
A session costs its CPU time plus its memory time, so the formula is active vCPU-seconds times the CPU rate plus GB-seconds held times the memory rate. AWS prices this exact case in its examples, and we reuse it as our reference agent throughout.
The reference agent is AWS's customer support example: a session lasts 10 minutes, with 90% of that time spent waiting on the model, tools or the human. The agent uses 1 vCPU while it is actually working, so the CPU meter runs for 60 seconds. Memory starts at 1 GB, rises to 2 GB during retrieval and peaks at 2.5 GB during tool calls, and is reclaimed when unused for 120 seconds.
| Line | Calculation (Runtime v2) | Cost per session |
|---|---|---|
| CPU | 60 s × 1 vCPU × ($0.1276 ÷ 3,600) | $0.002127 |
| Memory, first 300 s at 1 GB | 300 × 1 GB × ($0.0169 ÷ 3,600) | $0.001408 |
| Memory, next 150 s at 2 GB | 150 × 2 GB × ($0.0169 ÷ 3,600) | $0.001408 |
| Memory, last 150 s at 2.5 GB | 150 × 2.5 GB × ($0.0169 ÷ 3,600) | $0.001760 |
| Session total | $0.006703 |
Multiply by one million sessions and the runtime line is $6,703 a month, which matches the figure on AWS's page. Two details matter for your own estimate. First, memory is 68% of the runtime cost even though CPU is the more expensive unit, because memory is held while the CPU is idle. Second, container images sit in Amazon ECR and direct-code deployments in S3, billed at those services' rates: for a 100 MB agent, AWS puts S3 storage at $0.0023 a month, so deployment storage is a rounding error.
Key takeaway: For wait-heavy agents, memory-seconds, not CPU-seconds, set the Runtime bill. Shorten the time memory is held before you optimize CPU.
Does AgentCore bill while the agent is idle?
CPU stops billing when the agent is waiting, memory keeps billing until it is released, and a few fixed lines bill whether the agent runs or not. That is the accurate answer, and it differs from the shorthand you will see in places. AWS's FAQ says "I/O wait and idle time is free," while the same company's pricing example bills memory for the whole session. The two reconcile once you separate the meters.
| What is idle | Does it bill? | Source of the rule |
|---|---|---|
| vCPU while the agent waits on a model or API | No: CPU bills only while the agent is actively processing | Pricing page example (60 active seconds of 600) |
| Memory while the agent waits, Runtime v2 | Yes, until reclaimed: unused memory is reclaimed after 120 seconds | Pricing page example; FactualMinds also reports a 128 MB floor |
| Memory while the agent waits, Runtime v1 | Yes, for the whole session | Reported by AWS Builder Center and FactualMinds |
| A session no one is using | It stays alive until idleRuntimeSessionTimeout (default 900 seconds, range 60 to 28,800) |
AWS lifecycle documentation |
| Long-term memory records kept | Yes, monthly storage: $0.75 per 1,000 records | Pricing page |
| Gateway tool index | Yes: $0.02 per 100 tools per month | Pricing page |
| A NAT gateway in front of a VPC-attached agent | Yes, every hour: $0.045 per hour plus $0.045 per GB processed | AWS VPC pricing example; AWS Builder Center |
The session lifecycle rules are worth reading closely. By default an idle session survives 15 minutes and any instance lives at most 8 hours (28,800 seconds), which is also the ceiling for microVMs; capacity-provider Instances accept up to 14 days. AWS's own guidance recommends an idle timeout of about 5 minutes for development and 10 to 15 minutes for interactive chat. A forgotten test session on a 28,800-second idle timeout is the classic way to pay for memory no one is using.
The NAT line is the one that surprises small teams. A NAT gateway costs about $32.85 a month at $0.045 an hour (730 hours) before it moves a single byte, and AWS bills each partial hour as a full hour. AWS Builder Center's analysis of a cheap-model development account found the fixed NAT charge was roughly two-thirds of a $49 bill for 1,000 tasks. If your agent needs internet access from inside a VPC, budget the NAT as a fixed cost of the environment, not of the agent.
Key takeaway: Idle CPU is free, idle memory is not, and the cheapest saving is a short idle timeout in every non-production environment.
Runtime v1 vs v2 pricing: which rate card applies, and when v2 costs more
V2 charges more per unit and bills fewer units, so whether it saves money is arithmetic you can do in two lines. Third-party pages disagree about the rates because they quote different versions: CloudBurn's May 2026 pricing guide, for example, lists the v1 numbers without labeling them and its Runtime example differs from AWS's current one.
| Runtime v1 | Runtime v2 | Change | |
|---|---|---|---|
| vCPU-hour | $0.0895 | $0.1276 | +42.6% |
| GB-hour | $0.00945 | $0.0169 | +78.8% |
| Idle memory | Held until the session ends | Reclaimed after 120 seconds | Fewer GB-seconds billed |
| P75 start time, 2 GB image | 29.7 seconds | Under 2 seconds | AWS figure from the November 12, 2026 announcement |
| Maximum size | 8 vCPU and 32 GB |
The break-even follows from the memory rates: 0.00945 ÷ 0.0169 = 0.559. V2's memory line is cheaper only when it bills fewer than 55.9% of the GB-seconds v1 would, a cut of more than 44%. CPU is always 42.6% dearer on v2, so a CPU-heavy agent never gains.
Apply that to the reference agent, assuming v1 bills the peak 2.5 GB for all 600 seconds (the assumption FactualMinds uses): v1 memory is 1,500 GB-seconds, v2 bills 975, a 35% cut. That is less than the 44% needed, so v1 comes out at $5,429 per million sessions against v2's $6,703. FactualMinds reaches the same $5,429 figure. AWS says multi-turn agents "may see up to 68% less billed memory per session." At a 68% cut (480 GB-seconds), the v2 session falls to about $0.0044, roughly 19% below v1. FactualMinds also models an 8-hour session with memory spikes at $31.27 on v1 against $14.89 on v2, and short 5-second turns where v2 costs more because reclamation never triggers.
Which version you are on is easy to miss. AWS announced on November 12, 2026 that new runtimes use the next-generation runtime by default, while existing runtimes stay on their current version until you set platformVersion to V2. You can keep a new runtime on v1 by setting platformVersion to V1. V2 also restores sessions from a prepared snapshot, which is why startup drops from tens of seconds to about two. If startup time is not your problem and your agent is CPU-bound with short turns, keep the v1 rate card in mind before migrating.
The committed baseline is the other lever, and its status is unclear. The pricing page lists $0.0997 per vCPU-hour and $0.0132 per GB-hour, about 22% under the v2 consumption rate, as "launching by October 2026." AWS's November 9 weekly roundup still says committed baseline pricing is "coming soon," and AWS's November 12 blog describes it as a memory baseline per session billed as a minimum, with room to burst to four times that baseline on demand. On those terms it suits always-on agents, not bursty ones. Until AWS confirms the launch, price your plan on the on-demand rate and treat the baseline as upside.
Key takeaway: Do not migrate to v2 for price alone. Measure billed GB-seconds on both; v2 pays off when idle memory is large, turns are long and sessions pause.
The rest of the bill: Gateway, Memory, Observability and Policy
Everything outside Runtime is small per session, which is why it is easy to ignore until it is not. Scaling AWS's own examples to our reference agent (10 tool calls, 1 search, 100,000 sessions) gives the following.
| Line | Assumption | Cost per 100,000 sessions |
|---|---|---|
| Runtime v2 | AWS example session, $0.0067 each | $670.38 |
| Gateway | 10 InvokeTool calls ($5 per million) plus 1 search ($25 per million) per session | $7.50 |
| Memory | AWS example: 100,000 events at the 12 KB billable minimum, 10,000 long-term records, 20,000 retrievals | $18.97 |
| Observability | AWS example scaled: about 50 spans of 1 KB per session at $0.35 per GB, plus event logs | $3.25 |
| Identity | Used through Runtime or Gateway | $0.00 |
| Policy (optional) | 10 tool calls checked per session at $0.000025 | $25.00 |
| Total with Policy | $725.10 |
Memory is the least intuitive of these. Short-term memory events under 12 KB are billed as 12 KB, so a 3 KB event costs the same to ingest as a 12 KB one; storage, by contrast, bills on actual size. Long-term memory charges per record kept and per retrieval, so an agent that remembers everything about every user pays for the remembering every month, whether or not anyone returns. Choosing the "override or self-managed" extraction strategy cuts record storage to $0.25 per 1,000 but sends the extraction model calls to your own account.
Observability is cheap at AWS's example scale: 200,000 invocations producing about 10 GB of spans and 6 GB of event logs cost $6.50 a month. Verbose logging of prompts and responses changes that quickly, and standard CloudWatch rates apply to metrics and ordinary logs on top. If you are deciding what to trace, our guide to monitoring AI agents in production covers which spans pay for themselves.
Two meters are easy to switch on by accident. Web Search on AgentCore costs $7.00 per 1,000 queries, which is 1,400 times the Gateway invocation rate: AWS's own example of 200,000 research queries costs $1,400 a month in searches against $3 in invocations. Browser and Code Interpreter bill at the v1 Runtime rates ($0.0895 and $0.00945), so a travel-booking agent running 100,000 ten-minute browser sessions costs $1,226.67 a month in AWS's example.
Evaluations can cost more than the agent itself
AgentCore Evaluations bills model tokens at published rates, and because an evaluator reads the whole conversation, scoring one interaction costs far more than running it. AWS's example uses 15,000 input tokens and 300 output tokens per evaluation. At $2.40 per million input tokens and $12 per million output tokens, one built-in evaluator costs $0.0396, and the three-evaluator setup in the example costs $0.1188 per interaction. Our reference session costs $0.0067 to run. Scoring one interaction with three evaluators costs about 18 times as much.
AWS's example monitors 5,000 development test interactions and 2% of 10,000 production conversations, 15,000 in all, and totals $1,804.50 a month ($1,782 for built-in evaluators and $22.50 for one custom evaluator). That is a sensible shape: a few hundred dollars of scoring protects a much larger production spend. At full coverage it would not be. Sampling rate, evaluator count and context length are the three levers, and sampling is the easiest.
Key takeaway: Decide the sampling rate before you enable evaluators. At 3 built-in evaluators and 15,000 input tokens, scoring costs about $0.12 per interaction.
What a monthly AgentCore bill looks like at 10,000, 100,000 and 1 million sessions
At 10,000 sessions the fixed NAT gateway is a quarter of the bill; at one million, Runtime is about 70% and evaluations about a quarter. The table adds every line from the sections above for the reference agent, with evaluations on 2% of sessions, Policy on every tool call and a NAT gateway in the environment.
| Monthly line | 10,000 sessions | 100,000 sessions | 1,000,000 sessions |
|---|---|---|---|
| Runtime v2 | $67.04 | $670.38 | $6,703.75 |
| Gateway | $0.75 | $7.50 | $75.00 |
| Memory | $1.90 | $18.97 | $189.70 |
| Observability | $0.33 | $3.25 | $32.50 |
| Policy | $2.50 | $25.00 | $250.00 |
| Evaluations, 2% sampled | $23.76 | $237.60 | $2,376.00 |
| NAT gateway (fixed) | $32.85 | $32.85 | $32.85 |
| AgentCore total | $129.13 | $995.55 | $9,659.80 |
| Per session | $0.0129 | $0.0100 | $0.0097 |
The assumptions are the weak point, so change them: scale Gateway, Memory and Observability linearly (long-term memory storage will not scale perfectly), assume the evaluators use AWS's 15,000-token example, and note that every figure excludes model tokens, ECR or S3 storage, data transfer and the CloudWatch charges for metrics and ordinary logs.
Model tokens deserve their own line because they usually dominate. Our reference session makes 10 reasoning steps. If each step sends 8,000 input tokens, a session sends 80,000, so every $1 per million input tokens adds $0.08 per session, which is 12 times the runtime cost. Output tokens come on top. This is why AWS Builder Center's analysis concludes the model choice moves the bill more than the runtime does, and why LLM API cost optimization usually pays back before runtime tuning does. For the full picture of what an agent costs to build and run, see our AI agent development cost guide.
Is AgentCore cheaper than Fargate for agents?
Against one Fargate task per session, yes; against a shared Fargate service, no, and the gap is the work AgentCore does for you. We priced the same one million 10-minute sessions three ways using the Fargate pricing page's US East (N. Virginia) Linux/x86 rates, about $0.04048 per vCPU-hour and $0.004445 per GB-hour.
- One Fargate task per session is the like-for-like design: each session gets its own isolated compute. A 1 vCPU, 3 GB task costs $0.05382 an hour, and 1 million sessions of 10 minutes is 166,667 session-hours, so the bill is $8,969. Fargate bills the whole task for the whole session, including the 90% of the time the CPU idles, which is why AgentCore's $6,703 wins here. Add the time a new task needs to start, and the gap widens for short sessions.
- Shared Fargate tasks put many sessions in one container. One million sessions of 10 minutes means about 228 sessions running at the same moment on average. At 20 sessions per 1 vCPU, 2 GB task, that is about 11.4 tasks on average ($411 a month if you scale perfectly) or about 34 tasks if you size for a 3× peak ($1,234). The 20-per-task figure is our assumption: it holds only if each session's footprint is a few hundred megabytes, not the 1 to 2.5 GB in AWS's example.
- AgentCore costs more than the shared design by a factor of 5 to 16, and in return gives each session its own microVM, session routing, identity, scale-up in seconds and the managed tools in the table above.
So the honest rule is a default plus the cases where it flips. Default to AgentCore when your agent handles different users' data, calls tools with user-delegated credentials, or must scale unpredictably from zero: isolation per session is the thing you are paying for. Choose a shared Fargate or ECS service when your sessions are small, trusted, uniform and steady, and your team already runs containers. Include your own engineering time in the comparison: the $5,500 to $6,300 monthly difference at one million sessions is real, but building session isolation, authentication and autoscaling is a project, not a setting.
Lambda is the third option and the poorest fit for long waits, because Lambda bills duration while a function waits. At $0.0000166667 per GB-second (x86), a 10-minute invocation holding 3 GB costs $0.03, about four and a half times AgentCore's session cost. It suits short, request-response agent steps, not minutes-long sessions.
Key takeaway: AgentCore beats task-per-session containers because idle CPU is free. A shared container service is cheaper still, if you accept building isolation yourself.
Runtime Instances: when EC2-backed pricing beats microVMs
Runtime Instances bill the underlying EC2 instance plus a 12% management fee, and they win when the agent keeps its CPU busy. FactualMinds reports this compute type became generally available on August 6, 2026. It targets long-lived, stateful work: AWS's example is a code-modernization pipeline in which several agents share a filesystem and run 3-hour sessions on a c7g.2xlarge (8 vCPU, 16 GB) at $0.289 an hour on-demand.
The AWS example costs $0.867 of EC2 plus $0.104 of management fee, $0.971 per session, or $971.04 for 1,000 sessions a month. The management fee is always computed on the on-demand rate, but your EC2 discounts apply to the compute portion: Savings Plans, Reserved Instances and On-Demand Capacity Reservations. If you already hold those, read our guide to Savings Plans vs Reserved Instances before assuming the list price. Instances also accept sessions up to 14 days, against 8 hours for microVMs.
The break-even is a two-line calculation. Assume the work needs 8 vCPU and 16 GB while active, and holds the 16 GB throughout:
- Instances: $0.289 × 1.12 = $0.3237 per hour.
- microVM v2: 16 GB × $0.0169 = $0.2704 per hour for memory, plus 8 vCPU × $0.1276 = $1.0208 per active hour.
Setting them equal gives 0.2704 + 1.0208 × f = 0.3237, so f = 5.2%. If the agent keeps those 8 vCPUs busy more than about 5% of the time, Instances cost less. At 100% active, a 3-hour microVM session would cost $3.87 against $0.97. Below 5%, the microVM wins, and the reference support agent (10% active at 1 vCPU) is a very different shape from a build-and-test pipeline. Pick by measuring the active-CPU share of a real session, not by product positioning.
How AgentCore compares with Google and Azure agent runtimes
Per-meter comparisons mislead because the platforms meter different things, so compare a workload, not a rate. Beri's October 31, 2026 comparison, a third-party analysis that checked each vendor's US list prices that day, models one support agent with 300,000 sessions a month, four turns each, and excludes model tokens. It reports AgentCore Runtime v2 at $1,434.29 (runtime $845.57, memory $579.72, gateway $9.00), Google Agent Runtime at $528.92 and Azure's Foundry hosted agents at $3,642.50 with a 120-second timeout.
Its conclusions are conditional, which is the right way to read any such table. AgentCore suits long-running agents that spend most of each turn waiting on a model; Google's meter is cheapest for chat agents with long gaps between turns; and Foundry hosted agents depend on a metering rule Microsoft has not confirmed. Memory is about 90% of AgentCore's runtime line in that model, which matches what we found above. For the wider platform decision, including model catalogs, see our AWS Bedrock vs Azure OpenAI vs Google Vertex AI comparison.
Seven ways to lower an AgentCore bill
Each lever below follows from a rate or rule in this article, so you can estimate its effect before you change anything.
- Cut idle time first. Set
idleRuntimeSessionTimeoutto 5 minutes in development and 10 to 15 minutes in interactive production. The default is 15 minutes, the maximum is 8 hours. - Reduce memory held per session. Memory was 68% of our runtime line. Load large models, indexes and files outside the session, and keep the peak close to the average.
- Choose the rate card by measurement. Run a week of real sessions and compare billed GB-seconds on v1 and v2; v2 needs more than a 44% cut to pay off.
- Sample evaluations. Scoring 2% of production traffic cost $237.60 per 100,000 sessions in our model; scoring all of it would cost about $11,880.
- Use Runtime Instances for CPU-bound work where the active share is above roughly 5%, and apply Savings Plans to the EC2 portion.
- Keep non-production environments lean. Avoid a NAT gateway in a sandbox unless you need VPC access ($32.85 a month idle), and delete forgotten test runtimes.
- Treat the model as the main line. Choose the cheapest model that passes your evaluations, trim context per step and cache what repeats. Our FinOps for AI workloads guide covers token budgets and alerts.
The same discipline applies to the tool layer: if your agent calls custom tools through Gateway, the engineering cost of those servers dwarfs their invocation fees, as our MCP server development cost guide shows.
How to estimate your own AgentCore bill in an afternoon
Five measurements from a prototype are enough to produce a defensible monthly estimate, and the sensitivity tells you which one to tighten first.
- Sessions per month and average length. Session-hours divided by 730 gives your average concurrency.
- Active CPU share. Trace one session and sum the seconds the process is actually computing; the rest is wait.
- Memory profile. Record the peak and the average, and note how long memory sits unused between turns.
- Tools and memory events per session. Count Gateway invocations, searches, memory events and retrievals.
- Tokens per step and steps per session. Multiply by your model's list price. This is your largest line.
Then fill the tables above with your numbers, add the fixed lines (NAT, tool indexing, long-term memory), decide your evaluation sampling rate, and compare against the Fargate designs only if your team would genuinely run them. If you want to turn the estimate into a decision, our ROI model for AI agents shows how to set run cost against the labor or revenue the agent changes.
Conclusion: price the shape of your agent, not the meter list
AgentCore's runtime is cheap when an agent mostly waits, because idle CPU is free; it is costly when memory is held for long sessions, when evaluations score everything, or when a fixed NAT gateway sits under a small workload. For AWS's own reference agent, the runtime was $0.0067 per session, the whole AgentCore bill about a cent, and model tokens a multiple of both. Default to AgentCore when per-session isolation matters, measure billed GB-seconds before choosing v1 or v2, and treat the committed baseline as unconfirmed until AWS says it has launched.
Prices and product terms change often, so confirm the current rates on the AWS pricing page before committing a budget. If you would like a second set of eyes on an estimate or a design, talk to a specialist about an AI agent on AWS: the first discovery call is free, and our software built for how your business runs team builds on AWS, Azure and Google Cloud.
If you'd like one clear, practical take on AI, software and cloud decisions each month, subscribe to the Fleurant AI Briefing: one email a month, unsubscribe any time.
Frequently asked questions
Does AgentCore bill while the agent is idle?
CPU does not: AgentCore Runtime bills vCPU only while the agent is actively processing, not while it waits on a model or an API. Memory does, until it is released. On Runtime v2, unused memory is reclaimed after 120 seconds; on v1 it is held until the session ends. A NAT gateway, if you use one, bills every hour regardless.
How much does AgentCore cost per session?
AWS's own worked example, a 10-minute support session that is active 10% of the time, costs $0.0067 on Runtime v2 ($0.0021 for CPU, $0.0046 for memory), or $6,703 per million sessions. Other meters add roughly 5% on top at that scale, and the model tokens usually cost far more than the runtime.
Is AgentCore cheaper than Fargate for agents?
It depends on how you run Fargate. One task per session, to match AgentCore's isolation, cost about $8,969 per million 10-minute sessions in our model against $6,703 on AgentCore. Sharing a task across 20 sessions costs $411 to $1,234, but then you build session isolation, scaling and identity yourself.
Is there an AgentCore free tier?
AWS says new customers receive up to $200 in Free Tier credits, and the pricing page lists no minimum fees or upfront commitments. Some features, such as the Agent Registry, also include monthly free allowances. Model usage is billed by the model provider and is not covered by AgentCore itself.
Do I have to use Bedrock models with AgentCore?
No. AWS describes AgentCore as model-agnostic, working with any foundation model in or outside Amazon Bedrock, and with frameworks such as LangGraph, CrewAI and the OpenAI Agents SDK. You pay your model provider separately for tokens, and AgentCore for runtime, tools, memory and the other meters you use.
What is the difference between Runtime v1 and v2 pricing?
V2 charges $0.1276 per vCPU-hour and $0.0169 per GB-hour against v1's $0.0895 and $0.00945, but reclaims idle memory. V2 only wins when it cuts billed memory by more than about 44%. New runtimes default to v2 since November 12, 2026; existing ones stay on v1 until you set platformVersion to V2.
Is the AgentCore committed baseline discount available?
Not confirmed as of November 14, 2026. The pricing page lists $0.0997 per vCPU-hour and $0.0132 per GB-hour, about 22% below on-demand, as launching by October 2026, but AWS's November 9 weekly roundup still said committed baseline pricing is coming soon. Check the pricing page before you plan around it.
How do I estimate an AgentCore bill before building?
Measure five numbers on a prototype: sessions per month, session length, the share of time the CPU is active, peak and average memory, and tool calls per session. Multiply them by the rates in this article, add the fixed lines, and then add model tokens separately. Re-measure after a week of real traffic.
Sources
- Amazon Bedrock AgentCore Pricing, Amazon Web Services
- Run agents securely and efficiently with the next generation AgentCore runtime, AWS Machine Learning Blog
- The next generation AgentCore runtime is now the default, Amazon Web Services
- AWS Weekly Roundup: AgentCore Runtime V2 (November 9, 2026), AWS News Blog
- Configure Amazon Bedrock AgentCore lifecycle settings, AWS Documentation
- Amazon Bedrock AgentCore FAQs, Amazon Web Services
- AWS Fargate Pricing, Amazon Web Services
- Amazon VPC Pricing (NAT gateway), Amazon Web Services
- Amazon Bedrock AgentCore Pricing: Hidden Costs That Bill While Your Agent Idles, AWS Builder Center
- Amazon Bedrock AgentCore Runtime V2 GA: what changed, FactualMinds
- AgentCore vs Agent Engine vs Foundry Agent Service pricing, Beri
- Amazon Bedrock AgentCore Pricing, CloudBurn