Cloud service · AWS · Updated

Amazon Bedrock AgentCore - Amazon Bedrock AgentCore is a set of managed AWS services for deploying, securing, and operating AI agents and their supporting tools.

In short

Amazon Bedrock AgentCore provides infrastructure for agent execution, memory, tool access, identity, browser automation, code execution, and observability. Its components can be used independently or together with different agent frameworks and foundation models, including models accessed through Amazon Bedrock.

Cloud Services Hub →

10 key features of Amazon Bedrock AgentCore

01
Managed agent runtime

Deploy agent code and dependencies to AgentCore Runtime rather than managing an agent-serving fleet. Configure workload permissions, authentication, and session handling to match the application's execution requirements.

02
Short-term and long-term memory

Store interaction events and use configured strategies to extract longer-term information for subsequent conversations. Use stable actor and session identifiers, and retrieve only the memories relevant to the current request.

03
MCP-based tool gateway

Expose supported APIs and Lambda functions as tools through AgentCore Gateway. This provides a consistent tool interface while leaving business validation and resource-level authorization in the underlying implementation.

04
Agent identity and downstream access

Use AgentCore Identity to manage agent identities and access to downstream services, including supported OAuth and API-key authentication flows. Keep user authorization distinct from the agent workload's own permissions.

05
Managed browser automation

Run browser interactions in managed sessions for tasks that require navigating web applications. Add explicit checks before submitting forms, publishing content, or taking other actions with external effects.

06
Isolated code execution

Use Code Interpreter to execute code for calculations, analysis, and file-processing tasks without running generated code inside the agent application's process. Validate inputs and outputs and apply appropriate controls to sensitive files.

07
Operational observability

Use AgentCore Observability and Amazon CloudWatch to investigate agent execution, model calls, and tool activity. Add application instrumentation and correlation identifiers to connect failures across the agent and its downstream dependencies.

08
Framework and model flexibility

Use AgentCore infrastructure with different agent frameworks and model providers. Model invocation, orchestration logic, and tool-selection policies remain application design choices rather than being prescribed by the runtime.

09
Policy-based action governance

Use AgentCore Policy to apply policy-based governance to agent actions.

10
Agent quality evaluations

Use AgentCore Evaluations to assess agent quality through online and on-demand testing.

Where Amazon Bedrock AgentCore is used

  1. 01
    Enterprise service assistants

    Deploy an assistant that answers internal questions and invokes approved business tools. Combine Runtime, Gateway, and downstream authorization so actions such as opening a support ticket use narrowly scoped permissions.

  2. 02
    Personalized customer support

    Use Memory to retain relevant preferences and conversation context across support sessions. Keep account records in authoritative systems and verify the customer's identity before retrieving or changing account-specific information.

  3. 03
    Data analysis agents

    Use Code Interpreter to calculate metrics, transform supplied datasets, or generate analytical outputs. Store source data and results separately from conversation memory, and validate important calculations before using them in business decisions.

  4. 04
    Web application automation

    Use Browser for workflows involving applications without suitable APIs, such as collecting information from an internal portal. Handle authentication explicitly and require approval before irreversible submissions.

  5. 05
    Multi-tool operational workflows

    Expose operational APIs through Gateway so an agent can inspect incidents, retrieve diagnostics, and propose remediation. Keep destructive operations behind explicit authorization or human approval, and make retryable actions idempotent.

How Amazon Bedrock AgentCore is priced

Runtime compute consumption

AgentCore Runtime uses consumption-based pricing for compute resources, including CPU and memory. CPU charging distinguishes active processing from supported waiting periods, while memory consumption depends on allocation and duration; consult current pricing for precise metering rules.

Memory usage

AgentCore Memory charges depend on the memory operations used, such as storing short-term events and extracting or retrieving long-term memory. Estimate costs from conversation volume, configured extraction strategies, and retrieval frequency.

Gateway and identity usage

Gateway and Identity have component-specific usage pricing. Estimate tool discovery and invocation traffic, authentication activity, and credential-access patterns, and review any pricing exceptions for use with other AgentCore components.

Browser and code execution

Browser and Code Interpreter are metered separately according to their execution resource usage. Control session duration and terminate sessions when work finishes to avoid unnecessary consumption.

Associated AWS service charges

Budget separately for foundation model inference and services used by the application, such as Lambda, Amazon S3, and CloudWatch. Logging, tracing, data transfer, and external API charges can contribute materially to total workflow cost.

Services Amazon Bedrock AgentCore works with

A common architecture places an application frontend in front of an AgentCore Runtime endpoint, with Amazon Cognito providing user authentication when JWT-based access is configured. The runtime invokes Amazon Bedrock for model inference and uses AgentCore Gateway to discover and call approved tools. Lambda-backed tools encapsulate business operations, validate arguments, and enforce resource-level authorization before accessing internal systems.

Use Amazon S3 for durable documents and generated artifacts, while AgentCore Memory holds conversation events and selected longer-term context. Keep these responsibilities separate: a remembered customer preference is not an authoritative account record, and a runtime session is not durable workflow storage. Pass controlled object references where possible instead of repeatedly placing large files into prompts.

Send operational telemetry to CloudWatch and correlate runtime requests with model calls and downstream tool activity. Apply least-privilege IAM permissions to each execution path, configure supported downstream authentication through AgentCore Identity where appropriate, and use approval gates for consequential actions. Design tools for retries and partial failures so a repeated agent request does not duplicate a business transaction.

Amazon Bedrock

Agent applications hosted in AgentCore Runtime can invoke foundation models through Amazon Bedrock using AWS SDKs or supported framework integrations. For example, an agent can use a Bedrock model to decide which Gateway tool to call, then summarize the tool's response. Grant the runtime execution role only the required model invocation permissions and account for model inference charges separately.

AWS LambdaAWS Lambda

AgentCore Gateway can expose Lambda-backed functionality as MCP tools. For example, a function can validate a customer identifier and retrieve an order status from an internal system. Configure the required invocation permissions and enforce business authorization inside the tool rather than trusting model-generated arguments.

Amazon CloudWatchAmazon CloudWatch

AgentCore Observability uses CloudWatch capabilities to help operators inspect agent telemetry. For example, correlate a slow response with model latency, tool execution time, and application errors using emitted traces and logs. Configure instrumentation, retention, alarms, and access controls, and prevent credentials or sensitive conversation content from being logged unnecessarily.

Amazon CognitoAmazon Cognito

Amazon Cognito can provide OAuth access tokens for JWT-authenticated access to AgentCore endpoints configured with the appropriate issuer and client settings. For example, a signed-in web application can obtain a token and invoke an agent on behalf of its user. Endpoint authentication does not automatically authorize access to every downstream record, so enforce tenant and resource permissions separately.

Amazon S3Amazon S3

Agent application code can use Amazon S3 for input documents, datasets, and generated artifacts through AWS SDK calls. For example, an analysis agent can read an approved CSV object and write a report to a separate output prefix. Scope the execution role to the required objects and use controlled download access rather than embedding unrestricted object links in responses.

Amazon API GatewayAmazon API Gateway

Amazon Bedrock AgentCore Gateway can expose Amazon API Gateway REST API operations as MCP tools. Agents can discover and invoke selected API operations through the gateway rather than implementing separate API clients.

Amazon Elastic Container Registry (Amazon ECR)Amazon Elastic Container Registry (Amazon ECR)

Amazon Bedrock AgentCore Runtime deploys containerized agents and tools from images stored in Amazon ECR. Its execution role grants access to pull the image used for a runtime deployment.

Amazon VPCAmazon VPC

Amazon Bedrock AgentCore supports VPC connectivity for runtimes and built-in tools that need access to private resources. Configured subnets and security groups let an agent reach an internal database or let a browser session access a private website.

AWS CloudFormationAWS CloudFormation

Amazon Bedrock AgentCore resources can be provisioned and managed through AWS CloudFormation resource types. Templates can define resources such as runtimes, gateways, and memories alongside their permissions and supporting infrastructure.

AWS CloudTrailAWS CloudTrail

Amazon Bedrock AgentCore integrates with AWS CloudTrail to record supported API activity. These records let administrators audit who created, changed, or deleted AgentCore resources.

Amazon Bedrock AgentCore exam questions

Real practice exam questions on Amazon Bedrock AgentCore, with the correct answer and its explanation. Answer them with every option in the exam simulator.

AIB-C01 (beta)

An energy company has built an AI agent that investigates unusually high electricity bills. The agent chooses which account records and meter readings to inspect, then uses the results to decide whether further checks are needed. The required operations already exist as supported business APIs and AWS Lambda functions. The company wants to retain its agent's decision logic while giving it a consistent way to discover and invoke these operations, with minimal custom integration code. Which solution best meets these requirements?

Show answerCORRECT ANSWER

Use Amazon Bedrock AgentCore Gateway to expose the existing operations as MCP tools, and connect the agent to that tool interface while retaining its decision logic.

AgentCore Gateway can expose supported APIs and Lambda functions through a consistent Model Context Protocol (MCP) tool interface, reducing custom adapter code. The existing agent still selects actions and evaluates results; Gateway provides tool connectivity rather than replacing the agent's reasoning.

MLA-C02 (beta)

A company hosts a conversational agent on Amazon Bedrock AgentCore Runtime. Users reuse the same runtime session for many conversation turns. Memory consumption rises during the business day, but model token usage per turn remains stable. Engineers need to determine whether individual sessions retain progressively more memory between turns or whether the increase is explained only by a larger number of concurrent sessions. They can add application instrumentation but must not change production session behavior.

Which monitoring approach best meets these requirements?

Show answerCORRECT ANSWER

Emit structured memory measurements at consistent, quiescent points between turns, with session ID, turn number, timestamp, and in-flight operation count. Use CloudWatch Logs Insights to compare memory trends within individual sessions and correlate them with concurrent session counts.

Session-level measurements taken when no operations are in flight distinguish retained memory from temporary processing demand. Comparing successive measurements within the same session reveals growth across turns, while concurrent-session counts help distinguish that pattern from an increase in the number of sessions. Session identifiers can remain log fields rather than creating a custom metric time series for every session.

SAP-C03

A company runs an incident-analysis agent on Amazon Bedrock AgentCore Runtime in a tooling account. The agent retrieves application logs from the s3://central-incident-data/production/ prefix in a security account. It needs to list objects in that prefix and read their contents, but it must never upload or delete objects.

The agent currently assumes a role in the security account that permits reading, uploading, and deleting objects throughout the bucket. Automated remediation workloads also assume this role and must retain their existing permissions. The agent's runtime execution role has no direct S3 permissions.

A security review requires the agent's AWS permissions to prevent unauthorized operations even if compromised agent code makes arbitrary AWS SDK calls. Changes must not disrupt the remediation workloads.

Which solution meets these requirements?

Show answerCORRECT ANSWER

Create a dedicated role in the security account that trusts only the agent's runtime execution role. Allow GetObject only for objects under production/ and ListBucket only with an s3:prefix condition limited to that prefix. Allow the runtime role to assume only this dedicated role, and remove its access to the shared role without changing remediation access.

A dedicated role limits the agent's effective S3 permissions to the required actions and resources. The prefix condition constrains bucket listing, and the object resource scope constrains reads. Removing the agent's assumption path to the shared role prevents compromised code from obtaining its broader permissions while preserving remediation access.

Practice Amazon Bedrock AgentCore in a full exam

Questions on Amazon Bedrock AgentCore in each practice exam, with every answer option and an explanation for each:

Start a free practice exam

What is Amazon Bedrock AgentCore

2 min read

Amazon Bedrock AgentCore provides managed infrastructure for moving AI agents from application development into production. It addresses execution, state, authentication, tool connectivity, and operational visibility without requiring every application team to build those capabilities separately. AgentCore is not a foundation model or an agent reasoning framework; application code still defines the agent's instructions, model selection, orchestration, and permitted actions.

AgentCore Runtime hosts agent applications in isolated execution environments and manages the underlying execution infrastructure. Developers package their agent code with its dependencies, configure an execution role and authentication, and invoke the deployed agent through its endpoint. Runtime supports interactive and longer-running agent workloads. Keep session identifiers consistent when continuing an interaction, and distinguish runtime session state from durable application records.

AgentCore Runtime provides serverless execution and supports asynchronous tasks.

AgentCore Memory stores interaction events and can derive longer-term information, such as user preferences or summaries, using configured memory strategies. Applications explicitly write events and retrieve relevant memories during agent execution. Design actor identifiers, session identifiers, retention settings, and access controls before storing production conversations. Memory retrieval can improve continuity, but it does not replace an authoritative transactional database or eliminate the need to validate retrieved information.

AgentCore Gateway makes tools available to agents through the Model Context Protocol, or MCP. It can expose supported targets, including AWS Lambda functions and APIs described by supported schemas, through a consistent tool interface. Gateway reduces the amount of custom adapter code an agent needs, but tool implementations remain responsible for input validation, authorization, transaction handling, and safe error reporting.

AgentCore Identity supports authentication and credential handling for agents accessing AWS resources and external services. Separate the identity of the caller, the permissions of the agent workload, and credentials used for downstream systems. Use narrowly scoped permissions and avoid placing access tokens or secrets in prompts, tool descriptions, or conversation history.

AgentCore security controls include dedicated micro virtual machines (microVMs) for session isolation, encrypted credential storage, namespace-based memory isolation, and comprehensive audit logging.

AgentCore Browser and Code Interpreter provide managed environments for browser automation and code execution. Browser is useful when a workflow requires interacting with a website rather than a supported API. Code Interpreter supports tasks such as calculations and data transformation. Treat web pages, downloaded files, and generated code as untrusted inputs, and restrict sensitive data exposure and consequential actions.

AgentCore Observability integrates operational telemetry with Amazon CloudWatch. Instrument model calls, tool invocations, and application operations so engineers can investigate latency, errors, and unexpected execution paths. Before production deployment, verify component availability in the target Region, review quotas, configure logging and retention, and test failure handling. Apply timeouts, retry limits, approval gates, and idempotency controls wherever agents can change external systems.

Learn Amazon Bedrock AgentCore in lessons

12 short lessons on Amazon Bedrock AgentCore in 5 certification courses.

and 6 more lessons

Open the lessons

Concepts related to Amazon Bedrock AgentCore

AWS architecture icons are the property of Amazon Web Services. BlowStack is not affiliated with or endorsed by AWS.