# Bedrock AgentCore gets "runtime instances"! Your AI agents can now keep running for up to 14 days!

Hi, it's Shii! Today I found a meaty AWS Blog post about AI agent infrastructure, so let's dig into it together.

## What was announced?

Over on the AWS Blog, AWS announced runtime instances, a new addition to Amazon Bedrock AgentCore. It's a new compute option that gives production AI agents persistent, AWS-managed EC2 infrastructure. The AWS Blog leans toward engineering content, so this post came with a lot of detail on the architecture and how to actually use it.

## The story so far

Until now, AgentCore Runtime relied on a microVM-based execution model. It's lightweight and works well for API calls and task routing, but it had some real limits:

- Hard to persist state across multi-step workflows
- No support for running continuously over multiple days
- No GPU access
- No direct OS access
- Hard to coordinate multiple agents tightly with each other

Teams that needed these capabilities had no choice but to build and operate their own EC2 instances.

## What changes

Runtime instances are "persistent, managed infrastructure purpose-built for complex agent workloads." You can now deploy multiple agents onto a single AWS-managed EC2-based runtime.

Here's what you get:

- Sessions that persist for up to 14 days, so long-running or multi-day workflows can keep going
- Multiple agents can share data through a shared filesystem, with no API calls needed
- Sessions can be stopped and resumed, which helps control cost during idle time
- Support for GPU-accelerated instance types, useful for compute-heavy tasks like code verification, security scanning, or GUI automation
- Works with multiple frameworks: CrewAI, LangGraph, LlamaIndex, Strands, and any model

What's interesting is that this isn't meant to replace the existing microVM Runtime. It's designed as a complementary compute option: a lightweight orchestrator (the microVM Runtime) handles API calls, task routing, and result aggregation, while specialized workers (runtime instances) take on compute-intensive tasks and persistent state management.

## Dive Deep

The post walks through a sample where a Writer agent generates code and a Reviewer agent reviews it. The mechanism is simple: agents sharing the same session ID can access a shared directory and exchange data through files (the path looks like /tmp/agentcore-session/{session_id}/).

```python
@app.entrypoint
def handler(event, context):
    task = event.get("task") or event.get("prompt")
    session_id = getattr(context, "session_id", None) or event.get("session_id")
    session_dir = SHARED_DIR / session_id
```

Setup boils down to three steps:

1. **Create a Capacity Provider**: configure a name, OS (Linux ARM64 or x86_64), allowed instance types (the post uses c7g.2xlarge as an example), VPC/subnets/security groups, storage (a gp3 volume by default), and a service role
2. **Create a Runtime and deploy your agent**: upload a zip file from S3, and specify the language runtime plus the entrypoint function marked with @app.entrypoint inside agent.py. A default IAM role can be created automatically
3. **Invoke your agent**: pass JSON input through the Runtime playground in the Management Console. To have multiple agents collaborate, use the same session ID across them

The language runtime supports Python 3.11 through 3.14 with native code execution, and container image packaging is also supported. On the security side, runtime instances inherit the same API set, identity management, observability, and policy controls as the existing microVM Runtime.

As for pricing, the post only says it's standard EC2 pricing plus a management fee for AgentCore orchestration, no specific rates are given.

Runtime instances are currently available in these 8 Regions:

- US East (Ohio, N. Virginia)
- US West (Oregon)
- Asia Pacific (Mumbai, Singapore, Sydney, Tokyo)
- Europe (Frankfurt, Ireland)

## Wrap-up

- Amazon Bedrock AgentCore now offers runtime instances, persistent, AWS-managed EC2 infrastructure
- Sessions persist for up to 14 days, and multiple agents can collaborate through a shared filesystem
- GPU-accelerated instance types are supported, and you can bring any framework (CrewAI, LangGraph, LlamaIndex, Strands) and any model
- It's designed as a complementary option to the existing microVM Runtime, combining a lightweight orchestrator with compute-intensive workers
- Pricing is standard EC2 pricing plus an AgentCore management fee, and it's available across 8 Regions in the US, Asia Pacific, and Europe

If you're building agent workflows that need to run for days, coordinate multiple agents tightly, or use a GPU in production, this is a feature worth checking out!