AgentCore harness in now generally available
Go from agent idea to production in minutes—no orchestration code required, with full model flexibility and built-in governance.
View original announcement →Visual Summary
graph TD
A{{AgentCore Harness}}:::announced
B((Developer)):::external
C([Declarative Config]):::feature
D(AgentCore Runtime):::compute
E(AgentCore Gateway):::compute
F(AgentCore Memory):::storage
G([Model Providers]):::feature
H(AgentCore Observability):::compute
I([AWS Skills Catalog]):::feature
J([Isolated MicroVM Sessions]):::feature
B ==>|"defines agent"| C
C ==>|"assembles"| A
A -->|"runs in"| D
D -->|"provisions"| J
A -->|"connects tools"| E
A -->|"persists state"| F
A -->|"invokes"| G
A -->|"traces actions"| H
A -.->|"attaches"| I
classDef announced fill:#ff9900,stroke:#ec7211,color:#fff,font-weight:bold
classDef compute fill:#e3f2fd,stroke:#1565c0,color:#1565c0
classDef storage fill:#e8f5e9,stroke:#2e7d32,color:#2e7d32
classDef feature fill:#fff3e0,stroke:#e65100,color:#e65100
classDef external fill:#f5f5f5,stroke:#616161,color:#616161
What's New
AWS has announced the general availability of the managed agent harness in Amazon Bedrock AgentCore, a fully managed orchestration layer that takes teams from agent concept to production deployment in minutes. Rather than requiring teams to hand-code the orchestration loop, tool execution, context management, and session isolation, AgentCore harness accepts a declarative configuration and assembles a production-grade agent environment automatically. The harness is designed to scale from initial prototype to enterprise production without requiring a rebuild, and supports exporting to code-based orchestration when custom control is needed.
How It Works
- Declarative configuration: Customers define an agent by specifying the model, tools, skills, and instructions in configuration; AgentCore assembles and continuously runs the orchestration loop without requiring custom loop code.
- Isolated microVM sessions: Each agent session runs in a secure, isolated microVM (backed by AgentCore Runtime), providing its own filesystem and shell so the agent can write and execute code within a sandboxed environment.
- Stateful memory across sessions: Short-term and long-term memories, files, and state persist across sessions even when the underlying microVM expires and is replaced, ensuring continuity for long-running workflows.
- Model-agnostic execution: Agents can use any model from Amazon Bedrock, OpenAI, Google Gemini, or any LiteLLM-compatible provider, and can switch models mid-session without losing context—enabling patterns like planning with one model and coding with another.
- Integrated tool connectivity: Agents connect to tools via AgentCore Gateway, MCP servers, or built-in capabilities including a browser, code interpreter, and web search; AWS skills from Git, S3, or the curated AWS skills catalog can be attached with a single toggle.
- Platform-native observability and governance: Every agent action is automatically traced through AgentCore Observability, with identity and security policies enforced through the same gateway, requiring no additional wiring.
- Escape hatch to custom orchestration: A single CLI command exports the harness to Strands-based code running on the same underlying compute and primitives; Claude Agent SDK export is coming soon, preserving all prior work.
- Safe rollout controls: Immutable versioning and named endpoints allow teams to roll out changes incrementally and roll back instantly by pointing an endpoint at an earlier version.
Why It's Important
- Eliminates the hardest part of agent development: Building a durable production harness—handling concurrency, isolation, state, scaling, and failure recovery—is where most teams spend the majority of their time today; AgentCore harness removes that undifferentiated heavy lifting entirely.
- Dramatically compresses time-to-production: A production-grade agent with memory, tool access, and session isolation can be running in minutes from a single configuration definition, versus weeks of infrastructure work.
- No prototype-to-production rewrite: The same configuration used on day one operates at scale, eliminating the common pattern of rebuilding agents when moving from proof-of-concept to production.
- Reduces operational complexity: Identity, memory, observability, and security governance are all provided by the same platform without additional integration work, reducing the surface area teams must manage.
- Enables model flexibility without risk: The ability to swap model providers mid-session without losing context or rewriting agent logic gives teams freedom to optimize for cost, performance, or capability at any point in the agent's lifecycle.
How It's Different
- Managed harness vs. self-hosted frameworks: Unlike open-source agent frameworks (LangChain, AutoGen, etc.) that require teams to build and operate their own hosting, scaling, and isolation infrastructure, AgentCore harness provides all of that as a managed service.
- Configuration-first vs. code-first: Most agent frameworks require writing orchestration code from the start; AgentCore harness starts from declarative configuration and only requires code when genuinely custom orchestration is needed.
- Model-decoupled architecture: The harness is explicitly decoupled from the model layer, allowing mid-session provider switching—a capability not natively supported by most framework-bound agent runtimes.
- Integrated platform vs. layered hosting: AgentCore harness is not a hosting wrapper around a third-party framework; it is a native piece of the AgentCore platform, sharing the same gateway, identity, memory, and observability primitives rather than integrating with them externally.
- Graceful escape to code: When custom orchestration is needed, the export path (Strands SDK, Claude Agent SDK coming soon) runs on the same compute and primitives—there is no platform migration, only a shift in how the loop is expressed.
- Per-session microVM isolation: Each session runs in its own isolated microVM, a stronger isolation boundary than thread- or process-level isolation used by typical self-hosted agent frameworks.
When to Prefer It
- Teams new to agent development: Organizations building their first production agents who want to avoid the infrastructure learning curve and get to a working, scalable agent quickly.
- Rapid prototyping with a production path: When you need to validate an agent use case quickly but cannot afford to throw away the prototype when moving to production.
- Multi-model workflow patterns: Use cases that benefit from using different models for different subtasks (e.g., a reasoning model for planning, a fast model for code generation) within a single agent session.
- Enterprise governance requirements: Deployments where every agent action must be audited, traced, and governed under organizational security policies from the first call, without building a custom observability and identity layer.
- Teams with limited MLOps capacity: Small teams or those without dedicated infrastructure engineers who need production-grade agent infrastructure without the operational overhead.
- Iterative agent improvement workflows: Teams that want to use AgentCore Evaluations and Optimization to score agent behavior on real traffic, run A/B tests, and roll out prompt or tool changes safely with instant rollback.
- Agents requiring persistent state and file access: Use cases where the agent must remember context across sessions, write and execute code, or share data across multiple agent instances via S3 or EFS.
- Gradual migration to custom orchestration: Teams that anticipate eventually needing custom orchestration logic but want to start fast and export to code only when the need is proven.
Availability
- GA status: Amazon Bedrock AgentCore harness is generally available as of June 17, 2026.
- Supported regions: Available in 15 AWS Commercial Regions: US East (N. Virginia), US East (Ohio), US West (Oregon), Europe (Frankfurt), Europe (Ireland), Europe (London), Europe (Paris), Europe (Stockholm), Asia Pacific (Mumbai), Asia Pacific (Singapore), Asia Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Seoul), Canada (Central), and South America (São Paulo). Note: AWS GovCloud (US-West) is listed for AgentCore Runtime but not for the harness specifically.
- Related features in GA: AgentCore Runtime, Memory, Gateway, Identity, Built-in Tools, Observability, Policy, Evaluations, and Optimization are also generally available across most of the same regions.
- Preview features: AgentCore Payments is in preview, available only in US East (N. Virginia), US East (Ohio), US West (Oregon), and Europe (Ireland).
- Export targets: Strands SDK export is available now; Claude Agent SDK as an export target is listed as "coming soon."
- Pricing: Not explicitly stated in the announcement; refer to the Amazon Bedrock AgentCore pricing page for current details.
- Documentation: Available at https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness.html
