AWS Bedrock AgentCore Runtime Instances Explained
AWS Bedrock AgentCore Runtime Instances give AI agents persistent EC2-backed infrastructure with 14-day sessions, GPU support, and multi-agent coordination. Full breakdown of architecture, pricing, and use cases.
TL;DR — Amazon Bedrock AgentCore now offers Runtime Instances: persistent, AWS-managed EC2 infrastructure where multiple agents share a host, collaborate within sessions lasting up to 14 days, and leverage GPU acceleration. It complements the existing microVM option (capped at 8 hours) for workloads that need long-running state, multi-agent coordination, or heavy compute. Pricing is standard EC2 plus a management fee. Available today in 8 regions.
If you’ve built agents that outgrow a single function invocation — workflows that span days, multi-agent pipelines that need shared state, or inference tasks that demand a GPU — you know the infrastructure gap. The agent framework handles orchestration. The model API handles generation. But nothing in that stack gives you a persistent, managed host where agents can live together, stop and restart without losing context, and access durable storage. You either self-manage EC2 or accept the time limits of serverless.
Yesterday (August 6, 2026), AWS closed that gap with Runtime Instances in Amazon Bedrock AgentCore Runtime. This is not a replacement for the existing microVM-based runtime — it’s a complementary compute tier designed for workloads that need persistence, coordination, and GPU access beyond what ephemeral execution can provide.
What AgentCore Runtime Instances actually are
Runtime Instances are AWS-managed EC2 infrastructure provisioned through the AgentCore Runtime API. You deploy one or more agents into a single runtime instance, and those agents share the host’s filesystem, memory, and (optionally) GPU within sessions that persist for up to 14 days.
The key distinction from the existing AgentCore Runtime microVMs:
| microVMs | Runtime Instances | |
|---|---|---|
| Session duration | Up to 8 hours | Up to 14 days |
| Compute model | Ephemeral, per-invocation | Persistent, managed EC2 |
| Multi-agent | Separate isolation per agent | Multiple agents on same host |
| GPU support | No | Yes |
| State persistence | None (stateless) | EBS + AgentCore Memory |
| Cost model | Pay-per-use (invocation time) | EC2 instance hours + management fee |
| Stop/restart | N/A (terminates after execution) | Yes, preserves session state |
| Best for | Short tasks, burst execution | Long workflows, collaboration, GPU |
microVMs remain the right choice for short, isolated tasks — a tool call that runs for minutes, a code execution sandbox, a single-shot generation. Runtime Instances are for everything that doesn’t fit in an 8-hour window or needs agents to share context on the same machine.
Architecture and deployment model
The deployment model is straightforward. You package your agent code (one or more agents) and deploy it to a Runtime Instance. The instance runs on Linux (ARM64 or x86_64), supports Python 3.11 through 3.14, and accepts two packaging formats:
- Zip deployment — your code plus a manifest, uploaded directly
- Container deployment — a Docker image pushed to ECR or any OCI-compatible registry
Both use the same entry point pattern. Your agent code exposes endpoints through a simple decorator:
from agentcore import app
@app.entrypoint
def code_writer(session, task: str):
"""Agent that writes code based on a task description."""
workspace = session.filesystem("/workspace")
# Access shared session state
context = session.memory.recall(task)
# Write code to shared filesystem
code = generate_code(task, context=context)
workspace.write("solution.py", code)
# Signal the reviewer agent
session.notify("code_reviewer", {
"file": "/workspace/solution.py",
"task": task
})
return {"status": "written", "path": "/workspace/solution.py"}
@app.entrypoint
def code_reviewer(session, notification: dict):
"""Agent that reviews code written by the code_writer."""
workspace = session.filesystem("/workspace")
# Read from shared filesystem
code = workspace.read(notification["file"])
# Perform review
review = review_code(code, criteria=["correctness", "style", "security"])
if review.needs_changes:
session.notify("code_writer", {
"task": f"Revise based on feedback: {review.summary}",
"original_file": notification["file"]
})
return {"status": "reviewed", "passed": not review.needs_changes}This example shows two agents — a code writer and a reviewer — deployed together on the same Runtime Instance. They share a filesystem within the session, communicate through notifications, and can iterate without any external coordination layer. The session persists their state, so if one agent is idle while the other works, no context is lost.
The @app.entrypoint decorator is all AgentCore needs to discover and route to your agents. No framework lock-in: the code inside can use CrewAI, LangGraph, LlamaIndex, Strands, or raw API calls. AgentCore handles the infrastructure; your framework handles the orchestration.
Multi-agent coordination on a shared host
The defining feature of Runtime Instances is co-location. Multiple agents run on the same host and share:
- Filesystem — agents read and write to the same paths, enabling artifact passing without S3 round-trips
- Session memory — AgentCore Memory provides long-term recall across the session’s lifetime
- Notifications — agents signal each other within the session
- GPU — when the instance type includes a GPU, all agents on the host can access it
This is fundamentally different from microVM isolation, where each agent runs in its own sandbox with no shared state. Runtime Instances trade strict isolation for collaboration efficiency. The security boundary moves from per-agent to per-instance — agents on the same instance trust each other, but different instances remain isolated.
For multi-agent patterns — supervisor/worker, pipeline, debate, ensemble — co-location removes the serialization and networking overhead that makes these patterns painful at scale. Agents communicate through shared memory and filesystem rather than API calls and queues.
Session lifecycle and cost management
Sessions on Runtime Instances persist for up to 14 days. During that time, you can stop and restart the instance to save costs during idle periods. Stopping preserves the session state (EBS volumes, AgentCore Memory) without incurring compute charges.
This maps well to workloads with irregular activity patterns:
- A research agent that runs for 6 hours, waits for human review, then runs another 4 hours the next day
- A CI/CD agent pipeline that activates on commits and sleeps between them
- A data processing workflow that runs nightly but maintains state across runs
The stop/restart model means you’re not paying for a running EC2 instance during the gaps. You pay for EBS storage (pennies per GB-month) and resume where you left off.
GPU acceleration
Runtime Instances support GPU-accelerated instance types. This opens use cases that were previously impossible in AgentCore:
- Local model inference — run smaller models locally on the instance rather than calling external APIs, reducing latency and cost for high-volume inference
- Embedding generation — generate embeddings on-instance for RAG pipelines without network round-trips
- Code execution with GPU — agents that run CUDA workloads, ML training, or image/video generation
- Hybrid inference — use local models for cheap tasks and Bedrock APIs for complex reasoning
GPU support is the clearest differentiator from microVMs, which are CPU-only and time-limited. If your agent needs to run a fine-tuned model locally or execute GPU-accelerated code, Runtime Instances are the only path within AgentCore.
Storage and memory
Runtime Instances integrate with two persistence layers:
Amazon EBS — standard block storage attached to the instance. Survives stop/restart cycles. Use it for working files, agent artifacts, databases, or anything that needs filesystem durability beyond the session.
AgentCore Memory — a managed memory service that provides long-term recall for agents. Agents can store and retrieve context across sessions, enabling workflows that span multiple session lifetimes. Think of it as the agent’s long-term memory that persists even after the 14-day session window expires.
Together, these give agents both short-term working storage (EBS) and indefinite recall (Memory), which is the combination needed for agents that maintain context over weeks or months of intermittent operation.
Pricing model
Runtime Instances use a transparent pricing model:
- Standard EC2 pricing for the instance type you select (on-demand rates)
- Management fee on top of EC2 costs, covering AgentCore orchestration, session management, health monitoring, and the managed deployment infrastructure
This is simpler than trying to estimate costs for serverless invocations at scale, and more predictable for long-running workloads. If your agents run for hours or days, the per-invocation cost of microVMs can exceed the cost of a dedicated instance — Runtime Instances give you a fixed hourly rate instead.
The stop/restart capability is the key cost lever. An instance running 8 hours per day at an on-demand rate costs roughly a third of running 24/7. For workloads with idle periods, this is significantly cheaper than keeping a microVM session alive at the per-second invocation rate.
When to use microVMs vs Runtime Instances
Use microVMs when:
- Tasks complete in minutes to a few hours
- Each agent needs strict isolation from others
- You want pure pay-per-use with no idle cost
- The workload is stateless or state fits in the invocation payload
Use Runtime Instances when:
- Workflows span hours to days (up to 14 days)
- Multiple agents need to collaborate on shared state
- You need GPU acceleration
- Cost predictability matters more than per-second granularity
- Agents need persistent storage (EBS) across stop/restart cycles
The two options complement each other within the same AgentCore deployment. You might use microVMs for tool calls and short tasks while routing complex multi-agent workflows to Runtime Instances. AgentCore manages both through the same API surface.
Framework support
Runtime Instances are framework-agnostic. The @app.entrypoint pattern works regardless of what runs inside:
- CrewAI — deploy crew definitions as entrypoints, share context between crews on the same instance
- LangGraph — run graph-based workflows with persistent checkpointing to EBS
- LlamaIndex — deploy RAG pipelines with local embedding generation on GPU instances
- Strands — lightweight agent loops with shared filesystem coordination
You’re not locked into an AWS-specific framework. Your existing agent code deploys with minimal changes — add the decorator, package as zip or container, and deploy.
Region availability
Runtime Instances launched on August 6, 2026 in the following regions:
- US East: Ohio (us-east-2), N. Virginia (us-east-1)
- US West: Oregon (us-west-2)
- Asia Pacific: Mumbai (ap-south-1), Singapore (ap-southeast-1), Sydney (ap-southeast-2), Tokyo (ap-northeast-1)
- Europe: Frankfurt (eu-central-1), Ireland (eu-west-1)
Technical specifications
| Specification | Details |
|---|---|
| Operating system | Linux |
| Architectures | ARM64, x86_64 |
| Python versions | 3.11, 3.12, 3.13, 3.14 |
| Max session duration | 14 days |
| Deployment formats | Zip, Container (OCI) |
| GPU support | Yes (GPU instance types) |
| Storage | Amazon EBS, AgentCore Memory |
| Networking | VPC integration, security groups |
What this means for the agent infrastructure space
Runtime Instances represent AWS’s acknowledgment that agents need more than ephemeral compute. The agent runtime layer is becoming a first-class infrastructure category, and AWS is building it directly into Bedrock rather than leaving teams to self-manage EC2 with custom orchestration.
For teams currently evaluating agent sandboxes and runtimes, Runtime Instances add another option to the landscape — one that’s deeply integrated with the AWS ecosystem (IAM, VPC, CloudWatch, Bedrock models) and backed by EC2’s proven infrastructure.
The 14-day session limit and multi-agent co-location are the features that matter most here. They enable workflow patterns that were previously only possible with self-managed infrastructure: persistent research assistants, long-running development environments, multi-day data pipelines, and collaborative agent teams that share context without external coordination.
FAQ
Can I mix microVMs and Runtime Instances in the same application?
Yes. Both are compute options within AgentCore Runtime. You can route different tasks to different compute tiers based on duration, isolation requirements, or GPU needs. The same agent code deploys to both with the @app.entrypoint pattern.
What happens when the 14-day session expires? The session terminates and the instance is reclaimed. AgentCore Memory persists beyond the session, so agents can recall context when a new session starts. EBS volumes can be configured for retention or snapshot on termination.
Is there a cold start penalty? Starting a stopped instance takes the same time as starting an EC2 instance (typically 30–90 seconds depending on instance type). This is slower than microVM cold starts (sub-second) but acceptable for long-running workloads where start time is amortized over hours or days.
Can I SSH into a Runtime Instance? No. Runtime Instances are managed infrastructure. You interact with them through the AgentCore API, logs (CloudWatch), and the deployment interface. You don’t get shell access to the underlying EC2 instance.
What instance types are supported? Standard EC2 instance families including compute-optimized, memory-optimized, and GPU instances. Specific availability varies by region. Check the AgentCore pricing page for the current list.
How does this compare to running agents on plain EC2?
Runtime Instances add managed session lifecycle (14-day persistence, stop/restart), the AgentCore deployment model (@app.entrypoint), integrated memory, multi-agent routing, and health monitoring. You get the same EC2 performance without managing the orchestration yourself. The tradeoff is the management fee and less control over the instance configuration.
Can I use custom Docker images? Yes. Container deployments accept any OCI-compatible image. You can install arbitrary dependencies, system packages, and runtimes beyond Python. The only requirement is that your image exposes the AgentCore entrypoint interface.
