A8gent
AI Agent PlatformsDeveloper framework

Amazon Bedrock AgentCore Pricing and Review (2026)

AWS's managed services for running agents built with any framework, each billed on its own meter.

Reviewed by A8gent
Contents
  1. Verdict
  2. What is Amazon Bedrock AgentCore?
  3. Best for, and not for
  4. Strengths and limits
  5. Pricing
  6. What people actually build with Amazon Bedrock AgentCore
  7. What Amazon Bedrock AgentCore actually costs at small-business volume
  8. The gotcha: a dozen meters, and evaluations that cost more than the agent
  9. What breaks in production, and how you find out
  10. What it connects to that you already run
  11. Amazon Bedrock AgentCore alternatives: what to pick instead, and when
  12. Migration and lock-in: can you get your work out?
  13. FAQ
VerdictIs Amazon Bedrock AgentCore worth it?

AgentCore is cheap to run and hard to price. The runtime itself is inexpensive: AWS's own example of a ten-minute support session costs $0.006703, so a thousand of them is $6.70, largely because CPU is not billed while the agent waits on a model. The difficulty is that the runtime is one meter among more than a dozen, and model tokens, CloudWatch and anything you add from Gateway, Memory, Web Search or Evaluations arrive as separate lines. It is worth it for a team already on AWS that wants isolation, identity and tool access handled as managed services. It is not worth it for a small business that wants one number, or that has nobody who can read an AWS bill.

What is Amazon Bedrock AgentCore?

Amazon Bedrock AgentCore is a set of AWS services for deploying and operating AI agents without managing infrastructure. It is not a framework: AWS says it works with any open-source framework, naming CrewAI, LangGraph, LlamaIndex and Strands Agents, and with any foundation model inside or outside Amazon Bedrock. The services are modular and include a serverless Runtime, Memory, a Gateway that turns APIs into agent tools, Identity, a Browser, a Code Interpreter, Observability, Evaluations, Policy and a Registry. Each is used and billed independently, on consumption, with no upfront commitment or minimum fee.

Best for

Engineering teams already on AWS that want agent runtime, identity, memory and tool access as managed services.

Not for

Small businesses without AWS skills, and anyone who needs a single predictable monthly price.

Strengths

  • Consumption pricing with no upfront commitment or minimum fee, and every rate published
  • Runtime CPU is billed only while consumed, so time spent waiting on a model or an API is not charged as CPU
  • Works with any framework and any model, inside or outside Amazon Bedrock
  • Each session runs in an isolated microVM
  • Modular: use Runtime alone, or only Gateway or Memory, and pay for just that
  • AWS publishes worked pricing examples with the full arithmetic for each service

Limitations

  • More than a dozen separately metered services, each with its own unit, make a total hard to forecast
  • Model inference is not part of AgentCore's rates and is billed separately
  • Observability is billed under Amazon CloudWatch pricing, on a different price list
  • Runtime v2 rates are higher than v1: $0.1276 against $0.0895 a vCPU-hour and $0.0169 against $0.00945 a GB-hour
  • Built-in evaluations are priced per token and can cost more than running the agent
  • Requires AWS expertise to deploy, secure and monitor

Amazon Bedrock AgentCore pricing

AgentCore bills each service separately on consumption, with no upfront commitment or minimum fee. Runtime, Browser and Code Interpreter charge per second for vCPU and memory. Gateway, Identity, Policy and Registry charge per thousand calls. Memory charges for storage and retrieval. Evaluations charge per token. Model inference, CloudWatch observability and Bedrock knowledge bases are billed on their own AWS price lists. New AWS customers receive up to $200 in Free Tier credits.

Amazon Bedrock AgentCore pricing tiers
PlanPriceWhat you get
Runtime v2$0.1276/vCPU-hrPlus $0.0169 per GB-hour of memory. Billed per second with a 1-second and 128 MB minimum. CPU is billed only while consumed; idle memory is reclaimed after 120 seconds. Runtime v1 is $0.0895 per vCPU-hour and $0.00945 per GB-hour
Browser and Code Interpreter$0.0895/vCPU-hrPlus $0.00945 per GB-hour. CPU is free during I/O wait and idle time when no background process is running; memory is billed at peak consumption
Gateway$0.005/1,000 callsAPI invocations such as ListTools and InvokeTool. Search API $0.025 per 1,000. Tool indexing $0.02 per 100 tools a month
Memory$0.75/1,000 recordsLong-term records per month with built-in strategies, $0.25 self-managed. Long-term retrieval $0.50 per 1,000. Short-term: $1.00 per GB ingested, $0.20 per GB retrieved, $0.10 per GB-month stored
Web Search and Web Answer$7.00/1,000 queriesWeb Search per query. Web Answer is $10 per 1,000 tool calls
Identity and Policy$0.010/1,000 requestsIdentity token or API key requests for non-AWS resources, free when used through Runtime or Gateway. Policy authorisation is $0.025 per 1,000 requests
Evaluations$0.0024/1,000 tokensBuilt-in evaluations: $0.0024 per 1,000 input tokens and $0.012 per 1,000 output tokens. Custom evaluations $1.50 per 1,000, with model usage billed separately

Pricing reflects public plans as of November 17, 2026 and can change. Check Amazon Bedrock AgentCore for the latest.

What people actually build with Amazon Bedrock AgentCore

AgentCore is what you reach for after the agent works on a laptop and before it can be trusted with real users. It supplies the unglamorous production pieces: somewhere isolated to run, a way to authenticate, a memory store, a controlled route to tools. AWS's own documentation frames three kinds of build.

The builds that fit

A customer-facing agent in production. The agent is written with a framework such as LangGraph, CrewAI, LlamaIndex or Strands Agents and deployed to Runtime, where each session runs in its own isolated microVM. This is the support-agent example AWS prices on its own page.

Existing APIs turned into agent tools. Gateway converts APIs, Lambda functions and existing services into tools that speak the Model Context Protocol, so an agent can use your order system or HR system without that system being rewritten. AWS lists integrations including Salesforce, Zoom, JIRA and Slack.

An agent that needs a browser or needs to run code. The Browser service gives an agent a managed cloud browser for filling in forms and navigating sites. The Code Interpreter gives it an isolated sandbox for Python, JavaScript and TypeScript, which suits data analysis.

An internal agent platform. A company gives its own developers a paved path: approved tools in a Registry, shared memory stores, central identity and policy, one place for observability.

A quick managed agent with no framework at all. The Harness service is a managed agent loop where you specify a model, a system prompt and tools in a single API call, and AWS handles orchestration and tool execution.

What it is genuinely bad at

Simplicity. There is no visual builder for a business owner and no single plan to subscribe to. Using it well means understanding AWS identity and access management, networking, CloudWatch and billing. A team without those skills will spend more on learning AWS than on running agents. It is also overkill for a single low-volume automation that a hosted tool would run for a flat monthly fee.

Bottom line: AgentCore is for taking an agent a team has already built into production on AWS, not for building a first agent or avoiding engineering.

What Amazon Bedrock AgentCore actually costs at small-business volume

Start with the runtime, because it is the meter people ask about. The pricing page, read on 17 November 2026, lists Runtime v2 at $0.1276 per vCPU-hour and $0.0169 per GB-hour, billed per second with a one-second and 128 MB minimum. CPU is billed only while consumed, so it falls to zero during I/O wait. Idle memory is reclaimed after 120 seconds.

AWS's own worked example is a customer support agent: ten-minute sessions with 90 percent I/O wait, one vCPU during active processing, and memory of 1 GB for 300 seconds, 2 GB for 150 seconds and 2.5 GB for 150 seconds. CPU is 60 billed seconds times one vCPU times $0.1276 divided by 3,600, which is $0.002127. Memory is 300 plus 300 plus 375, so 975 GB-seconds, times $0.0169 divided by 3,600, which is $0.004577. Together, $0.006703 a session. AWS scales that to a million sessions at $6,703. Scale it down instead: 1,000 ten-minute sessions a month is $6.70.

Our reference workload is lighter still. Take 1,000 triage runs, each a 20-second session with 5 seconds of active CPU at one vCPU and half a gigabyte of memory throughout, which are our assumptions. CPU is 5 times $0.1276 divided by 3,600, so $0.000177. Memory is 0.5 times 20, so 10 GB-seconds, times $0.0169 divided by 3,600, so $0.000047. That is $0.000224 a run, or 22 cents for the month.

So the runtime is close to free at small-business volume. The bill comes from everything else. None of AWS's runtime examples includes model tokens; inference is billed by Amazon Bedrock or by whichever provider you call. Observability is billed under CloudWatch pricing. And each further AgentCore service you switch on has its own line.

AgentCore at 1,000 ten-minute sessions a month. Rates and the runtime profile from aws.amazon.com/bedrock/agentcore/pricing on 17 November 2026; per-session call counts are assumptions. Model tokens and CloudWatch are not included.
ServiceRateAssumed usageMonthly cost
Runtime v2 CPU$0.1276 per vCPU-hour60 billed seconds a session at 1 vCPU$2.13
Runtime v2 memory$0.0169 per GB-hour975 GB-seconds a session$4.58
Gateway invocations$0.005 per 1,0003,000 tool calls$0.015
Web Search$7.00 per 1,000 queries2,000 queries$14.00
Long-term memory storage$0.75 per 1,000 records a month1,000 records$0.75
Long-term memory retrieval$0.50 per 1,0002,000 retrievals$1.00
AgentCore subtotal--$22.47
Built-in evaluations, if run on every session$0.0024 in and $0.012 out per 1,000 tokens15,000 input and 300 output tokens each$39.60
Model inference and CloudWatchSeparate AWS price lists-Billed separately

A small production stack, added up

Take 1,000 ten-minute support sessions a month and add the services a real agent tends to use. Runtime: $6.70, from AWS's example profile. Gateway: three tool calls a session is 3,000 invocations at $0.005 per 1,000, which is $0.015. Web Search: two queries a session is 2,000 queries at $7.00 per 1,000, which is $14.00. Long-term memory: 1,000 stored records at $0.75 per 1,000 is $0.75, and 2,000 retrievals at $0.50 per 1,000 is $1.00.

That comes to $22.47 a month for the AgentCore services, before model tokens and CloudWatch. Two things stand out. The largest line is not compute; it is web search at $14. And the session counts, call counts and record counts are our assumptions, so substitute your own. The useful point is the shape: runtime is the small number, and per-call tools are where the cost accumulates.

Bottom line: AgentCore Runtime costs about $6.70 for 1,000 ten-minute sessions on AWS's own example profile, and a realistic stack around it reaches about $22 before model tokens, with web search the largest line.

The gotcha: a dozen meters, and evaluations that cost more than the agent

No single price on the AgentCore page is alarming. The difficulty is that there are so many of them, in different units, and that the cheap one is the one in the headline. Runtime is vCPU-hours and GB-hours. Gateway is invocations. Identity and Policy are requests. Memory is gigabytes for short-term and records for long-term. Web Search is queries. Evaluations are tokens. Registry is records and API calls. Observability is not on the page at all; it is billed under CloudWatch. A forecast means estimating each one separately, and the estimate is only as good as your guess at how many tool calls and retrievals an agent makes per session, which you do not know until it is running.

The clearest example of a small-looking price that is not small is evaluations. Built-in evaluations are $0.0024 per 1,000 input tokens and $0.012 per 1,000 output tokens. AWS's own example has 45,000 evaluations using 675 million input tokens and 13.5 million output tokens, which is 15,000 input and 300 output tokens each. That works out at $0.036 plus $0.0036, so $0.0396 per evaluation. Compare it with the runtime example's $0.006703 per session. Evaluating a session costs nearly six times as much as running it. Evaluate every one of 1,000 sessions and you add $39.60 to a $6.70 runtime bill. Evaluations are valuable, so sample them rather than running them on everything.

The second is the runtime version. The page lists two sets of microVM rates. Runtime v1 is $0.0895 per vCPU-hour and $0.00945 per GB-hour. Runtime v2 is $0.1276 and $0.0169, which is 43 percent more for CPU and 79 percent more for memory. In exchange, v2 reclaims memory during the session and releases idle memory after 120 seconds. Whether v2 costs you more or less depends on how much of a session your agent sits idle holding memory. The page does not say which accounts are on which version, so check what your deployment is billed at. It also lists lower committed-baseline rates for v2, $0.0997 and $0.0132, described on the page as launching by October 2026.

The third is the instance-based runtime option, which does not have an idle discount at all. There you pay the EC2 On-Demand price plus a management fee, 12 percent in AWS's example, from boot until stop. It exists for workloads that need a specific machine, and it removes the property that makes the microVM runtime cheap.

Finally, short-term memory has a floor. AWS's memory example bills events averaging 3 KB at a 12 KB minimum, so small events cost four times what their size suggests.

Bottom line: On AWS's own example figures a built-in evaluation costs $0.0396 against $0.0067 to run the session it evaluates, so sample evaluations instead of running them on every session.

What breaks in production, and how you find out

The most common production surprise on AgentCore is financial rather than functional, and it follows from the pricing model. A session that should take ten minutes and instead loops for an hour is billed for the hour. A tool that an agent calls repeatedly is billed per call. An agent that issues twenty web searches where two were expected turns a $14 line into $140. Set AWS Budgets alerts on the account before the first deployment, and put limits on tool calls per session in the agent itself.

The second is finding out what happened. Observability is a named AgentCore service that gives a view of each step in an agent's execution, and it emits telemetry in an OpenTelemetry-compatible format. Its cost is on the CloudWatch price list, and trace data for a verbose agent can be substantial. Decide what to retain and for how long, because the default of keeping everything is a growing bill.

Third, memory behaviour affects both cost and correctness. In Runtime v2 idle memory is reclaimed after 120 seconds. An agent that assumes in-process state survives a long pause may find it does not, so anything that must persist belongs in the Memory service or your own store, not in a variable.

Fourth, permissions. Most first deployments that fail on AWS fail on identity and access configuration, not on the agent. Identity integrates with existing providers, with AWS naming Amazon Cognito, Okta, Microsoft Entra ID and Auth0, and Policy intercepts tool calls at the Gateway before they execute. Used properly these are the reason to choose AgentCore. Used carelessly they are either too permissive or the cause of an agent that mysteriously cannot call its tools.

The ordinary agent failures still apply. A model returns something unexpected, a tool times out, a prompt change breaks a case that used to work. AgentCore gives you isolation and a record; it does not make the agent correct.

What we did not verify

The pages we read on 17 November 2026 did not give us a list of supported regions, service quotas or a maximum session duration, so none is stated here. The pricing page notes that new AWS customers receive up to $200 in Free Tier credits, and that the Registry includes 5,000 records and a monthly allowance of search and list calls free. Compliance attestations for AgentCore are published through AWS's own compliance programme pages, which we did not check; confirm scope there before placing regulated data in any of these services.

Bottom line: AgentCore bills for whatever the agent does, so a loop or a chatty tool is a cost incident: set AWS Budgets alerts and cap tool calls per session before going live.

What it connects to that you already run

AgentCore's central promise is that it does not make you choose. On frameworks, AWS says Runtime works with custom frameworks and any open-source one, naming CrewAI, LangGraph, LlamaIndex, Google ADK, the OpenAI Agents SDK and Strands Agents. On models, it names any foundation model in or outside Amazon Bedrock, including OpenAI, Google's Gemini, Anthropic's Claude, Amazon Nova, Meta Llama and Mistral models. On protocols, it supports MCP and A2A.

For business systems the integration point is Gateway. It converts existing APIs, Lambda functions and services into MCP-compatible tools and can connect to existing MCP servers, with AWS listing Salesforce, Zoom, JIRA and Slack among popular integrations. If your systems already have APIs, this is the fastest route to making them usable by an agent without writing a tool wrapper for each.

For identity, AgentCore Identity works with existing providers rather than replacing them, so users do not have to be migrated. For monitoring, telemetry is OpenTelemetry-compatible, so it can flow to a monitoring stack you already use as well as CloudWatch.

The services are also separable, and this is easy to miss. You can run your agent somewhere else entirely, on your own servers or another cloud, and use only Gateway for tool access or only Memory for persistence. Likewise the Registry catalogues agents and tools deployed on AWS, on premises or on any other cloud.

What it does not connect to is a non-developer. There is no library of ready-made business automations and no visual canvas. A business that runs n8n or Make.com for everyday automation would keep doing so, and call an AgentCore-hosted agent as one step where real reasoning is needed.

Bottom line: AgentCore works with any framework and model and turns existing APIs into agent tools through Gateway, and each service can be used on its own even if the agent runs elsewhere.

Amazon Bedrock AgentCore alternatives: what to pick instead, and when

The alternatives divide by how much you want managed and by whom. If your company runs on Microsoft, Copilot Studio is the managed agent platform that sits with the tools your staff already use, and if it runs on Salesforce, Agentforce plays the same role there. Both are products with builders, where AgentCore is infrastructure.

If you want to stay cloud-neutral and pay for compute by the second, Trigger.dev runs agent code with no duration limit and a simple two-rate bill. If you would rather host the runtime yourself for a flat fee, Agno's open-source AgentOS runs in your own cloud with nothing charged per run. If you want a framework with its own hosted platform, Mastra covers that in TypeScript.

And if the honest position is that you have one workflow and no AWS engineer, none of this is the right layer. A no-code platform such as n8n, or a managed service, will get you to a working automation sooner and for a number you can predict.

Alternatives to AgentCore. AgentCore, Trigger.dev, Agno and Mastra figures read on 17 November 2026; other rows follow this directory's August 2026 reviews.
ToolBilling unitWhat a small workload costsWho it suitsDoes better than AgentCore
Amazon Bedrock AgentCorePer-service consumption: vCPU-hours, calls, records, tokensAbout $22 for 1,000 sessions with tools, before model tokensTeams already on AWSIsolation, identity and tool gateway as managed services
Trigger.devCompute second plus a per-run feeAbout $10 for 1,000 five-minute runs on the default machineDevelopers outside AWSTwo rates instead of more than a dozen meters
AgnoFlat monthly fee for the control plane$0 to serve; $150 a month for a live deploymentPython teams hosting their own runtimeNo usage meter at all
MastraPlan plus compute and event overage$0 to $25 a month for small workloadsTypeScript product teamsFramework and hosting from one vendor
Copilot StudioVendor's own usage meter (August review)See that review for dated figuresMicrosoft 365 organisationsA builder non-developers can use
AgentforceVendor's own usage meter (August review)See that review for dated figuresSalesforce organisationsLives inside the CRM
n8nExecution (whole workflow run)EUR 20 a month Starter covered 2,500 executions (August review)Teams without cloud engineersA visual builder and a predictable plan

Bottom line: Choose AgentCore if you already run on AWS and need production controls; choose something with one or two meters if you need to predict the bill.

Migration and lock-in: can you get your work out?

AgentCore's lock-in is lower than most AWS services at the centre and higher at the edges. At the centre, your agent is code written with an open-source framework of your choosing, calling a model of your choosing. AWS's design point is that it does not require its own framework or its own models. That code would run on another host. The runtime is a place to run a container, and the thing you would replace is the deployment, not the agent.

The edges are where you become attached. Memory is the clearest case: once an agent's long-term memory lives in the Memory service, moving means exporting those records and rebuilding retrieval somewhere else. Identity and Policy configuration is AWS-specific, though Policy's language is described by AWS as compatible with Cedar, its open-source policy language, which helps. Gateway tool definitions follow MCP, an open protocol, so the tools themselves are portable even if the gateway is not. Observability data sits in CloudWatch unless you also send it elsewhere, which the OpenTelemetry-compatible format allows.

Commercially there is nothing to exit. Pricing is consumption-based with no upfront commitment or minimum fee, so stopping usage stops the bill. The committed-baseline rates listed for Runtime v2 would change that for anyone who takes them: a commitment is a discount in exchange for lock-in, and should be sized on measured usage.

The practical way to keep the exit open is to use the modularity deliberately. Adopt Runtime and Gateway, which are close to open standards. Think harder before making Memory the only copy of what your agents know. Send telemetry to a store you control as well as CloudWatch. And keep infrastructure defined as code, so the deployment is documented by something other than the console.

Bottom line: The agent code and MCP tool definitions are portable off AgentCore; the long-term memory records and the identity and policy configuration are what tie you to AWS.

Amazon Bedrock AgentCore FAQ

How much does Amazon Bedrock AgentCore cost?

It is consumption-based with no minimum fee. Runtime v2 is $0.1276 per vCPU-hour and $0.0169 per GB-hour, billed per second, as published on 17 November 2026. Other services have their own rates, such as $0.005 per 1,000 Gateway invocations and $7.00 per 1,000 web search queries.

What does one agent session cost on AgentCore Runtime?

AWS's own example of a ten-minute support session with 90 percent I/O wait costs $0.006703: $0.002127 for 60 billed seconds of one vCPU and $0.004577 for memory. That is $6.70 per 1,000 sessions, before model tokens.

Am I charged while the agent waits for a model response?

Not for CPU. The pricing page says Runtime CPU is billed only while consumed, so it scales to zero during I/O wait. Memory is still billed, and in Runtime v2 idle memory is reclaimed after 120 seconds.

Is model inference included?

No. AgentCore's rates cover the agent infrastructure. None of AWS's runtime examples includes model tokens, which are billed by Amazon Bedrock or by whichever model provider your agent calls.

What is the difference between Runtime v1 and v2 pricing?

v1 is $0.0895 per vCPU-hour and $0.00945 per GB-hour. v2 is $0.1276 and $0.0169, with memory reclaimed during the session and idle memory released after 120 seconds. The page also lists v2 committed-baseline rates of $0.0997 and $0.0132.

Do I have to use Amazon's models or framework?

No. AWS says AgentCore works with any open-source framework, naming CrewAI, LangGraph, LlamaIndex, Google ADK, the OpenAI Agents SDK and Strands Agents, and with any foundation model inside or outside Amazon Bedrock.

How much do AgentCore evaluations cost?

Built-in evaluations are $0.0024 per 1,000 input tokens and $0.012 per 1,000 output tokens. On AWS's example of 15,000 input and 300 output tokens per evaluation, that is $0.0396 each, nearly six times the cost of the example runtime session. Custom evaluations are $1.50 per 1,000 plus model usage.

Is there a free tier?

The pricing page says new AWS customers receive up to $200 in Free Tier credits. The Registry includes 5,000 records, 1,000,000 search calls and 2,000,000 list and get calls free each month, and Identity is free when used through Runtime or Gateway.

How is observability billed?

Under Amazon CloudWatch pricing, not on the AgentCore price list. Spans, logs and metrics from your agents are charged at CloudWatch's rates, so include that page when you forecast.

Looking at alternatives? AgentCore is infrastructure for engineering teams and assumes you bring the agent, the framework, the model and the AWS expertise. Autonoly is a managed service for businesses that want an automation delivered rather than a set of metered building blocks. If your team already lives in AWS, AgentCore is a credible way to run agents in production. If you do not have that team, start with the workflow, not the cloud console. See the Autonoly review.