Amazon Bedrock AgentCore (Preview) Pricing

AgentCore Runtime is a secure, serverless runtime purpose-built for deploying and scaling dynamic AI agents and tools.

Consumption-based pricing
You only pay for what you use, with no pre-configuration of resources required. For CPU resources, you are charged when your agent is actively processing (not during I/O wait periods if you are just waiting for LLM responses). For memory resources, you're only charged for the memory your agent is consuming. 

Key details:

• No upfront resource selection required
• Billing is calculated per second, using the highest CPU and memory usage values recorded during that second, with a 1-second minimum
• 128MB minimum memory billing applies
• Network data transfer through customer ENIs is billed at standard EC2 rates

AgentCore Browser tool provides a fast, secure, cloud-based browser runtime to enable AI agents to interact with websites at scale.

Consumption-based pricing
You only pay for what you use, with no pre-configuration of resources required. For CPU resources, you are charged only when your tool is actively processing (not during I/O wait periods if you are just waiting for LLM responses). For memory resources, you're only charged for the memory your agent is consuming.

Key details:

• No upfront resource selection required
• Billing is calculated per second, using the highest watermark of CPU and memory usage for that second, with a 1-second minimum
• 128MB minimum memory billing applies
• Network data transfer through customer ENIs is billed at standard EC2 rates

AgentCore Code Interpreter tool enables AI agents to write and execute code securely in sandbox environments, enhancing their accuracy and expanding their ability to solve complex end-to-end tasks.

Consumption-based pricing
You only pay for what you use, with no pre-configuration of resources required. For CPU resources, you are charged only when your tool is actively processing (not during I/O wait periods if you are just waiting for LLM responses). For memory resources, you're only charged for the memory your agent is consuming.

Key details:

• No upfront resource selection required
• Billing is calculated per second, using the highest watermark of CPU and memory usage for that second, with a 1-second minimum
• 128MB minimum memory billing applies
• Network data transfer through customer ENIs is billed at standard EC2 rates 

AgentCore Gateway provides a secure way for agents to discover and use tools along with easy transformation of APIs, Lambda functions, and existing services into agent-compatible tools.

Consumption-based pricing
You pay only for the API calls your agents make through Gateway. You're charged based on the number of tool operations (ListTools and InvokeTool), search queries, and tools indexed for semantic search functionality. 

Key details:

• No upfront costs or minimum commitments required
• ListTools and InvokeTool APIs are metered in 128KB data transfer increments

AgentCore Identity simplifies agent identity and access management and allows your agents to securely access AWS resources and third-party tools and services on behalf of users or by themselves with pre-authorized user consent.

Consumption-based pricing
Customers who use AgentCore Identity through either AgentCore Runtime or AgentCore Gateway, do not incur any additional charges for their use of AgentCore Identity. For all other scenarios, you pay for only what you use and are charged based on the number of requests from the agent to AgentCore Identity for an OAuth token or an API key.

Key details:

• No minimum fees and no upfront commitments
• Billing is calculated per successful OAuth token or API key requested to perform a task requiring authorization for a non-AWS resource
• No additional charges incurred, when customers use AgentCore Identity through AgentCore Runtime or AgentCore Gateway

AgentCore Memory makes it easy for developers to build context-aware agents by eliminating complex memory infrastructure management while providing full control over what the AI agent remembers.

Consumption-based pricing
You only pay for what you use. Our pricing is simple and usage-based, aligning directly with how your AI agents create value:

1. Short-term memory is priced based on the number of raw events ingested, giving you predictable costs for in-session context.
2. Long-term memory is priced based on the number of memories stored each month and the number of memories retrieved, so you only pay when your agents store and use durable knowledge.
3. To extract long-term memory from raw events, you can choose between built-in memory strategies, which include automatic processing, or custom memory strategies that run in your account using the choice of model and prompt.

Key details:

• No upfront resource selection required
• For short-term memory, billing is calculated per create event request
• For long-term memory storage, billing is calculated per stored memory per day and averaged across the month
• For long-term memory retrieval, billing is calculated per retrieve memory request

AgentCore Observability gives developers complete visibility into agent workflows to trace, debug, and monitor AI agents' performance in production environments.

Consumption-based pricing
You pay as you go for telemetry generated, stored, and queried for your agents. The telemetry data is ingested and stored in your Amazon CloudWatch account. You are charged for data ingestion and storage, queries to retrieve and analyze information, and masking of sensitive/PII data in logs. To review pricing details visit Amazon CloudWatch pricing page. 

Example: Customer Support Agent Deployment

You plan to deploy a customer support agent that resolves user queries across chat and email. The agent handles order issues, account verification, and policy clarifications. It uses retrieval-augmented generation (RAG) to fetch product policies, and Model Context Protocol (MCP)-compatible tools to query order status and update support tickets. Each agent session involves sophisticated multi-step reasoning with 1 RAG call to a vector store, 2 MCP tool calls (e.g., OrderAPI, TicketAPI), and 2 LLM reasoning steps. You deployed your agent on AgentCore Runtime because you require complete session isolation and the flexibility to scale to millions of sessions in seconds.

Processing 10M user requests monthly, each session runs for 60 seconds with 70% I/O wait time (i.e. either waiting for LLM responses or network responses from internal APIs). Each agent session utilizes 1vCPU during active processing and 2GB memory continuously. Your monthly costs break down as follows:

CPU cost per session: 18 seconds (adjusting for 70% I/O wait time) × 1 vCPU × ($0.0895/3600) = $0.0004475
Memory cost per session: 60 seconds × 2GB × ($0.00945/3600) = $0.000315
Total cost per session: $0.0007625
Monthly total: 10M sessions × $0.0007625 = $7,625

AgentCore Runtime's consumption-based pricing means you only pay for active CPU processing time, not I/O wait periods, resulting in high cost efficiency compared to traditional compute options. 

Example: Automated Travel Booking System

You plan to create a travel booking AI agent that automates full trip planning and booking through web interactions. Your implementation requires AgentCore Browser's secure, serverless runtime to dynamically manage headless browsers for searching flights, hotels, simulating clicks, extracting prices, and submitting booking forms. AgentCore Browser tool provides enterprise-grade capabilities including session-isolated sandbox compute and comprehensive observability through Live View and Session Replay.

The agent processes 100K monthly requests. Each browser session runs for 10 minutes with 80% I/O wait time, utilizing 2vCPU during active processing and 4GB memory continuously. Your monthly costs break down as follows:

CPU cost per session: 120 seconds (adjusting for 80% I/O wait) × 2 vCPU × ($0.0895/3600) = $0.005967
Memory cost per session: 600 seconds × 4GB × ($0.00945/3600) = $0.0063
Total cost per session: $0.012267
Monthly total: 100K sessions × $0.012267 = $1,226.67 

Example: Natural Language Data Analysis Automation

You plan to deploy a data analyst agent that supports business and product teams with dataset queries, visualizations, and statistical analysis—all through natural language. Your agent dynamically generates and executes Python code for complex requests like correlation analysis between site traffic and conversion rates. You leverage AgentCore Code Interpreter because it provides isolated sandbox environments compliant with enterprise security policies, pre-built execution runtimes for multiple languages (JavaScript, TypeScript, Python), and large file size support.

The agent processes 10K monthly requests with 3 code executions per request. Each execution runs for 2 minutes with 60% I/O wait time, utilizing 2vCPU during active processing and 4GB memory continuously. Your monthly costs break down as follows:

CPU cost per session: 48 seconds (adjusting for 60% I/O wait) × 2 vCPU × ($0.0895/3600) = $0.002387
Memory cost per session: 120 seconds × 4GB × ($0.00945/3600) = $0.00126
Total cost per session: $0.003647
Monthly total: 30K executions × $0.003647 = $109.40

Example: Connecting HR Assistant agent to internal tools

You plan to build an HR assistant agent for a mid-sized enterprise, handling internal policy questions, leave balances, benefits enrollment, and payroll inquiries. To serve the user requests, the agent needs to access multiple internal systems (Onboarding, Benefits, Payroll, and Leave Management APIs) as tools. You used AgentCore Gateway to create MCP servers for 200 internal tools that your agent can interact with from anywhere, all without writing any code. To improve tool use accuracy, you leveraged the search capability to index tool metadata and enable dynamic matching of tools during agent invocation based on interaction context.

Each agent interaction requires 1 Search API and 4 InvokeTool API invocations. 50M monthly interactions result in 50M Search and 200M InvokeTool calls. Your monthly costs break down as follows:

SearchToolIndex charges: 200 tools × $0.02 per 100 tools = $0.04
Search API charges: 50M × $25/million = $1,250
InvokeTool API charges: 200M × $5/million = $1,000
Monthly total: $2,250.04 

Example: Secure Customer Support Access Management

You plan to operate a customer support agent that assists technical teams by accessing multiple tools—Slack for support conversations, Zoom to fetch call logs, and GitHub for issue tracking and commit logs. Your implementation uses AgentCore Identity for secure, delegated access "on behalf of" users or support engineers. The system is compatible with with existing identity providers ( e.g.,Okta, Microsoft Entra ID, Amazon Cognito) and manages all authentication methods from OAuth tokens to IAM roles, eliminating the need for custom security infrastructure.

Lets assume the agent is being used by 10K monthly active users averaging 5 interactions each, requiring 3 tool accesses per session for each user per month, your monthly costs break down as follows:

Total tokens requested: 10K users × 5 sessions × 3 tools = 150K tokens
Monthly total: 150K requests × $0.010/1,000 = $1.50

Note: AgentCore Identity is included at no additional cost when using AgentCore Runtime or Gateway.

Example: Personalized Coding Assistant Agent Implementation

You plan to develop a coding assistant agent that helps software engineers write, debug, and refactor code across IDEs and terminals. To provide a personalized experience, the agent needs to maintain context during a session and remember user preferences over multiple sessions. Your implementation uses AgentCore Memory for equipping the agent with both short-term memory (immediate conversations and events) and long-term memory (persistent knowledge across sessions).

Each time a user interacts with the agent (e.g., by sending a code snippet or asking a coding question), you send an event to AgentCore Memory for storing it as short-term memory. For long-term memory, you configured built-in extraction strategies to automatically extract and store summarization of debugging sessions and user preferences across sessions. The agent can then retrieve these long-term memories to provide a personalized experience for developers.

With 100,000 monthly short-term memory events, 10,000 stored long-term memories, and 20,000 monthly memory retrievals, your costs break down as follows:

Short-term memory: 100,000 events × $0.25/1,000 = $25
Long-term memory storage: 10,000 memories × $0.75/1,000 = $7.50
Long-term memory retrieval: 20,000 retrievals × $0.50/1,000 = $10
Monthly total: $42.50

Note: With custom extraction strategies, long-term storage cost would be lower at $0.25 per 1000 memories stored because you may incur additional charges for the model usage in your account. 

For AgentCore Observability pricing examples, refer to CloudWatch pricing here.