Amazon Bedrock AgentCore Pricing

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

Consumption-based pricing
You only pay for what you use, with no pre-configuration of resources required. Billing is based on CPU and memory consumption across your session lifetime, calculated at per-second increments. For CPU resources, you are charged based on actual consumption—if your agent consumes no CPU during I/O wait, there are no CPU charges. The same applies during idle periods. For memory resources, you're charged for the peak memory consumed up to that second.

• Key details:
  No upfront resource selection required
• Billing is calculated per second, using the actual CPU consumption and peak memory consumed up to that second, with a 1-second minimum
• You pay for resource consumption throughout your session (boot, initialization, active processing, idle periods) until session termination
• Billing includes system-level overhead beyond process-level measurements
• 128MB minimum memory billing applies

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

Consumption-based pricing
You only pay for what you use, with no pre-configuration of resources required. Billing is based on CPU and memory consumption across your session lifetime, calculated at per-second increments. For CPU resources, you are charged based on actual consumption—if your agent consumes no CPU during I/O wait, there are no CPU charges. The same applies during idle periods. For memory resources, you're charged for the peak memory consumed up to that second.

• Key details:
  No upfront resource selection required
• Billing is calculated per second, using the actual CPU consumption and peak memory consumed up to that second, with a 1-second minimum
• You pay for resource consumption throughout your session (boot, initialization, active processing, idle periods) until session termination
• Billing includes system-level overhead beyond process-level measurements
• 128MB minimum memory billing applies

AgentCore Code Interpreter tool enables agents to 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. Billing is based on CPU and memory consumption across your session lifetime, calculated at per-second increments. For CPU resources, you are charged based on actual consumption—if your agent consumes no CPU during I/O wait, there are no CPU charges. The same applies during idle periods. For memory resources, you're charged for the peak memory consumed up to that second.

• Key details:
  No upfront resource selection required
• Billing is calculated per second, using the actual CPU consumption and peak memory consumed up to that second, with a 1-second minimum
• You pay for resource consumption throughout your session (boot, initialization, active processing, idle periods) until session termination
• Billing includes system-level overhead beyond process-level measurements
• 128MB minimum memory billing applies

Amazon Bedrock AgentCore Gateway enables agents to securely access tools by transforming APIs and Lambda functions into agent-compatible tools and connecting to existing MCP servers.

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

Key details:

• No upfront costs or minimum commitments required

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 agent remembers.

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

1. Short-term memory is priced based on the number of raw events created, giving you predictable costs for in-session context.
2. Long-term memory records is priced based on the number of memories processed and stored each month and the number of memory record retrieval calls, so you only pay when your agents store and use processed knowledge.
3. To extract long-term memory from raw events, you can choose between built-in memory strategies, which include automatic processing, or more configurable memory strategies that run in your account using your 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 record 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 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/Personally Identifiable Information (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 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. During active processing it utilizes 2vCPU and 4GB memory continuously, and during I/O it is utilizing 0.4vCPU and 5GB memory. 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 for users or support engineers. The system is compatible with existing identity providers ( e.g. Amazon Cognito, Okta, Microsoft Entra ID) and manages all authentication methods from OAuth tokens to API keys, 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 memory records, and 20,000 monthly memory record retrieval calls, 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 built-in with override extraction strategies, long-term storage cost would be lower at $0.25 per 1000 memories stored. However, you may incur additional charges for model usage in your account.

Example: Multi-Agent Financial Advisory Platform

You plan to deploy a comprehensive financial advisory platform with multiple specialized agents handling investment research, portfolio analysis, and regulatory compliance checks. Each agent performs complex multi-step reasoning with database and websearch queries, API calls to financial data providers, and document analysis. The platform processes millions of transactions and generates extensive telemetry data including traces, metrics, and logs across all agent interactions. You use AgentCore Observability to monitor performance, debug issues, and ensure compliance with financial regulations through comprehensive audit trails.

Your platform generates 10 TB of observability data monthly from agent interactions, API calls, and system events. Assuming 30% of the spans are event logs (model invocation, tool call), then approximately 6TB (assuming 2KB of log data per span event) are written to CloudWatch standard logs. Your monthly costs break down as follows:

Monthly Span Ingestion charges: 10 TB × 1,000 GB/TB × $0.35/GB = $3,500
Monthly Event Logging charges: 6 TB × 1,000 GB/TB × $0.50/GB = $3,000
Monthly total: $3,500 + $3,00 = $6,500

*Standard CloudWatch rates will apply for any metrics and non-telemetry (standard) logs data sent to CloudWatch.