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.

Example: Enterprise AI Tool Marketplace for a Financial Services Firm
You work at a large financial services firm with 5,000+ developers across trading, risk management, compliance, and client services teams. Each team builds and maintains MCP servers, agents, and custom tools, but there's no centralized place to discover existing resources. You leverage AWS Agent Registry as your centralized catalog where teams publish their tools.
You create a single registry where developers across 12 teams register their resources—totaling 17,000 registry records: 2,000 MCP servers (market data feeds, order management, risk calculators, compliance checkers), 10,000 agents (portfolio rebalancing, trade reconciliation, regulatory reporting), and 5,000 custom tools (internal APIs, proprietary models, knowledge bases). The 2,000 MCP servers are added at the beginning of the month, while the 10,000 agents and 5,000 custom tools are added mid-month.

On the consumer side, all 5,000 builders query the registry throughout the month. In the first month, builders average 2 Search calls and 5 List + Get calls per day as they familiarize themselves with the system. By the second month, usage increases to 20 Search calls and 50 List + Get calls per day as adoption grows.

• First Month:
  • Records: 2,000 MCP servers (full month) + 7,500 pro-rated records (10,000 agents + 5,000 tools added mid-month) = 9,500 effective records. With 5,000 records free, you're charged for 4,500 records at $0.40/1,000 = $1.80
  • Search API calls: 300,000 calls (5,000 builders × 2 calls/day × 30 days). Since it is within the 1M free tier, the cost is = $0
  • List + Get API calls: 750,000 calls (5,000 builders × 5 calls/day × 30 days). Since it is within the 2M free tier, the cost is = $0
  • Monthly total: $1.80
• Second Month:
  • Records: 17,000 total records - 5,000 free = 12,000 billable records at $0.40/1,000 = $4.80
  • Search API calls: 3,000,000 calls (5,000 builders × 20 calls/day × 30 days) - 1M free = 2M billable calls at $0.020/1,000 = $40.00
  • List + Get API calls: 7,500,000 calls (5,000 builders × 50 calls/day × 30 days) - 2M free = 5.5M billable calls at $0.004/1,000 = $22.00
  • Monthly total: $66.80