AWS Builder Center
Amazon Bedrock AgentCore Runtime Instances: Persistent Compute for Production AI Agents

Amazon Bedrock AgentCore Runtime Instances: Persistent Compute for Production AI Agents

Explore how AgentCore Runtime Instances provide persistent, managed compute for long-running and multi-agent workloads requiring shared sessions, operating-system access or GPU acceleration.

Amazon Bedrock AgentCore Runtime Instances: Persistent Compute for Production AI Agents

AI agents are moving beyond simple question-and-answer interactions.
Modern agents may need to write and test code, process large datasets, operate desktop applications, collaborate with other agents or complete workflows that continue for several days.
These workloads introduce an important infrastructure question:
Where should an AI agent run when its work cannot be completed within a short, stateless invocation?
AWS has introduced Runtime Instances for Amazon Bedrock AgentCore, a new compute option designed for persistent and complex production AI-agent workloads.
Runtime Instances provide AWS-managed EC2 infrastructure where multiple agents can run, collaborate and share session data for up to 14 days.

The limitation of short-lived agent execution

Many agent workloads can be completed using short-lived compute.
For example, an agent might:
  1. Receive a user request.
  1. Call a foundation model.
  1. Invoke one or two tools.
  1. Return the result.
  1. End the session.
This model is effective for chat assistants, API automation, information retrieval and other request-driven workloads.
However, production agents are increasingly being asked to perform longer and more complicated tasks, such as:
  • Modernizing a large application
  • Generating, compiling and testing code
  • Running security scans
  • Operating graphical applications
  • Processing media using GPUs
  • Coordinating with multiple specialized agents
  • Pausing a workflow and resuming it later
  • Maintaining temporary files throughout a session
Traditionally, engineering teams had to build and manage the supporting EC2 infrastructure themselves. This included instance provisioning, networking, storage, security, monitoring, session management and scaling.
AgentCore Runtime Instances manage much of this infrastructure while integrating with AgentCore’s identity, observability and policy controls.

What are AgentCore Runtime Instances?

Runtime Instances are a persistent compute option within Amazon Bedrock AgentCore Runtime.
They provide managed EC2 capacity where developers can deploy one or more AI agents. Agents running within the same session can use a shared working environment, allowing them to exchange files and coordinate tasks without building separate data-transfer APIs.
Key capabilities include:
  • Sessions lasting up to 14 days
  • Multiple collaborating agents
  • Shared session storage
  • Direct operating-system access
  • GPU-accelerated instance support
  • Linux ARM64 and x86-64 environments
  • Python 3.11 through Python 3.14
  • Native-code and container support
  • Session stop and restart
  • Integration with AgentCore APIs and observability
  • Support for different agent frameworks and models
Developers can deploy agents as ZIP packages or container images.
Supported frameworks can include:
  • Strands Agents
  • CrewAI
  • LangGraph
  • LlamaIndex
  • Custom agent frameworks
The runtime is also model-agnostic, allowing teams to choose models based on each agent’s task.

Runtime microVMs versus Runtime Instances

AgentCore now provides complementary compute choices.
Requirement
Runtime microVMs
Runtime Instances
Execution style
Request-driven
Persistent
Maximum session duration
Up to 8 hours
Up to 14 days
Scaling
Fast, invocation-oriented
Dedicated managed capacity
Shared agent environment
Limited
Multiple agents can share a session
GPU support
Not the primary use case
Supported
Operating-system access
Restricted environment
Direct OS access
Best suited for
Lightweight and short-running agents
Long-running and compute-intensive agents
Runtime microVMs remain suitable for agents that respond to API requests, perform short workflows and scale rapidly.
Runtime Instances are more appropriate when agents require persistence, specialized hardware, shared files or direct access to the operating system.
The two compute types can also be combined.
A lightweight orchestrator agent running in a microVM could receive requests and distribute work to specialized agents running on Runtime Instances.

Example: A multi-agent software engineering team

Consider an AI-powered application-development workflow involving four agents:

Code-writer agent

The first agent receives a requirement and generates application code.

Code-review agent

The second agent reads the generated files and reviews them for bugs, maintainability and coding standards.

Security agent

The third agent scans the same files for vulnerabilities, exposed credentials and insecure dependencies.

Testing agent

The fourth agent compiles the application, executes automated tests and records the results.
All four agents can operate within the same persistent session.
The workflow could look like this:
User request ↓ Orchestrator agent ↓ Code-writer agent ↓ Code-review and security agents ↓ Testing agent ↓ Final report
Because the agents share a working environment, the reviewer can directly access files created by the writer. The security and testing agents can inspect the same workspace without copying the files to another system.
The session can be stopped during an approval stage and resumed later without restarting the entire workflow.

Persistent sessions and long-term memory are different

It is important to distinguish session persistence from long-term agent memory.
A Runtime Instance can preserve temporary files and execution state throughout a session lasting up to 14 days. This is useful for work in progress.
However, information that must survive after the session should be stored externally.
AWS suggests combining Runtime Instances with:
  • Amazon EBS for persistent storage
  • AgentCore Memory for long-term agent recall
  • Amazon S3 for durable artifacts
  • DynamoDB for workflow status and metadata
  • Amazon CloudWatch for logs and operational monitoring
A good design separates:
  • Temporary working state
  • Durable business data
  • Long-term agent memory
  • Application logs and audit records

Potential use cases

Software development

Agents can generate, review, compile, test and document code within a shared development environment.

Application modernization

Multiple agents can analyze a legacy repository, update different components and validate the modernized application over several days.

Security testing

An agent can run dependency scans, static analysis and approved penetration-testing workflows that require operating-system tools.

Data science

Agents can prepare datasets, train models, run experiments and use GPU-enabled environments.

Media processing

Long-running agents can coordinate video rendering, image processing or other compute-intensive workloads.

GUI automation

Agents requiring a persistent operating system can interact with applications that do not provide modern APIs.

Research workflows

Specialized agents can collect information, perform analysis and gradually produce a final report while maintaining intermediate artifacts.

Deployment approach

A typical implementation involves the following steps:
  1. Create an AgentCore capacity provider.
  1. Select the permitted EC2 instance types.
  1. Configure the VPC, subnets and security groups.
  1. Configure storage and an infrastructure role.
  1. Package the agent as a ZIP file or container image.
  1. Create an AgentCore Runtime using  Instances  as the compute type.
  1. Deploy multiple specialized agents to the capacity provider.
  1. Invoke the agents using the same session ID when they need to collaborate.
  1. Monitor their activity through AgentCore observability.
  1. Stop idle sessions and restart them when work resumes.
Runtime Instances use standard EC2 pricing together with a management fee for AgentCore orchestration.

Architecture considerations

Before selecting Runtime Instances, architects should evaluate several areas.

Workload duration

If the workflow finishes within minutes, persistent capacity may be unnecessary. Runtime microVMs may provide a more efficient design.

Session partitioning

Each user, project or workflow should receive an appropriately isolated session. Avoid mixing unrelated workloads within the same shared environment.

Storage

Determine which files are temporary and which must be stored durably in Amazon S3, EBS or another data service.

Security

Use least-privilege IAM roles, private networking and restricted security groups. Agent tools should receive only the permissions required for their assigned tasks.

Human approval

Sensitive actions such as production deployment, financial transactions or destructive changes—should include explicit approval steps.

Observability

Record model calls, tool usage, execution duration, errors and state transitions. Long-running autonomous workflows require more than basic infrastructure monitoring.

Cost management

Choose appropriate EC2 capacity, stop idle sessions and use specialized GPU instances only when required.

Failure recovery

Store workflow checkpoints outside the runtime so an interrupted agent can resume safely without repeating completed actions.

Regional availability

At launch, Runtime Instances are available in selected AWS Regions, including:
  • US East (Ohio and Northern Virginia)
  • US West (Oregon)
  • Asia Pacific (Mumbai, Singapore, Sydney and Tokyo)
  • Europe (Frankfurt and Ireland)
Developers should confirm current regional availability before finalizing an architecture.

Why this announcement matters

The first generation of enterprise AI applications focused heavily on selecting the right foundation model.
The next challenge is operational:
  • Where will agents execute?
  • How will they maintain state?
  • How will multiple agents collaborate?
  • How will they access specialized compute?
  • How will organizations secure and monitor their actions?
AgentCore Runtime Instances address this infrastructure layer.
They do not simply provide another place to call an LLM. They provide a managed working environment where autonomous agents can perform longer, more complex and collaborative tasks.

Final thoughts

Runtime Instances represent an important shift in AI-agent architecture.
Agents are evolving from short-lived assistants that answer questions into long-running digital workers that create artifacts, use software, collaborate and continue working across multiple sessions.
A practical architecture will likely use both AgentCore compute options:
  • Runtime microVMs for fast, request-driven orchestration
  • Runtime Instances for persistent and compute-intensive execution
The foundation model remains the agent’s reasoning engine but Runtime Instances provide the workplace where complex work can actually happen.

References

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article