AgentCore Runtime is a secure, serverless runtime purpose-built for deploying and scaling agents and tools. Choose between direct code deployment for rapid iteration or container-based deployment for maximum control.

You only pay for the active resources you consume 
Unlike traditional compute services that charge for pre-allocated resources (i.e., fixed instance size and cost per second while hosting the agent), with AgentCore Runtime you only pay for active resource consumption. This delivers substantial cost savings for agentic workloads, which typically spend 30-70% of time in I/O wait (waiting for LLM responses, tool / API calls, or database queries). With pre-allocated pricing, you would pay for idle CPU during these wait periods. With the active resource consumption-based pricing in AgentCore Runtime, I/O wait and idle time is free, if no other background process is running.

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. 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 actual CPU consumption and peak memory consumed up to that second, with a 1-second minimum
• You only pay for actual resource consumption during your session, which spans from microVM boot, initialization, active processing, idle periods, until session termination (microVM shutdown)
• Billing includes system overhead in addition to your application's resource usage
• 128MB minimum memory billing applies for memory
• Storage costs: Container deployment requires ECR storage (billed separately). Direct code deployment will bill you for the size of the code artifacts you deployed at S3 Standard rates, starting February 27, 2026.
• Network data transfer charges apply at standard EC2 rates
  
  
  

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

You only pay for the active resources you consume
Unlike traditional compute services that charge for pre-allocated resources (i.e., fixed instance size and cost per second while hosting the agent), with AgentCore Browser you only pay for active resource consumption. This delivers substantial cost savings for agentic workloads, which typically spend 30-70% of time in I/O wait (waiting for LLM responses, tool / API calls, or database queries). With pre-allocated pricing, you would pay for idle CPU during these wait periods. With the active resource consumption-based pricing in AgentCore Browser, I/O wait and idle time is free, if no other background process is running.

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. 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 actual CPU consumption and peak memory consumed up to that second, with a 1-second minimum
• You only pay for actual resource consumption during your session, which spans from microVM boot, initialization, active processing, idle periods, until session termination (microVM shutdown)
• Billing includes system overhead in addition to your application's resource usage
• 128MB minimum memory billing applies for memory
• Network data transfer charges apply at standard EC2 rates
  
  

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

You only pay for the active resources you consume
Unlike traditional compute services that charge for pre-allocated resources (i.e., fixed instance size and cost per second while hosting the agent), with AgentCore Code Interpreter you only pay for active resource consumption. This delivers substantial cost savings for agentic workloads, which typically spend 30-70% of time in I/O wait (waiting for LLM responses, tool / API calls, or database queries). With pre-allocated pricing, you would pay for idle CPU during these wait periods. With the active resource consumption-based pricing in AgentCore Code Interpreter, I/O wait and idle time is free, if no other background process is running.

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. 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 actual CPU consumption and peak memory consumed up to that second, with a 1-second minimum
• You only pay for actual resource consumption during your session, which spans from microVM boot, initialization, active processing, idle periods, until session termination (microVM shutdown)
• Billing includes system overhead in addition to your application's resource usage
• 128MB minimum memory billing applies for memory
• Network data transfer charges apply at standard EC2 rates
  
  

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
• Network data transfer charges apply at standard EC2 rates

Policy in Amazon Bedrock AgentCore gives you comprehensive control over actions agents take, helping ensure agents stay within defined boundaries without slowing down.

Consumption-based pricing

You only pay for the authorization requests performed during agent execution. Each time an agent calls a tool through AgentCore Gateway, Policy checks the action against your rules to determine whether it is allowed or denied.

In addition, Policy offers natural language policy authoring, which lets you create Cedar policies using simple natural language descriptions. You are charged per 1,000 user input tokens processed when converting natural language into Cedar policy statements.

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. 

AgentCore Evaluations helps continuously inspect agent quality based on real-world behavior. Teams can perform agentic evaluations using 13 built-in evaluators on common quality dimensions or create custom evaluators for specific business requirements. The results are integrated into AgentCore Observability powered by Amazon CloudWatch for unified monitoring.

Consumption based pricing
You pay for what you use. For built-in evaluators, pricing is charged by AgentCore based on input and output tokens processed during evaluation. For custom evaluations using your own LLM infrastructure, you pay per evaluation performed, with separate inference costs based on the model used.

Key details:

• No upfront commitments or minimum fees required
• Includes CI/CD integration with configurable quality thresholds
• Production monitoring with sampling rules and dashboard aggregation
• Cost control through percentage-based sampling, conditional sampling, and selective metric monitoring
• Model usage costs are included for built-in evaluators - no separate model charges
• Custom evaluations incur additional model usage charges in your account

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 thousands of sessions in seconds.

Processing 10M user requests monthly, each session runs for 60 seconds with 70% I/O wait time (waiting for LLM responses and API calls), and no other background process is running during I/O. Each agent session utilizes 1vCPU during active processing. Memory usage starts at 1GB during initialization, increases to 2GB during RAG processing, then peaks at 2.5GB during complex tool calls for the remainder of the session. Your monthly costs break down as follows:

CPU cost per session: 18 seconds (only active processing time) × 1vCPU × ($0.0895/3600) = $0.0004475
Memory cost per session: 10 seconds × 1GB × ($0.00945/3600) + 20 seconds × 2GB × ($0.00945/3600) + 30 seconds × 2.5GB × ($0.00945/3600) = $0.000026 + $0.000053 + $0.000197 = $0.000276
Total cost per session: $0.0007235

Monthly total: 10M sessions × $0.0007235 = $7,235

Storage costs: With container-based deployment, you manage ECR storage separately based on published ECR rates. If you used direct code deployment instead, S3 Standard pricing (starting February 27, 2026) would apply for your code artifacts - for a 100MB agent, this adds up to $0.0023/month in storage costs.

Comparison to pre-allocated pricing: If this workload ran on a service charging for pre-allocated resources, you would need to provision for peak usage (2.5GB memory, 1vCPU) for the entire 60-second duration, resulting in up to 3.3x higher CPU costs and up to 1.4x higher memory costs. In the example above, the CPU cost savings are significant, given that CPU consumption accounted for 62% of the total workload cost. AgentCore Runtime's consumption-based pricing automatically captures the "I/O wait is free" benefit and charges only for actual memory usage as it scales up, delivering substantial 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:

You plan to develop a procurement automation agent that helps operations teams manage vendor selection, purchase order creation, and invoice approvals. To ensure actions follow defined business rules, you use Policy with AgentCore Gateway tools to automatically verify every action before it executes against your defined policies. Each time the agent attempts to perform an action (for example, sending purchase approval or initiating a payment), Gateway intercepts the tool call to check whether the action is allowed or denied. Let’s assume the agent serves 100K sessions in a month and makes 5 tool calls on average in every session. If you implement one authorization request for each tool call, you make 500K authorization requests per month with a cost break down as follow:


Authorization Requests = 100K sessions x 5 tool calls/session x 1 policy enforced/ tool call = 500K authorization requests
Monthly Total: 500K requests x 0.000025 = $12.50

Before deployment, your team optionally uses natural language policy authoring to simplify onboarding and policy setup. Instead of writing Cedar policies manually, they describe rules in plain language and AgentCore converts them into Cedar policy statements. You are charged a one-time fee based on the number of user input tokens processed during this authoring step. If your team used 10,000 tokens to author several policies, your costs would be:

Policy Authoring = 20K tokens × $0.13 per 1K input tokens = $2.60

Note: Standard CloudWatch rates apply if Observability is enabled.

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.

Example: E-commerce Customer Service Agent Quality Monitoring

You plan to deploy a customer service agent that handles order inquiries, returns processing, and product recommendations for an e-commerce platform. To ensure consistent service quality, you use AgentCore Evaluations to monitor agent performance across development and production environments. Your implementation uses 3 built-in trace-level evaluators (correctness, helpfulness, and goal success rate) plus 1 custom evaluator for business-specific quality metrics.

During development, your CI/CD pipeline evaluates 5,000 test interactions monthly. In production, you monitor 2% of live interactions through sampling rules, evaluating 10,000 customer conversations monthly. Each built-in evaluation processes an average of 15,000 input tokens (including conversation history, product catalogs, and order details) and generates 300 output tokens for scoring.

Your monthly costs break down as follows:
Built-in Evaluators:

• Total interactions evaluated: 15,000 (5,000 development + 10,000 production)
• Built-in evaluators per interaction: 3 (correctness, helpfulness, goal success rate)
• Total evaluation: 15,000 interactions × 3 evaluators = 45,000 evaluations
• Input tokens: 45,000 evaluations × 15,000 tokens = 675M tokens
• Output tokens: 45,000 evaluations × 300 tokens = 13.5M tokens
• Input cost: 675M tokens × $2.40/1M = $1,620
• Output cost: 13.5M tokens × $12.00/1M = $162
• Built-in evaluators subtotal: $1,782

Custom Evaluations:

• Total custom evaluations: 15,000 interactions × 1 custom evaluator = 15,000 evaluations
• Custom evaluation cost: 15,000 evaluations × $1.50/1,000 = $22.50

Monthly total: $1,804.50

Note: Model usage costs are included for built-in evaluators. Custom evaluations incur additional model usage charges in your account.