AgentCore Runtime V2 is now the default: pricing vs V1, cold starts and how to stay on V1
AgentCore Runtime V2 is now the default for new runtimes. V1 vs V2 pricing, a break-even example, cold-start data and a snapshot migration checklist.

Since 12 November 2026, new Amazon Bedrock AgentCore runtimes use the "next generation" runtime (platform version V2) by default in 19 AWS Regions. V2 starts each session from a snapshot of your already-initialised agent, so cold starts drop to about 2 seconds, and it bills only for memory your agent actually uses. Existing runtimes are not moved automatically, and you can keep any new runtime on the old version by setting platformVersion to V1.
The catch: V2's per-unit rates are higher, and snapshot restores change how you must write startup code. Here's what changed, what it costs, and how to decide.
What is AgentCore Runtime V2?
AgentCore Runtime is AWS's managed service for hosting AI agents and tools: each user session runs in its own Firecracker microVM. V2 is a new "platform version" of that runtime, generally available since 18 September 2026 and now the default for new runtimes.
AWS's 12 November announcement sums up the changes: the new runtime "restores each session from a snapshot of your initialized agent, scales compute and memory with the work, and scales idle agents to zero. Every session still runs in its own hardware-isolated Firecracker microVM."
Two things change, according to AWS's launch blog:
- Cold starts. AgentCore prepares your environment once, snapshots it, and restores that snapshot for every new session instead of booting and importing everything from scratch.
- Memory billing. Sessions start small, page in memory on demand and give it back when it goes cold, so "you pay for what your agent uses" rather than holding the peak for the whole session.
What changed on 12 November?
Before 12 November you had to opt in to V2. Now, AWS says, "new runtimes in Amazon Bedrock AgentCore use the next generation of AgentCore runtime by default" in these Regions: US East (N. Virginia), US East (Ohio), US West (Oregon), Canada (Central), South America (São Paulo), Europe (Frankfurt, Ireland, London, Milan, Paris, Spain, Stockholm) and Asia Pacific (Malaysia, Mumbai, Seoul, Singapore, Sydney, Thailand, Tokyo).
Three rules from the announcement matter most:
- Existing runtimes stay on V1 "until you move them".
- To move a runtime to V2, or use V2 where it isn't the default, set
platformVersiontoV2on create or update. - To keep a new runtime on V1, set
platformVersiontoV1explicitly.
One thing to watch: when we checked on 16 November, the AgentCore Developer Guide's platform-versions section still said "V1 is the default" and that omitting platformVersion on create gives you V1. That contradicts the 12 November announcement. Until the docs catch up, don't rely on the default either way: set platformVersion explicitly in every create call and in your deployment scripts.
How much faster is AgentCore Runtime V2?
| Measurement | V1 (original) | V2 (new) | Source |
|---|---|---|---|
| P75 cold start, 2 GB image | 29.7 s | under 2 s | AWS announcement |
| P75 cold start, 200 MB to 2 GB images | ~5.4 s rising to ~30 s | ~2 s, flat | AWS launch blog (empty echo agent) |
| First invoke, 859 MB image (single test) | 13.6 s | 1.8 s | Classmethod, Tokyo |
| First invoke, 46 MB image (single test) | 3.4 s | 2.1 s | Classmethod, Tokyo |
| Time for create/update to reach READY | ~5 s | ~3 minutes | Classmethod; AWS docs say "several minutes" |
The independent numbers come from Classmethod engineer suzuki.ryo, who tested both versions in the Tokyo Region the day after V2 launched and concluded that cold starts are improved, while noting each figure is a single measurement and that "V2 is not intended to improve computational performance" (Classmethod). The same test found the first warm call on a new session on an existing runtime was slower on V2 (1.912 s vs 0.611 s), with later calls similar.
How much does AgentCore Runtime V2 cost vs V1?
Rates from the AgentCore pricing page (US dollars):
| V1 | V2 consumption (default) | V2 committed baseline | |
|---|---|---|---|
| CPU | $0.0895 per vCPU-hour | $0.1276 per vCPU-hour | $0.0997 per vCPU-hour |
| Memory | $0.00945 per GB-hour | $0.0169 per GB-hour | $0.0132 per GB-hour |
AWS says billing is per second "using actual CPU and memory consumption, with a 1-second minimum", there's a 128 MB minimum for memory billing, and in V2 "idle memory is reclaimed automatically ... after 120 seconds". The pricing page labels committed baseline as "launching by October 2026"; AWS's 9 November weekly roundup still described it as "coming soon", while the Developer Guide already documents how to set it, so confirm it's live in your Region before budgeting on it.
So V2's CPU rate is about 43% higher and its memory rate about 79% higher than V1 (our calculation from the rates above). AWS's own launch blog is upfront about this: "The per-unit rate is higher, but you use far fewer GB-hours, so the team expects most agents to see a lower bill, though that isn't guaranteed."
Will V2 make my AgentCore bill cheaper? A worked example
Here's an illustrative estimate (our maths, not an AWS quote). Assume a chat session lasting 10 minutes, with 60 seconds of active CPU at 1 vCPU and a 2 GB memory footprint that V1 bills for the full 10 minutes:
| Scenario | CPU cost | Memory cost | Total per session | vs V1 |
|---|---|---|---|---|
| V1 | $0.00149 | $0.00315 | $0.00464 | — |
| V2, billed memory cut 30% | $0.00213 | $0.00394 | $0.00607 | +31% |
| V2, billed memory cut 50% | $0.00213 | $0.00282 | $0.00494 | +6% |
| V2, billed memory cut 68% (AWS's "up to" figure) | $0.00213 | $0.00180 | $0.00393 | −15% |
In this example V2 only breaks even once billed memory falls by roughly 55%. AWS says multi-turn agents can see "up to 68% less billed memory per session", so long, mostly idle conversations are the best case. Short, CPU-heavy sessions are the worst case, because the CPU rate rose and there's little idle memory to reclaim.
The practical advice, which AWS's Developer Guide also gives: run on V2 consumption pricing first, watch the CPUUsed-vCPUHours and MemoryUsed-GBHours CloudWatch metrics, and compare against your V1 bill before moving production traffic.
What breaks when you move an agent to V2?
Because every session restores the same memory snapshot, anything your code creates at startup is identical in every instance. AWS's optimisation guide lists the traps; this is our pre-migration checklist built from it:
| Check | Why it matters on V2 |
|---|---|
| Generate random values, UUIDs and tokens inside the request handler | Values created at startup are copied into the snapshot; Python's random module repeats the same sequence across instances |
Node.js: don't trust crypto.randomUUID() or the uuid package for uniqueness |
AWS says OpenSSL-based values "can repeat across instances, even when you call them in your handler"; read /dev/urandom instead |
| Read the current time per request | A startup timestamp is frozen at snapshot time, and time.monotonic() doesn't advance across a restore |
| Refresh credentials when they expire | Tokens loaded at startup may have expired before a session starts |
| Don't use hostname or PID as an instance ID | Every restored instance reports localhost and PID 1 |
| Don't cache dynamic tool catalogs at startup | AWS warns this "freezes your agent's tool inventory at the time of the snapshot" |
| Finish initialisation within 120 seconds | If /ping isn't healthy within 120 s, creation fails |
| Avoid binding to a fixed source port | Can collide with the connection re-established after restore |
| Allow minutes for create/update | Poll until READY; calling update or delete earlier returns ConflictException |
Sachin, writing on AWS Builder Center, summed up the rule as "Cache what is stable. Refresh what is dynamic." and added that, at the time he wrote it, CloudFormation and CDK didn't directly support setting platformVersion (AWS Builder Center). We couldn't confirm the current CloudFormation status on an official page, so check the latest resource reference if you deploy with infrastructure as code.
We didn't find Reddit or Hacker News threads about V2 becoming the default. The questions developers are asking, judging by Google's suggestions and the blog posts above, are mostly "agentcore runtime v2" vs v1 pricing and how to opt in or out.
How do you stay on V1 or move to V2?
AWS's Developer Guide shows the CLI flag. To create a runtime on a specific platform version:
aws bedrock-agentcore-control create-agent-runtime \
--agent-runtime-name "my-agent" \
--role-arn "arn:aws:iam::111122223333:role/AgentExecutionRole" \
--agent-runtime-artifact '{
"containerConfiguration": {
"containerUri": "111122223333.dkr.ecr.us-west-2.amazonaws.com/my-agent:latest"
}
}' \
--network-configuration '{"networkMode": "PUBLIC"}' \
--platform-version V2
Use V1 instead of V2 to stay on the original runtime. To check which version a runtime uses:
aws bedrock-agentcore-control get-agent-runtime \
--agent-runtime-id my-agent-ABCDE12345 \
--query platformVersion
In boto3 the parameter is platformVersion="V2" on create_agent_runtime. Per the docs, omitting it on an update keeps the runtime's current version.
What are the V2 limits?
- Default session size: 2 vCPU and 8 GB on consumption pricing, with no bursting above that.
- With a committed baseline: sizes from 1 GB/0.25 vCPU up to 8 GB/2 vCPU, each able to burst to 4x, so up to 8 vCPU and 32 GB per session.
- Container images: up to 10 GB compressed on V2, vs 2 GB on V1.
- Session lifetime: up to 8 hours; sessions end after 15 minutes of inactivity.
Editor's take
V2 is a genuine fix for AgentCore's biggest complaint: a 30-second cold start on a large image is unusable for a chat agent, and 2 seconds isn't. Making it the default makes sense for new projects.
But "default" shouldn't mean "automatic" for anything already running. The higher unit rates mean some agents will cost more, and the snapshot model can introduce subtle bugs, such as duplicate session IDs across instances, that won't show up in a quick test. Move one runtime, run the checklist above, compare a week of metrics, then decide. And pin platformVersion in your scripts so the docs-vs-announcement mismatch can't surprise you.
If you're building agents on AWS, related reads: AgentCore's new Web Search API and pricing, Step Functions as agent tools via AgentCore Gateway, and AWS Lambda MicroVMs vs Fargate. And if you want to run an open-weight model behind your agent, see today's explainer on DeepSeek V4 on SageMaker JumpStart.
FAQ
What is AgentCore Runtime V2?
It's the next-generation platform version of Amazon Bedrock AgentCore Runtime. It restores each session from a snapshot of your initialised agent for fast cold starts, bills for memory actually used, and scales idle agents to zero.
Is AgentCore Runtime V2 the default now?
Yes, for new runtimes in 19 Regions since 12 November 2026, according to AWS. Existing runtimes stay on V1 until you move them. The Developer Guide still said V1 was the default when we checked, so set platformVersion explicitly.
How do I keep my AgentCore runtime on V1?
Set platformVersion to V1 when you create the runtime (--platform-version V1 in the CLI). Existing runtimes stay on their current version unless you change it.
How much does AgentCore Runtime V2 cost?
On consumption pricing, $0.1276 per vCPU-hour and $0.0169 per GB-hour, billed per second, vs $0.0895 and $0.00945 on V1. Committed baseline rates are $0.0997 and $0.0132.
Is AgentCore Runtime V2 cheaper than V1?
It depends on your agent. Unit rates are higher, but you're billed for less memory. In our example, V2 only became cheaper once billed memory fell by about 55%. AWS says multi-turn agents can see up to 68% less billed memory.
How fast are AgentCore V2 cold starts?
AWS says sessions start in under 2 seconds at P75 on a 2 GB image, down from 29.7 seconds on V1.
What is the maximum container image size on AgentCore Runtime V2?
10 GB compressed, compared with 2 GB on V1, according to the Developer Guide.
Why are my random IDs duplicated on AgentCore V2?
Values generated at startup are captured in the snapshot and shared by every restored instance. Generate IDs, tokens and random values inside the request handler, and in Node.js read from /dev/urandom.
Sources
- AWS What's New: The next generation AgentCore runtime is now the default (12 Nov 2026)
- AWS Machine Learning Blog: The new AgentCore Runtime: elastic, optimized, and consistently fast starts (18 Sep 2026)
- AWS News Blog: Weekly Roundup, 9 November 2026
- Amazon Bedrock AgentCore pricing
- AgentCore Developer Guide: How it works / Platform versions
- AgentCore Developer Guide: Optimize your agent for Runtime V2
- Classmethod: I tried out the newly released Amazon Bedrock AgentCore Runtime V2
- AWS Builder Center: The snapshot trap in Amazon Bedrock AgentCore V2
Featured image: A technician working in an AWS data center (a general AWS facility, not specific to AgentCore). Image: Amazon. Source