You've deployed your first AgentCore agent. Sessions are running. Then you open Cost Explorer and find charges across four lines you didn't plan for. Each makes sense in isolation, but nobody told you they'd all run at the same time.
That's the core challenge with Amazon Bedrock AgentCore pricing: it's not one rate. AgentCore has 12 independently billable components that fall into 5 billing patterns (per-session active consumption, per-request, per-record, pass-through, and free/preview). Your bill depends on which components you enable, how you configure them, and how much traffic your agent generates.
If you'd rather start with your own numbers, the AgentCore pricing calculator covers Runtime, Gateway, Memory, Policy, Identity, Browser, Code Interpreter, and Evaluations in one tool. Come back here for the component-by-component breakdown and the worked monthly totals.
This post walks through every AgentCore billing layer, shows the math for two real agent profiles, and covers the configuration choices that have the biggest cost impact before you deploy. I'll also cover Evaluations, Payments, and Optimization (the features added since GA that most pricing guides don't include yet).
Bedrock Agents vs. AgentCore: What You're Actually Paying For
Before the pricing: a quick sanity check. If you're seeing charges under bedrock:InvokeAgent in your Cost Explorer, you're on the legacy Bedrock Agents product, not AgentCore. These are different billing models entirely.
Legacy Bedrock Agents is an orchestration layer. It charges per foundation model inference token with no Runtime, Memory, or Gateway billing units. Simple and relatively predictable.
AgentCore is a full-stack managed platform. It reached general availability on October 13, 2025, and covers the entire lifecycle of a production agent: execution environment, session isolation, memory management, tool connectivity, identity brokering, observability, policy enforcement, quality evaluation, and more. You can run AgentCore with any foundation model (Claude, Amazon Nova, OpenAI, Gemini, Llama, Mistral) and any open-source framework (CrewAI, LangGraph, LlamaIndex, and others).
The key point: the AgentCore harness itself is free. Charges accrue only when you consume underlying resources in each component. The billing you need to model comes from the 12 components listed below, and you only pay for the ones you use.
Check your Cost Explorer filter, are charges appearing under AmazonBedrock or AmazonBedrockAgentCore? Different products, different billing models.
The 12 AgentCore Components and Which Ones Bill You
Here's how each component bills:
| Component | Status | Billing Type |
|---|---|---|
| Runtime | GA | Per vCPU-hour + GB-hour (active only) |
| Browser | GA | Per vCPU-hour + GB-hour (active only) |
| Code Interpreter | GA | Per vCPU-hour + GB-hour (active only) |
| Gateway | GA | Per 1,000 invocations/searches + tool indexing |
| Identity | GA | Per 1,000 requests (free via Runtime/Gateway) |
| Memory | GA | Per event + per record/month + per retrieval |
| Policy | GA | Per authorization request + per token (authoring) |
| Observability | GA | CloudWatch pass-through rates |
| Evaluations | GA | Per 1,000 tokens (built-in) or per 1,000 runs (custom) |
| Optimization | Preview | Free during preview; GA price not announced |
| Agent Registry | Preview | Free tier, then per 1,000 records/invocations |
| Payments | Preview | No AWS charge; third-party wallet provider pass-through |
Execution (Runtime, Browser, Code Interpreter) is almost always the largest single cost center. That's where we'll start.
Runtime, Browser, and Code Interpreter Pricing
All three execution components share identical unit rates. The billing model is called active consumption, but the "active" only applies to CPU: you pay for CPU cycles your agent actually consumes (idle and I/O-wait CPU is free), while memory is billed on peak footprint for every second the session is alive, including idle periods. The CPU savings can be material; memory is not subject to them.
Runtime is your primary session execution environment: isolated microVMs, session state management, async jobs up to 8 hours. Browser adds a cloud-based headless browser for web automation tasks. Code Interpreter provides an isolated sandbox for Python, JavaScript, and TypeScript execution.
Understanding the distinction between active CPU time and peak memory time is the single most important thing to get right when estimating AgentCore costs.
How Active Consumption Billing Works
The rates (AC-P-01 through AC-P-06 from the official AgentCore pricing page):
- CPU: $0.0895 per vCPU-hour, billed only for actual CPU cycles consumed; I/O wait is not billed
- Memory: $0.00945 per GB-hour, billed on peak memory footprint, per second, for the full session duration
That second point matters. CPU billing stops during I/O wait. When your agent is waiting for an LLM response, an API call, or a database query, those CPU cycles are free. Memory billing does not stop. Your agent's peak memory footprint accumulates charges for every second the session is alive, including idle seconds.
This makes the I/O wait ratio critical for your cost estimate. AWS's own pricing page puts CPU savings at up to 3.3x vs. pre-allocated compute for a session with 70% I/O wait. Your actual savings depend on your agent's real I/O ratio, and whether any background processes run during those wait periods (which would negate the CPU savings).
Per-session hardware sizing is configurable up to the limits set by the AWS service quotas. The current AWS Browser worked example uses 2 vCPU / 4 GB active, and the Runtime and Code Interpreter examples run at 2 vCPU / 8 GB, so plan your estimates against those values rather than tighter assumptions. Confirm the current per-region quota in the AgentCore service quotas documentation before sizing a production deployment.
Billing granularity is per-second with a 1-second minimum. The minimum memory billing is 128 MB. Browser profiles (cookies, localStorage) stored in S3 are billed at S3 Standard rates starting April 15, 2026, a new charge for any Browser sessions using profile persistence (AC-P-27).
Per-Session Cost Formula and AWS Worked Examples
The formula for a single session:
CPU cost = (active_cpu_seconds / 3,600) x vCPU_count x $0.0895
Memory cost = (session_seconds / 3,600) x peak_GB x $0.00945
AWS publishes three official worked examples on the pricing page. These use specific session profiles, your numbers will differ based on your actual I/O ratio, session duration, and memory footprint.
Runtime example (customer support agent): 10M sessions/month, 60-second sessions, 70% I/O wait, 1 vCPU active, 2.5 GB peak memory.
- Active CPU time per session: 18 seconds
- CPU cost per session: $0.0004475
- Memory cost per session: $0.000276
- Total per session: $0.0007235
- Monthly total: $7,235
Browser example (travel booking agent): 100K sessions/month, 10-minute sessions, 80% I/O wait, 2 vCPU / 4 GB active.
- Monthly total: $1,226.67
Code Interpreter example (data analyst agent): 10K requests with 3 executions each (30K total), 2-minute executions, 60% I/O wait, 2 vCPU / 4 GB.
- Monthly total: $109.40
These are official AWS examples from the AgentCore pricing page. The sessions/month and I/O ratios are defined by AWS as illustrative, confirm your actual numbers before using these as production budget inputs.
Execution is the largest cost center for most agents. The next layer, Gateway, determines how your agent connects to tools.
Gateway, Identity, and Policy Pricing
Gateway converts your existing APIs and Lambda functions into MCP-compatible tools your agent can call. It also connects to external MCP servers. How you configure it, specifically which tool operations your agent performs most often, determines this billing layer.
Three things drive your Gateway bill: invocations, searches, and indexing. They look cheap in isolation. At the usage levels of a production agent, they add up quickly.
Gateway Invocations, Search, and Tool Indexing
Gateway API invocations (AC-P-07): $0.005 per 1,000, covers ListTools, InvokeTool, and Ping operations. The per-call rate is low, but a busy agent making 200M tool calls/month generates $1,000 in InvokeTool charges alone.
Gateway Search API (AC-P-08): $0.025 per 1,000, 5x more expensive than standard invocations. This applies only to semantic search queries (when your agent asks "which tool should I use?" rather than calling a specific tool by name). Index only the tools that genuinely benefit from semantic discovery, and route everything else as direct invocations.
Tool indexing (AC-P-09): $0.02 per 100 tools per month, a predictable recurring charge for maintaining the semantic search index. 1,000 tools = $0.20/month. 10,000 tools = $2/month. For large enterprise tool catalogs, index only what the search API actually needs.
VPC data egress (AC-P-10): $0.006 per GB, applies to data flowing out to your customer-owned VPCs in commercial AWS regions. Standard EC2 cross-AZ transfer rates also apply.
The official Gateway worked example (HR assistant): 50M monthly interactions, 200 tools, 1 search + 4 InvokeTools per interaction. Tool indexing: $0.04. Search API: $1,250. InvokeTool: $1,000. Monthly total: $2,250.04.
Identity Free Tier and Policy Authorization Costs
Identity (AC-P-11): $0.010 per 1,000 token or API key requests, but this charge only applies when Identity is called directly. When used through AgentCore Runtime or AgentCore Gateway, Identity is free. Route all agent-to-tool authentication through Runtime or Gateway and you eliminate this charge entirely.
Policy authorization (AC-P-19): $0.000025 per request, a fraction of a cent per tool call intercepted by the Policy engine. At 100M tool calls/month, that's $2,500 in Policy authorization charges. Audit your tool call volume before enabling Policy on every Gateway target.
Policy natural language authoring (AC-P-20): $0.13 per 1,000 input tokens — one-time cost for converting natural language rules into Cedar policies, not an ongoing authorization charge. You write a rule once; it runs at $0.000025/request thereafter.
Gateway, Identity, and Policy are predictable and low per-call. Memory is where billing gets conditional, and where most teams underestimate their costs.
Memory Pricing - and the Strategy Decision That Triples Your Bill
If you've wondered whether Memory model usage is bundled or billed separately, the answer depends entirely on which memory strategy you select. This is the single most common AgentCore billing question, and the three-way conditional logic is worth understanding before you deploy.
Memory has two layers: short-term (in-session, conversational context) and long-term (cross-session, persistent knowledge). They bill independently, and both are additive to your execution costs.
Short-Term vs. Long-Term Memory Billing
Short-term memory (AC-P-12): $0.25 per 1,000 new events, one event per CreateEvent API call. For most conversational agents, this is a small line item unless session turn counts are high.
Long-term memory storage depends on your strategy:
- Built-in automatic extraction (AC-P-13): $0.75 per 1,000 records/month, AgentCore handles extraction using a built-in model. That model's inference cost is bundled into the $0.75 rate.
- Built-in with override or self-managed (AC-P-14): $0.25 per 1,000 records/month, you control extraction logic. The storage rate drops by 67%, but in-account model charges for your extraction calls are billed separately.
Long-term retrieval (AC-P-15): $0.50 per 1,000 retrievals, applies regardless of which storage strategy you use, charged per RetrieveMemoryRecords call.
The official Memory worked example (coding assistant): 100K short-term events, 10K long-term records using built-in automatic extraction, 20K retrievals. STM: $25. LTM storage: $7.50. Retrieval: $10. Monthly total: $42.50.
Which Memory Strategy Should You Use?
The 3x storage price difference ($0.75 vs. $0.25 per 1K records) is significant at scale. But the override and self-managed options shift model inference costs into your account, billed at standard Bedrock rates. The net break-even depends on how frequently memory extraction runs and which model handles it.
Here's how to think about it:
- Low extraction frequency (memory consolidation runs occasionally): the override strategy's lower storage rate likely wins, even after adding in-account model costs.
- High extraction frequency (memory extracted on every turn): the bundled model in built-in automatic may be cheaper than paying separately for the same inference volume.
One more constraint worth knowing: memory event expiration is fixed between 7 and 365 days. You cannot expire events in less than 7 days. Set EventExpirationDuration to the minimum appropriate for your use case, events stored longer than needed keep accumulating storage charges you can't cancel early.
Observability, Evaluations, Payments, and What's Still Free
AgentCore added several billing dimensions since its October 2025 GA that most pricing guides don't cover yet. Here's what they actually cost.
Observability, Evaluations, and Payments have meaningfully different billing models from the execution components. One passes through to another AWS service, one bundles model usage, and one passes through to a third-party provider entirely.
Observability - CloudWatch Pass-Through Pricing
AgentCore Observability has no service-specific pricing. Telemetry data (traces, spans, logs, and metrics) flows into Amazon CloudWatch and is charged at standard CloudWatch rates (AC-P-16).
The official example uses $0.35/GB for span ingestion and $0.50/GB for event logs (these are CloudWatch rates, not fixed AgentCore rates, verify against current CloudWatch pricing before using them in estimates). A financial advisory platform generating 10 TB/month in spans (10 TB x $0.35/GB = $3,500) and 6 TB in logs (6 TB x $0.50/GB = $3,000) pays $6,500/month in observability costs alone.
Observability has no free tier in AgentCore, and the charges are uncapped. For high-traffic production deployments, implement percentage-based sampling to control telemetry volume before it becomes a significant cost center.
Evaluations - Built-in vs. Custom
Evaluations launched in preview in December 2025 and provides 13 built-in quality evaluators plus custom evaluator support.
Built-in evaluators (AC-P-17):
- $0.0024 per 1,000 input tokens
- $0.012 per 1,000 output tokens
- Model usage is included in these rates, no separate Bedrock charges
Custom evaluators (AC-P-18):
- $1.50 per 1,000 evaluations
- Model usage billed separately in your account
The official e-commerce example: 45,000 evaluation runs using 3 built-in evaluators at 15,000 input tokens each. Monthly cost: $1,804.50. Evaluations at scale with large context windows can become a significant line item. Two non-adjustable rate limits apply: 200,000 input tokens per minute and 100 evaluations per minute for built-in evaluators.
Payments (Preview) - No AWS Charge, but Read the Pass-Through
Payments launched in preview on May 11, 2026, with support for Coinbase CDP and Stripe Privy wallets. The billing model here is different from everything else in AgentCore (AC-P-24):
AWS charges nothing for the Payments service itself. Costs pass through to your chosen wallet provider:
- Coinbase CDP: $0.005 per wallet operation. Both CreateInstrument and ProcessPayment each count as one wallet operation, so a payment that creates a wallet instrument and then processes a payment costs $0.01 total.
- Stripe Privy: CreateInstrument has no charge. ProcessPayment counts as one wallet operation fee.
These are third-party rates, not AWS-set prices. Verify with your wallet provider directly before production deployment, and account for the actual transaction amounts your agent will facilitate separately from these operation fees.
Agent Registry and Optimization Recommendations
Agent Registry (Preview) is a centralized catalog for MCP servers, agents, and skills. AWS has now published the rates that will apply once Agent Registry exits preview:
- First 5,000 records/month: free (AC-P-21)
- First 1,000,000 Search API invocations/month: free (AC-P-22)
- First 2,000,000 combined List/Get API invocations/month: free (AC-P-23)
Above-threshold post-preview rates: $0.400/1K records, $0.020/1K search invocations, $0.004/1K list/get invocations. During the current preview window the service itself remains no-charge, so use the published rates for forecasting only — verify the current preview-vs-post-preview status on the AgentCore pricing page before counting these in your monthly estimate.
Optimization Recommendations (Preview) is free during the public preview period (AC-P-25). GA pricing has not been announced. A/B tests run through Optimization consume standard Runtime, Gateway, and Evaluations resources at their normal rates, the "free" label covers the recommendation engine itself, not the underlying compute.
Use Optimization during preview while it's free, but don't model it as a zero-cost component in your long-term infrastructure plans.
Total Monthly Cost - Two Agent Profiles, All Layers Added Up
Here's what the full bill looks like when you run a real agent. The numbers below use AWS's published rates. Your actual bill depends on your session volume, tool call frequency, observability settings, and memory configuration.
Foundation model inference (the tokens your agent sends to and receives from Claude, Nova, or another model) is always additive and typically the largest portion of your total cost. Those charges flow through standard Bedrock pricing and are not included in the AgentCore component costs below. See the Amazon Bedrock foundation model pricing guide for the FM cost layer.
Prototype Agent: Lightweight Chatbot (Low Volume)
A simple conversational agent with no Memory, basic Gateway for 2-3 tool integrations, and minimal observability. These are illustrative estimates using official AWS rates.
Assumptions: 10K sessions/month, 60-second sessions, 60% I/O wait, 1 vCPU, 1.5 GB peak memory, 3 tool calls per session at direct invocations only (no search), 100 GB telemetry/month.
| Component | Calculation | Monthly Cost |
|---|---|---|
| Runtime CPU (AC-P-01) | 10K x 24s active x 1vCPU x ($0.0895/3,600) | ~$5.97 |
| Runtime Memory (AC-P-02) | 10K x 60s x 1.5GB x ($0.00945/3,600) | ~$2.36 |
| Gateway invocations (AC-P-07) | 30K calls x ($0.005/1K) | $0.15 |
| Observability (AC-P-16) | 100 GB x ~$0.35/GB (CloudWatch spans) | ~$35.00 |
| Subtotal (AgentCore components) | ~$43.48 | |
| FM inference | — | See Bedrock pricing guide |
At 10K sessions/month, this is a manageable AgentCore bill, dominated by the CloudWatch span ingestion line.
Production Agent: Multi-Turn with Memory and Gateway
A production agent with Memory enabled (built-in automatic extraction), Gateway with semantic tool search, Policy enforcement on tool calls, and Evaluations sampling for quality monitoring. These are illustrative estimates using official AWS rates.
Assumptions: 50K sessions/month, 90-second sessions, 70% I/O wait, 1 vCPU, 2 GB peak memory, 5 tool calls/session (1 search + 4 direct), 50K LTM records at built-in automatic, 100K STM events, 50K retrievals, Policy on all tool calls (250K/month), Evaluations on 10% of sessions, 1 TB telemetry/month.
| Component | Calculation | Monthly Cost |
|---|---|---|
| Runtime CPU (AC-P-01) | 50K x 27s active x 1vCPU x ($0.0895/3,600) | ~$33.56 |
| Runtime Memory (AC-P-02) | 50K x 90s x 2GB x ($0.00945/3,600) | ~$23.63 |
| Gateway search (AC-P-08) | 50K x ($0.025/1K) | $1.25 |
| Gateway invocations (AC-P-07) | 200K x ($0.005/1K) | $1.00 |
| Memory STM (AC-P-12) | 100K x ($0.25/1K) | $25.00 |
| Memory LTM storage (AC-P-13) | 50K x ($0.75/1K) | $37.50 |
| Memory retrieval (AC-P-15) | 50K x ($0.50/1K) | $25.00 |
| Policy authorization (AC-P-19) | 250K x ($0.000025) | $6.25 |
| Evaluations built-in (AC-P-17) | 5K sessions x ~10K tokens each | ~varies |
| Observability (AC-P-16) | 1 TB x $0.35/GB | ~$358 |
| Subtotal (AgentCore components) | ~$511 + Evaluations | |
| FM inference | — | See Bedrock pricing guide |
The production profile shows how billing patterns compound. Runtime and Observability are the two largest line items, and Memory LTM storage adds a meaningful recurring charge on top.
Run your production workload assumptions through the AgentCore pricing calculator to get numbers specific to your session profile.
The Hidden Cost Drivers Nobody Warns You About
The AgentCore pricing page explains each component rate clearly. What it doesn't always make obvious is how these rates interact with default settings and scale behavior. Here's what tends to generate unexpected charges in practice.
Most surprises trace back to two categories: components that bill continuously rather than only during active work, and pass-through charges that don't appear on the AgentCore pricing page itself.
Idle Session Memory Accumulation
Memory billing for Runtime, Browser, and Code Interpreter is based on peak memory footprint for every second the session is alive, including idle seconds where your agent is waiting for user input. CPU stops charging during I/O wait. Memory does not.
The default idle session timeout is 15 minutes (idleRuntimeSessionTimeout via the LifecycleConfiguration API parameter). An agent session that completes its last active step and then waits 15 minutes for a user to type the next message accumulates 15 minutes of memory charges. At 2 GB peak and 10K sessions/month with a 10-minute average idle tail, that's roughly 10K x (600 seconds x 2 GB x $0.00945/3,600), not catastrophic per session, but it scales with your session count.
Tune idleRuntimeSessionTimeout to the minimum practical value for your use case. For batch and fire-and-forget workloads, set it to a few minutes. For interactive conversational agents, find the right balance between user experience and idle billing.
Token Amplification, VPC Endpoints, and Memory Lock-In
Token amplification is an indirect cost rather than an AgentCore-specific charge, but it compounds quickly in agentic systems. Each reasoning step triggers a Bedrock inference call. Multi-step agents with tool use, planning phases, and reflection loops can generate 5-10x more tokens than the initial user message suggests. This shows up in your Bedrock costs, not your AgentCore costs, but the two bills are inseparable.
VPC PrivateLink endpoints for Gateway are a common miss. When running AgentCore in a VPC, Gateway VPC egress is $0.006/GB (AC-P-10), and standard EC2 cross-AZ transfer rates apply. For high-traffic agents with significant data payloads, these cross-AZ costs can appear as unexplained charges, check VPC and PrivateLink endpoint costs if you see unexpected data transfer bills.
Memory event expiration lock-in: Short-term memory events cannot expire in less than 7 days. There is no way to force-expire events set at 30 or 90 days. Set EventExpirationDuration explicitly at the minimum your use case requires.
Browser profile S3 billing (AC-P-27): Browser sessions with profile persistence (cookies, localStorage) are billed at S3 Standard rates starting April 15, 2026. If you're using Browser with profile persistence enabled, this is a new recurring charge that didn't exist before that date.
How to Control AgentCore Costs
The most effective cost controls for AgentCore aren't complicated, they're mostly about default settings that are easy to leave unchanged. Here are the specific levers with the highest impact.
Shifting these controls left into your IaC templates, rather than applying them post-deploy, is how teams avoid repeated cost surprises. Parameters like idleRuntimeSessionTimeout should be parameterized at the CloudFormation or CDK level, not set manually per agent after deployment. The AWS CloudFormation guide for AgentCore covers the resource template structure.
idleRuntimeSessionTimeout and Memory Expiration
The default 15-minute idle timeout is the easiest cost lever to miss. For most interactive workloads, a 2-5 minute idle timeout is more appropriate. Set it via idleRuntimeSessionTimeout in the LifecycleConfiguration parameter for your Runtime configuration.
For IaC deployments (the approach I'd recommend), parameterize this value by environment. Development and staging agents can run with much tighter timeout policies than production without affecting developer experience.
# AWS CloudFormation / CDK parameter approach
# your-org/your-repo/infra/agentcore-runtime.yaml
Parameters:
IdleTimeoutSeconds:
Type: Number
Default: 300
AllowedValues: [60, 120, 300, 600, 900]
Description: Idle session timeout in seconds (reduce for dev/staging)
Resources:
AgentRuntime:
Type: AWS::BedrockAgentCore::Runtime
Properties:
LifecycleConfiguration:
IdleRuntimeSessionTimeout: !Ref IdleTimeoutSeconds
Tags:
- Key: Environment
Value: !Ref Environment
- Key: CostCenter
Value: !Ref CostCenter
Set EventExpirationDuration for Memory with the same discipline. The minimum is 7 days, use it unless your use case genuinely requires longer retention.
Prompt Caching for Foundation Model Costs
FM inference is additive to every AgentCore component cost. For agents with repeated system prompts or large document contexts loaded on every session, Bedrock prompt caching can reduce that FM cost by up to 90% on input tokens and improve latency by up to 85% (per AWS Well-Architected prompt caching guidance, GENCOST03-BP03).
This is a Bedrock-level optimization, not AgentCore-native. It requires your foundation model to support caching (currently Anthropic Claude and Amazon Nova models on Bedrock). The setup is on the Bedrock side, enable it in your model invocation configuration. The payoff is material for any agent that loads a fixed system prompt or knowledge document on each turn.
Tagging, Cost Explorer, and FinOps Chargeback
Resource tagging is supported across all GA AgentCore services and was added at the GA release in October 2025. Tag every AgentCore resource at deploy time using at minimum:
Environment(dev/staging/prod)TeamorOwnerCostCenter
These tags flow directly into AWS Cost Explorer, enabling cost allocation by team and environment. For organizations running multiple agents, this is the foundation of any chargeback model.
Policy can serve double duty as a cost guardrail. If certain external API calls are expensive (high-cost third-party services, Payments-enabled tool calls), you can configure Cedar policies to block or rate-limit those calls when they exceed budget thresholds, before the cost hits.
For a broader view of how to enforce these controls in your CI/CD pipeline, the shift-left FinOps approach applies directly here. CloudBurn's IaC rules can flag AgentCore sessions deployed with default timeouts or missing cost allocation tags before they reach production.
CloudBurn
Catch AgentCore Cost Anti-Patterns in Code Review
CloudBurn scans your Terraform and CloudFormation for cost anti-patterns in CI — including default idle timeouts and missing cost tags on AgentCore resources. Open source, installs in seconds.
Frequently Asked Questions
What is the difference between Bedrock Agents and AgentCore pricing?
Does AgentCore charge for I/O wait time?
Is AgentCore Memory model usage bundled or billed separately?
What hidden costs should I watch for in AgentCore?
Does AgentCore have a free tier?
What does AgentCore Payments cost?
Is AgentCore Optimization free?
How do I track AgentCore costs per team or project?
Key Takeaways
Amazon Bedrock AgentCore pricing is a multi-layer model that rewards up-front configuration discipline. Here's what matters most:
-
The harness is free; the components compound. Runtime memory during idle sessions, Observability volume, and Memory strategy selection are the three easiest places to overspend without realizing it.
-
Memory strategy is a 3x decision. Built-in automatic extraction ($0.75/1K records) vs. built-in with override ($0.25/1K records) is a 67% storage cost difference. Evaluate your extraction frequency before defaulting to automatic.
-
Set
idleRuntimeSessionTimeoutat deploy time. The default 15-minute idle window is the single most common source of unexpected memory charges. Parameterize it in your IaC templates so every environment gets the right value from the start. -
FM inference is always additive and usually the largest cost. AgentCore component costs don't include the tokens your agent consumes. See the Amazon Bedrock foundation model pricing guide for the inference cost layer, and enable prompt caching if your agent uses repeated system prompts.
-
Evaluations, Payments, and Optimization add new billing dimensions. Optimization is free during preview. Payments passes through to your wallet provider. Evaluations can reach four figures per month at scale, sample rather than evaluate every session.
For your specific workload, the AgentCore pricing calculator covers all components in one tool. Plug in your session counts, tool call frequency, and memory configuration to get a number before you deploy.
If you're deploying via Terraform, CDK, or CloudFormation, use CDK cost estimation techniques to model your AgentCore infrastructure costs before they land on a bill.
What configuration choices are you considering for your agent deployment? Leave a comment below and let me know what tradeoffs you're working through.