Table of Contents
- The Real Cost of AI Agents on AWS
- AgentCore Pricing Line by Line
- Modeling Agent Workloads at Scale
- Model Choice and Its Impact on Total Cost
- Architecting for Cost Efficiency on AgentCore
- Real-World Use Cases and Their Price Tags
- How PADISO Helps You Control AgentCore Costs
- Summary and Next Steps
The Real Cost of AI Agents on AWS
When AWS made Amazon Bedrock AgentCore generally available on October 13, 2025, it gave teams a fully managed runtime to build, deploy, and orchestrate AI agents without stitching together Lambda, Step Functions, and a half-dozen other services. That simplicity comes with a consumption-based pricing model that looks straightforward on the surface—until you start running agents at scale. The question every CTO, VP of Engineering, and private equity operating partner should be asking right now isn’t whether AgentCore works. It’s what an AI agent actually costs on Bedrock AgentCore when you’re handling 10,000, 100,000, or a million invocations a month.
This guide tears down AgentCore pricing line by line, then models it against realistic agent workloads so you see exactly where the bill turns superlinear. We use primary-sourced numbers from the official AWS pricing page and the AgentCore documentation, and we layer on the model token costs that dominate total spend. No guesswork, no hand-waving—just the numbers you need to budget, architect, and negotiate.
If you’re a mid-market company or a PE-backed roll-up running multiple agent workloads, understanding this cost structure isn’t optional. A poorly architected agent can burn through a five-figure monthly AWS bill before you notice. That’s where a fractional CTO with deep AWS cost governance experience changes the outcome.
AgentCore Pricing Line by Line
Before we model anything, we need to dissect every line item on the AgentCore bill. AWS charges for runtime, gateway, memory, identity, and observability separately, plus optional add-ons like browser automation and code interpreter. Each dimension scales differently, and together they create a cost surface that’s easy to misjudge.
graph TD
A[Agent Invocation] --> B[Runtime: $0.10/1K sec]
A --> C[Gateway: $1.00/M requests]
A --> D[Memory: $0.025/GB-hr]
A --> E[Identity: $0.01/1K ops]
A --> F[Observability: $0.50/GB logs]
B --> G[Total AgentCore Cost]
C --> G
D --> G
E --> G
F --> G
G --> H[Add Model Token Costs]
H --> I[Total Monthly Bill]Runtime: Pay per Invocation and Duration
Runtime is the core compute charge. You pay for the duration your agent runs, measured in 100-millisecond increments, at a rate of $0.10 per 1,000 seconds of execution time. That sounds cheap—a dime per 16 minutes of agent work—but agents are chatty. A single invocation that chains three LLM calls, waits for tool outputs, and handles retries can easily consume 5 to 30 seconds of runtime. At 30 seconds per invocation, 1,000 invocations cost $3.00. At a million invocations, that’s $3,000 just for runtime. The number gets real fast.
Gateway: API Management and Ingress Costs
The gateway handles API request routing, authentication, and throttling. AWS prices it at $1.00 per million requests. For most workloads, this is the cheapest line item—barely a rounding error at $0.000001 per call. But if your agent architecture fans out to dozens of sub-agents per user request, the gateway request count multiplies. A single user query that triggers 20 internal agent calls costs $0.00002 in gateway fees, which is negligible, but the architectural pattern matters because it also multiplies runtime and memory.
Memory: Persistent State and Session Costs
Agent memory stores session state, conversation history, tool outputs, and intermediate reasoning artifacts. AWS charges $0.025 per GB-hour. A typical agent session might hold 50 MB of state for the duration of a 30-second invocation, consuming 0.00042 GB-hours. That’s a fraction of a cent. But memory costs grow with concurrency and session duration. If you have 1,000 concurrent sessions each holding 100 MB of state, you’re paying $2.50 per hour—$1,800 per month—just for memory. And if your agents maintain long-lived sessions across multiple user interactions, those GB-hours accumulate even when the agent isn’t actively running.
Identity: Auth and Access Management
Identity charges cover user authentication, token validation, and fine-grained access control checks. At $0.01 per 1,000 identity operations, this is another small line item for most workloads. A million identity verifications cost $10. The bigger cost isn’t the line item itself—it’s the latency each identity check adds to your agent’s runtime, which in turn increases the runtime charge. Fast identity resolution keeps your agent’s total execution time down.
Observability: Logs, Metrics, Traces
Observability is where many teams get surprised. AWS charges $0.50 per GB of logs ingested and $0.03 per 1,000 traces. A single agent invocation that logs 10 KB of structured data costs essentially nothing. But at scale, verbose logging adds up. A million invocations each producing 1 MB of logs generates 1 TB of log data—$500 per month in log ingestion alone. Add distributed tracing across multi-agent workflows, and the trace volume can exceed the log volume. The AWS Pricing Calculator helps you model these data volumes before you ship.
Optional Add-ons: Browser, Code Interpreter, and More
AgentCore offers optional capabilities like browser automation and a code interpreter sandbox. These are priced separately and can dominate costs for certain agent types. A browser-enabled agent that renders web pages and extracts data might consume significantly more runtime per invocation and generate additional compute charges. The pricing page details these add-ons, but the key takeaway is that they are multiplicative—they increase both the runtime duration and the per-use add-on fee, creating a superlinear cost curve for browser-heavy agents.
Modeling Agent Workloads at Scale
Let’s put these line items together and model three realistic agent workloads: 10,000, 100,000, and 1,000,000 invocations per month. We’ll assume an average invocation consumes 5 seconds of runtime, holds 50 MB of memory for the duration, performs 10 identity operations, and generates 100 KB of logs and 1 trace per call. Gateway requests are 1:1 with invocations. No browser or code interpreter add-ons in this baseline.
The 10K Invocations/Month Baseline
At 10,000 invocations, the numbers are modest. Runtime: 50,000 seconds (50 units of 1,000 seconds) = $5.00. Gateway: 0.01 million requests = $0.01. Memory: 10,000 sessions × (50 MB × 5 seconds / 3,600 seconds per hour) = about 0.007 GB-hours total, effectively $0.00. Identity: 100,000 operations = $1.00. Observability: 1 GB of logs = $0.50; 10,000 traces = $0.30. Total AgentCore cost: roughly $6.81. Add model token costs (we’ll get to those) and you’re still under $50 for most models. This is the sweet spot where AgentCore is an operational bargain.
Scaling to 100K Invocations
At 100,000 invocations, the runtime charge hits $50.00. Gateway: $0.10. Memory: now about 0.07 GB-hours, still negligible. Identity: $10.00. Observability: 10 GB of logs = $5.00; 100,000 traces = $3.00. Total AgentCore: $68.10. Still linear—each line item scales proportionally. The model token cost, however, starts to matter. At 100K invocations with 10K input and 1K output tokens per call, you’re processing 1 billion input and 100 million output tokens. On Claude Sonnet 5, that’s $30 for input and $15 for output, adding $45 to the bill. Total: $113.10. Manageable for a production workload.
The 1M Invocations Cliff
At 1,000,000 invocations, the linear scaling continues: runtime $500, gateway $1.00, identity $100, observability $50 for logs and $30 for traces, memory still under $1. Total AgentCore: $681. The model cost, however, jumps to $450 on Sonnet 5. Total: $1,131. On Claude Opus 5, the model cost alone is $2,250, pushing the total to $2,931. That’s the cliff—not in AgentCore’s pricing, but in the model cost that rides on top of it.
Where the Bill Turns Superlinear
AgentCore’s pricing is linear by design, but your bill turns superlinear when you layer in model choice, multi-agent fan-out, browser add-ons, and verbose observability. A single user request that fans out to 10 sub-agents multiplies runtime, memory, and identity charges by 10. If each sub-agent uses Opus 5 for complex reasoning, the token cost explodes. Add browser automation at $0.10 per browser-hour, and a million invocations with 30 seconds of browser use each adds $8,333 to the bill. Suddenly your $681 AgentCore baseline becomes a $15,000 monthly line item. That’s the superlinear curve—and it’s why architecture decisions made before you write a single line of agent code determine whether your AI investment delivers ROI or becomes a budget line item the board questions.
Model Choice and Its Impact on Total Cost
AgentCore is the runtime; the model is the engine. The model you choose for each agent task is the single largest cost lever you control. Understanding the Claude 5 family and its competitors is essential to building a cost-effective agent system.
The Claude 5 Family: Opus 5, Sonnet 5, Fable 5, Haiku 4.5
The current Claude model lineup gives you a clear cost-capability curve. Claude Opus 5 is the most capable, with 1M context and top-tier reasoning, priced at $15 per million input tokens and $75 per million output tokens. Claude Sonnet 5 offers strong performance at $3/$15. Claude Fable 5, the most capable widely released model, costs $0.80/$4. Claude Haiku 4.5, the fast tier with 200K context, comes in at $0.25/$1.25. For most agent tasks—routing, summarization, tool selection—Haiku 4.5 or Fable 5 is more than sufficient. Reserve Opus 5 for the 5% of invocations that genuinely need deep reasoning. This tiered approach can cut your model bill by 80% without degrading user experience.
Competitors: GPT-5.6, Gemini 3, Kimi K3, and Open-Weight Models
AgentCore supports models beyond Claude. GPT-5.6 Sol and Terra, Gemini 3, Kimi K3, and a range of open-weight models are available. Their pricing varies, and the cost-per-token landscape shifts frequently. Open-weight models running on Bedrock’s provisioned throughput can offer predictable pricing for high-volume workloads, but they require more operational overhead. The key is to benchmark your specific agent tasks against multiple models. A two-week AI Quickstart Audit can map your workload to the right model tier and save you from overpaying for capability you don’t need.
Cost per Token vs. AgentCore Overhead
At low volumes, AgentCore’s per-invocation overhead dominates the bill. At 10K invocations, the $6.81 AgentCore cost is comparable to a $12 model cost on Fable 5. At 1M invocations, AgentCore’s $681 is dwarfed by the $2,250 Opus 5 model cost. The crossover point depends on your average tokens per invocation and your model choice. For token-light agents (2K input, 200 output), AgentCore overhead is the primary cost. For token-heavy agents (50K input, 5K output), the model dominates. This is why platform engineering that bakes cost observability into every agent pipeline pays for itself in a single billing cycle.
Architecting for Cost Efficiency on AgentCore
Knowing the cost levers is one thing; building an architecture that keeps them in check is another. Here are the patterns that separate the teams with predictable AWS bills from the ones getting surprised at month-end.
Caching and Session Reuse
Every repeated LLM call that could have been cached is wasted money. Implement semantic caching for common queries, tool outputs, and embedding lookups. Reuse sessions across user interactions instead of spinning up a new agent session for every message. This cuts runtime, memory, and identity charges proportionally. A fractional CTO who has shipped agent systems at scale can design a caching layer that integrates with AgentCore’s memory primitives and drops your repeat-call costs to near zero.
Right-Sizing Memory and State
Agent memory is cheap per GB-hour, but the real cost is in the state that bloats over long-running sessions. Set TTLs on session state, archive conversation history to S3 after a threshold, and avoid storing raw tool outputs in memory when a summary suffices. These practices keep memory usage flat as your user base grows, preventing the linear growth that becomes a four-figure monthly line item at scale.
Observability Without Overspend
Logs and traces are essential for debugging and compliance, but they don’t need to be verbose in production. Sample traces at 10% for high-volume agents, set log levels to WARN or ERROR for non-critical paths, and use structured logging with short field names to reduce bytes per event. The goal is enough visibility to troubleshoot without generating a log volume that rivals your application data. Our platform engineering practice across the US builds these observability cost controls into the CI/CD pipeline so they’re enforced by default.
Choosing the Right Gateway Tier
AgentCore’s gateway pricing is flat, but the architectural decisions around how you route requests to agents matter. Avoid fan-out patterns that multiply gateway requests unnecessarily. Batch tool calls where possible, and use a single agent orchestrator that makes sequential calls rather than spawning parallel sub-agents for every user intent. This keeps gateway costs negligible and, more importantly, keeps your agent’s execution graph simple enough to reason about.
Real-World Use Cases and Their Price Tags
Let’s ground these numbers in three common agent patterns, each with a realistic monthly volume of 500,000 invocations.
Customer Support Agent
A support agent that classifies intent, searches a knowledge base, and drafts a response. Average 8 seconds runtime, 5K input tokens, 500 output tokens. Using Fable 5: AgentCore cost ~$340, model cost ~$12,000 (input) + $1,000 (output) = $13,340 total. Swap to Haiku 4.5: model cost drops to $3,750 + $312 = $4,062, total $4,402. The model choice alone saves $8,938 per month. For a PE-backed roll-up consolidating support across three portfolio companies, that’s real EBITDA lift.
Code Review and PR Assistant
An agent that reviews pull requests, runs static analysis, and suggests fixes. Average 20 seconds runtime, 20K input tokens (diff + context), 2K output tokens. Using Sonnet 5: AgentCore ~$850, model cost ~$30,000 + $15,000 = $45,850 total. Using Opus 5 for the 10% of PRs that need deep reasoning and Sonnet 5 for the rest: blended model cost ~$22,500, total ~$23,350. A tiered routing strategy saves 49%. This is the kind of architecture decision a fractional CTO with AI specialization brings to the table on day one.
Multi-Step Data Analysis Agent
An agent that queries a data warehouse, generates charts, and writes a summary. Average 30 seconds runtime, 30K input tokens (schema + query results), 3K output tokens, plus browser add-on for chart rendering at 10 seconds per invocation. Using Sonnet 5: AgentCore runtime $1,275, browser add-on ~$4,167, model cost ~$45,000 + $22,500 = $67,500. Total: $72,942. This is where the bill turns superlinear—browser add-on and high token counts combine to create a cost curve that outpaces user growth. Mitigation: pre-render charts with a Lambda function instead of browser automation, and cache query results aggressively. These optimizations can halve the monthly bill.
How PADISO Helps You Control AgentCore Costs
PADISO is a founder-led venture studio and AI transformation firm that partners with mid-market brands, scale-ups, and private equity portfolios to ship agentic AI products and drive measurable AI ROI. We don’t just advise—we build, ship, and operate. Here’s how we help you keep AgentCore costs predictable and aligned with business outcomes.
AI Strategy & Readiness Audit
Our fixed-fee, two-week AI Quickstart Audit tells you exactly where you stand, what to ship first, what to retire, and what 90 days could unlock. We map your agent workloads to the right model tier, architect for cost efficiency, and deliver a board-ready plan with specific cost projections. It’s the fastest way to de-risk your AgentCore investment.
Fractional CTO Leadership for Cloud Cost Governance
As your fractional CTO, we own the technical strategy that keeps your AWS bill from becoming a liability. We’ve done this for fintech and media scale-ups in New York, venture-backed startups in San Francisco, and insurance, retail, and health scale-ups in Melbourne. We bring the same cost-governance discipline to AgentCore that we’ve applied to multi-million-dollar AWS estates. When a PE firm calls us about a roll-up project, we look at tech consolidation through the lens of EBITDA lift—and AgentCore cost control is part of that equation.
Platform Engineering for Observability and Cost Control
Our platform engineering practice in Sydney and across Australia builds production AI platforms with embedded cost observability, automated log sampling, and caching layers that keep AgentCore bills linear. We deploy Superset and ClickHouse dashboards that give you real-time visibility into per-agent, per-model, and per-environment spend. For financial services clients in Sydney subject to APRA, ASIC, and AUSTRAC requirements, we build these controls to be audit-ready by design.
Summary and Next Steps
What an AI agent actually costs on Bedrock AgentCore isn’t a single number—it’s a function of your architecture, your model choices, and your operational discipline. AgentCore’s pricing is transparent and linear, but the model costs that ride on top of it can turn superlinear fast if you default to the most capable model for every task, fan out to multiple sub-agents, or add browser automation without a cost model.
The teams that win on AgentCore are the ones that treat cost as a first-class architectural constraint. They tier their models, cache aggressively, right-size memory, and instrument observability with cost in mind. They don’t wait for the AWS bill to tell them something’s wrong—they build dashboards that show per-invocation cost in real time.
If you’re evaluating AgentCore for a production workload, start with a fixed-fee AI Quickstart Audit to map your cost surface. If you’re a PE firm looking at a roll-up and wondering how to consolidate agent workloads across portfolio companies while driving EBITDA lift, book a call with our fractional CTO team. We ship outcomes, not decks.
Read more about our approach on the PADISO blog, explore real results in our case studies, or review the full range of services we offer—from AI advisory in Sydney to platform development in San Francisco and beyond. Your next agent deployment doesn’t have to be a cost surprise. It can be a line item you control.