Skip to main content
SYS.ONLINE

Amazon Bedrock AgentCore 00: Overview

· 10 min read
Chiwai Chan
Tinkerer

These are the slides from part 00 of my Amazon Bedrock AgentCore series for the AWS User Group Wellington — a high-level tour of every AgentCore service and how the pieces fit together, before the later decks go deep on each one.

Series: Amazon Bedrock AgentCore deck series

Event: AWS User Group Wellington — November 2026 (#83)
When: Thursday 5 November 2026, 4:30–6:30 PM NZDT
Where: Datacom Wellington, 55 Featherston Street, Pipitea, Wellington 6011

Tip: click into the slides and use the arrow keys to navigate, or hit the fullscreen button for the best experience.

Download the slides: PDF · PowerPoint

Were you at the talk?​

Rate it — anonymous, and under a minute.

QR code that opens the anonymous feedback form for this session

Open the feedback form — or enter event code 5A36OI at feedbackfeijoa.com.

Every slide is built from the AWS AgentCore Developer Guide and cites the doc pages it is based on.

The big picture​

What is Amazon Bedrock AgentCore?​

  • An agentic platform to build, deploy and operate agents securely at scale
  • Works with any framework and any foundation model
  • No infrastructure to manage
  • Modular: use services together or independently
  • Frameworks named: CrewAI, LangGraph, LlamaIndex, Strands Agents

Open-source flexibility and enterprise-grade security — you don't have to choose.

Problems it solves​

  • Run agents securely at scale — isolated sessions, serverless hosting
  • Act across tools and data with the right permissions and governance
  • Monitor performance and quality in production
  • Remember context across turns and sessions (agents are otherwise stateless)
  • Improve continuously with evaluations, recommendations and A/B tests

What can you build?​

Use caseWhat it looks like
AgentsAutonomous apps that reason, use tools, keep context
Tools & MCP serversTurn APIs, Lambda or OpenAPI specs into MCP tools
Agent platformsA paved path: approved tools, shared memory, governed access

How the services fit together​

LayerServices
Build & runHarness (managed loop) · Runtime (host your code)
ContextMemory (short-term + long-term)
Tools & connectivityGateway · Code Interpreter · Browser · Payments
Trust & governanceIdentity · Policy · Registry
Operate & improveObservability · Evaluations · Optimization

Harness runs inside Runtime; Policy enforces at Gateway; Optimization builds on Evaluations.

Service map​

AgentCore services grouped into five areas, with Harness running inside Runtime, Policy enforcing at Gateway, and Optimization building on Evaluations

A request, end to end​

A user or app invokes the Runtime agent with inbound auth from Identity; the agent uses Memory, Code Interpreter, Browser and Gateway, which Policy evaluates and which calls Lambda, APIs and MCP servers

Build & run​

Harness — a managed agent loop​

  • Declare model, system prompt, tools, skills as configuration; AgentCore runs the loop
  • Each session: isolated microVM with its own filesystem and shell
  • Models from Amazon Bedrock, OpenAI, Google Gemini, or LiteLLM-compatible providers
  • Switch model providers mid-session without losing context
  • Tools via AgentCore Gateway, MCP servers, built-in Browser and Code Interpreter
  • Powered by Strands Agents; no separate harness charge

Harness — lifecycle and when to graduate​

  • Built-in short-term and long-term memory; bring your own container
  • Mount S3 Files or EFS to share data across sessions
  • Immutable versions + named endpoints for safe rollout and rollback
  • InvokeHarness state in AWS Step Functions
  • Export to Strands code and run on Runtime when config isn't enough
  • GA in all regions where AgentCore is supported

Harness vs. Runtime​

HarnessRuntime
Orchestration loopProvided (Strands)Yours
How you add featuresConfig fieldCode (usually AgentCore SDK)
Choice of frameworkNoYes
Bidirectional streamingNoYes
Graph / workflow patternsNoYes
Session isolation, VPC, versioningYesYes

Runtime — serverless hosting for agents and tools​

  • Framework agnostic: LangGraph, Strands, CrewAI or custom code
  • Any model: Amazon Bedrock, Anthropic Claude, Google Gemini, OpenAI
  • Protocols: MCP and Agent to Agent (A2A)
  • Each session in a dedicated microVM; memory sanitized when it ends
  • Up to 8 hours per session on microVMs, 14 days on Instances
  • 100MB payloads; HTTP plus WebSocket bidirectional streaming

Runtime — key building blocks​

  • Runtime: hosts your agent or tool code; has a unique identity
  • Versions: immutable snapshots; each config update creates a new one
  • Endpoints: addressable pointers to a version; DEFAULT tracks latest
  • Sessions: identified by runtimeSessionId, isolated microVM each
  • Consumption-based pricing: CPU billing aligned to active processing
  • Built-in inbound auth via AgentCore Identity (Okta, Entra ID, Cognito)

Context & connectivity​

Memory — context-aware agents​

TypeWhat it holdsExample
Short-termTurn-by-turn events in one session"What about tomorrow?" after a Seattle weather question
Long-termInsights extracted across sessionsRemembering a window-seat preference
  • Long-term records come from strategies added to the memory resource
  • Built-in strategies: semantic, user preference, summary, episodic
  • Also built-in overrides and self-managed strategies

Gateway — one secure entry point for agentic traffic​

  • Converts APIs, Lambda functions and services into MCP tools
  • Fronts other agents and HTTP services (incl. A2A) via passthrough
  • Routes inference across model providers by the requested model
  • Inbound and outbound authentication in one managed service
  • Semantic tool search across thousands of tools
  • 1-click integrations: Salesforce, Slack, Jira, Asana, Zendesk

Gateway — target categories​

CategoryBehaviourExamples
MCPAggregated into one virtual MCP serverLambda, API Gateway, OpenAPI, Smithy, MCP servers, integrations, connectors
HTTPDirect, no aggregation or translationAgentCore Runtime agents, A2A agents, passthrough
InferenceModel-based routing to providersAmazon Bedrock, OpenAI, Anthropic
  • Inbound auth: OAuth (JWT), IAM (SigV4), authenticate-only, or none

Identity — identity for agents and workloads​

  • Agent identities are workload identities in a central directory
  • Token vault: stores OAuth tokens, client credentials and API keys, KMS-encrypted
  • OAuth 2.0 client credentials (2LO) and authorization code (3LO) flows
  • Built-in providers: Google, GitHub, Slack, Salesforce, Atlassian (Jira)
  • SDK decorators: @requires_access_token, @requires_api_key
  • Native integration with Runtime and Gateway

Payments — microtransactions for agents​

  • Lets agents pay for APIs, MCP servers and content
  • Protocols: x402 and Machine Payments Protocol (MPP), both on HTTP 402
  • Wallet providers: Coinbase CDP and Stripe (Privy)
  • Per-session budget (maxSpendAmount, currency) plus an expiry time
  • Coinbase x402 Bazaar MCP server exposed through AgentCore Gateway
  • Launched in Preview (May 2026)

Code Interpreter — sandboxed code execution​

  • Agents write and run code in an isolated sandbox
  • Languages: Python, JavaScript, TypeScript
  • Pre-built runtimes with common libraries pre-installed
  • Files: up to 100 MB inline; up to 5 GB via S3 with terminal commands
  • Default 15-minute execution, extendable up to 8 hours
  • Custom session properties and network modes; CloudTrail logging

Browser — a managed cloud browser​

  • Isolated, containerized browser for agents to use web apps
  • AWS managed aws.browser.v1, or a custom browser (recording, network, IAM role)
  • Sessions: default 15 minutes, maximum 8 hours; run many at once
  • Automation endpoint (WebSocket) — Strands, Nova Act, Playwright
  • Live View lets an end user watch and interact in real time
  • Session recording to your S3 bucket, replay in the console

Operate & govern​

Observability — trace, debug, monitor​

  • Step-by-step visualisation of the agent's execution path
  • CloudWatch dashboards: sessions, latency, duration, tokens, errors
  • Telemetry in OpenTelemetry (OTEL)-compatible format
  • Built-in metrics for agents, gateways and memory by default
  • Instrument your code for extra spans, metrics and logs
  • All data stored in Amazon CloudWatch

Policy — deterministic control over tool calls​

  • Policy engines associated with gateways; every tool call evaluated first
  • Enforced at the gateway boundary, outside agent code
  • Author in Cedar, natural language, or Dogwood
  • Principals: AgentCore::OAuthUser (JWT) or AgentCore::IamEntity (IAM)
  • Temporal policies reason over a session's action history
  • Decisions logged via CloudWatch for audit

Evaluations — measure agent quality​

TypeWhen
OnlineContinuously, sampling live production sessions
On-demandTargeted, on chosen span or trace IDs
BatchAsync job over many sessions; aggregate scores
  • Evaluators: built-in (LLM-as-a-judge), third-party (DeepEval, AutoEval), custom
  • Custom: your own LLM judge or code-based via Lambda
  • Frameworks: Strands, LangGraph with OpenTelemetry / OpenInference

Optimization — the improvement loop​

  1. Recommendations: optimised system prompt or tool descriptions from traces
  2. Configuration bundles (optional): versioned, immutable config snapshots
  3. A/B testing: split traffic via Gateway; online evals report significance
  4. Promote the winner, then repeat from the new baseline

Builds on AgentCore Evaluations — you pick the target evaluator to optimise for.

AWS Agent Registry — discover and govern​

  • Central catalog: MCP servers, agents, tools, skills, custom resources
  • Registries hold records; approval workflow gates discoverability
  • Hybrid search: semantic + keyword
  • Native MCP endpoint for MCP-compatible clients
  • Authorization: IAM or JWT from your corporate IdP
  • GA (August 2026) with AWS Organizations auto-detection

Security — shared responsibility​

  • AWS secures the cloud; you secure what you run in it
  • Data at rest encrypted by default (AWS owned KMS keys); TLS 1.2+ in transit
  • Gateways can use a customer-managed KMS key
  • Resource-based policies for Runtime, Gateway and Memory
  • Use aws:SourceArn / aws:SourceAccount against confused deputy
  • VPC and AWS PrivateLink options

Getting started​

Availability at a glance​

MilestoneWhen
Initial release (preview)July 2025
AgentCore GA in nine regionsOctober 2025
Policy, Evaluations, AgentCore CLI GAMarch 2026
Payments in PreviewMay 2026
Harness, Recommendations, Batch evals, A/B testing GAJuly 2026
Failure Insights public previewJuly 2026
AWS Agent Registry GAAugust 2026

Availability timeline​

Timeline from the July 2025 preview and October 2025 GA through Policy, Evaluations, Payments, Harness and Agent Registry releases up to August 2026

Getting started — the AgentCore CLI​

npm install -g @aws/agentcore
agentcore create # Harness, Agent, or Skip
agentcore dev # local server + agent inspector
agentcore deploy # CDK under the hood
agentcore invoke --prompt "Hello, what can you do?"
  • Needs Node.js 20+; Python 3.10+ for agent code
  • Build types: CodeZip (default, no Docker) or Container
  • Add capabilities: agentcore add memory | gateway | credential | evaluator

Interfaces for AgentCore​

InterfaceUse it for
AgentCore CLICreate, dev, deploy, invoke, status
AgentCore Python SDKRuntime, Memory, Tools, Identity, Evaluations primitives
AgentCore MCP serverTransform, deploy, test from Kiro, Cursor, Claude Code, Amazon Q CLI
AWS SDK / AWS CLIFull control plane + data plane APIs
AgentCore consoleManage services, agent sandbox testing

CLI and Python SDK don't cover every operation — fall back to the AWS SDK.

Where to go next​

#Deck#Deck
01Getting Started & Tooling09Browser
02Harness10Observability
03Runtime11Policy
04Memory12Evaluations
05Gateway13Optimization
06Identity14Agent Registry
07Payments15Security
08Code Interpreter