cd /news/ai-agents/aws-agentcore-in-production · home › topics › ai-agents › article
[ARTICLE · art-171214] src=omnara.com ↗ pub= topic=ai-agents verified=true sentiment=· neutral

AWS AgentCore in Production

Amazon Bedrock AgentCore's Runtime bills per second for CPU and memory, and an agent holding about 1 GB of memory costs roughly $5 a month to host versus about $44 in model tokens, making the model roughly 90% of the total, according to AWS's AgentCore pricing documentation. AWS positions AgentCore's Runtime, harness, Gateway, Identity, Memory, Observability, Policy, Evaluations, Browser and Code Interpreter as modular services, but the guide states that joining them into a production agent — including mapping sessions to customers and handling approvals that can wait a day — remains mostly the customer's job. Runtime sessions run up to 8 hours and stop after 15 idle minutes by default, while the separate AgentCore Instances compute type runs sessions for up to 14 days on EC2 machines AWS operates inside the customer's own account.

key takeaway

Runtime bills per second with CPU dropping to zero while an agent waits on the model or a tool and idle memory reclaimed after two minutes, so a 1 GB agent costs about $5 a month to host against roughly $44 in model tokens — about 90% of the total.

by read13 min views6 publishedNov 16, 2026
AWS AgentCore in Production
Image: Omnara (auto-discovered)

All guides What Amazon Bedrock AgentCore costs, what you still build around it, and where it breaks once customers depend on it

On this page #

Amazon Bedrock AgentCore is AWS's set of services for running AI agents. At its center is Runtime, which hosts your agent's code in an isolated microVM for each session and scales it for you. Runtime works with any framework and any model, and around it sit services for tools, credentials, memory, tracing, and policy.

AWS describes these as modular services you can use together or independently, and each one handles a single piece of running an agent. Joining them into an agent customers rely on is mostly your job, from tracking which session belongs to which customer to approvals that can wait a day.

What You're Actually Buying #

AgentCore spans many services, and each maps to one problem an agent runs into in production:

  • Runtime hosts your agent's code or container, built with any framework or none, in a dedicated microVM per session. A session's compute lasts up to 8 hours and stops after 15 idle minutes by default.
  • The harness is AWS's own agent loop, built on Strands Agents. You declare the model, tools, and instructions as configuration, and it saves the conversation to Memory and runs on Runtime with no separate charge.
  • Gateway turns your APIs, Lambda functions, and existing MCP servers into tools behind one MCP endpoint. It authenticates calls on the way in and out.
  • Identity checks who is calling your agent. It stores the OAuth tokens and API keys your agent uses, keeping each user's OAuth tokens tied to that user.
  • Memory stores conversation events for the short term and extracts facts, summaries, and preferences for the long term, kept separately for each user.
  • Observability sends OpenTelemetry traces, logs, and metrics to CloudWatch.

Beyond those, Policy checks tool calls that pass through Gateway against rules you write, and Evaluations scores the agent's traces. Browser and Code Interpreter give it sandboxes for the web and for code.

Runtime also has a second compute type, AgentCore Instances. It runs sessions for up to 14 days on EC2 machines that AWS operates inside your own account.

Here's how the core pieces meet in a support agent inside a SaaS product. Your backend signs the user in, picks a session ID for the conversation, and invokes Runtime with the user's token. The agent loads that user's history from Memory, calls the model, and reaches your ticketing API through Gateway.

When a tool needs the user's own Zendesk access, Identity returns the stored token, or a consent link if the user hasn't granted it yet. Policy checks the call, and every step lands in CloudWatch. That's five AgentCore services plus CloudWatch, each with its own configuration and IAM permissions.

What It Really Costs #

Most of the bill comes from model tokens, which AgentCore doesn't sell. Runtime bills per second for the CPU and memory your agent uses. CPU drops to zero while the agent waits on the model or a tool, and AWS reclaims idle memory after two minutes, so a waiting agent costs almost nothing to host.

The examples below assume each agent holds about 1 GB of memory and, like AWS's own pricing example, spends most of its time waiting on the model and tools.

Hosting is the small part of the bill. An agent costs about $5 a month in Runtime and about $44 in tokens, so the model makes up about 90% of the total. The token estimate uses the hourly usage from Anthropic's pricing example at Claude Sonnet 5.5's list price.

So AgentCore's bill rarely decides the choice. What matters more is how long a session lasts and what you build around it. A session ends after 15 idle minutes by default. A customer who steps away for lunch comes back to a fresh microVM, which has to reload the conversation from Memory before the agent can answer. A longer idle timeout keeps the session warm, up to its 8-hour limit.

Approvals run into the same limit. A microVM costs next to nothing while it waits for a reviewer, but it can't outlive 8 hours, so a reply that comes the next morning lands in a fresh microVM. The conversation comes back from Memory, but anything the agent kept only in its process or on its local disk is gone.

With your own code on Runtime, the usual AWS pattern is to save the agent's state, end the session, and resume when the reviewer answers, for example with a Step Functions task token. It works, and it's one more piece you build and run.

Instances can hold the agent for the whole day, but each session there is its own EC2 instance. The instance bills for every hour it waits. At the size in AWS's own example, that's about $8 a day for every approval still waiting, or about $2,300 for a hundred left over a three-day weekend.

Long, CPU-heavy work is where hosting starts to show up on the bill. Twenty 40-minute builds a workday come to about $95 a month. A run that long has to stream its output or run as a background task, because a plain request times out after 15 minutes.

The other services add smaller amounts, priced by use. Gateway charges $5 per million tool calls, and AWS's Memory example of 100,000 events and 20,000 retrievals comes to about $19 a month.

What You Still Assemble #

AgentCore's docs are clear about where each service stops, and the gaps sit between them. Most apply whether you use the harness or your own code. Deploying AI Agents to Production covers the same pieces for any platform.

Start with who owns a session. AgentCore doesn't enforce session-to-user mappings, so your backend keeps track of which sessions belong to which customer.

Next is state that outlives the session. Runtime's docs call session state ephemeral and point you to Memory, so your agent saves each turn and reloads it in the next microVM. The harness does that for you, though Memory events expire after 7 to 365 days. Files need session storage, a preview feature capped at 1 GB per session, or your own EFS or S3 file system.

Approvals are still mostly yours. The harness can hand a tool call back to your code and resume when you send the result, but the approval screen, the notification, and tracking each pending call until a reviewer answers are yours to build.

Crashes land on your code as well. When a microVM fails its health checks or reaches its lifetime, Runtime stops it, and whatever the agent held in memory goes with it. Your tools have to record that a call started, so a retry doesn't charge a card twice.

Per-customer budgets are another gap. The harness stops each run after 75 steps or an hour by default, and Gateway can rate-limit each caller, but a spending budget per customer comes from your own metering. AWS says its observability "explains activity but is not a billing report."

Wiring Gateway and Identity together adds its own setup. For a tool that acts as the user, you host a public HTTPS callback that confirms who is signed in, unless your gateway uses AWS's hosted consent portal. AWS also recommends putting the gateway in front of the runtime and restricting the runtime to calls from it, so its policies apply to every request.

Where It Breaks in Production #

None of the limits below are hidden. Each one turns into a specific failure once customers use the agent every day.

Session length comes first. A microVM's lifetime timer starts at creation and can't be reset, so even a busy session ends at 8 hours. An AWS Enterprise Support article on re:Post notes that AWS documents no warning before that cutoff, so agents have to save their progress on their own schedule.

Background jobs can run the full 8 hours, but only while your agent keeps reporting that it's busy, so one stuck thread can end the job. One team's production write-up describes a blocked thread that stopped those reports, after which "AgentCore’s service recycles the app."

Fixes are slow to reach customers. Every deploy takes several minutes while AWS prepares a snapshot of your started agent, which is how Runtime keeps cold starts short.

Even then, a deploy doesn't move running sessions. Each microVM keeps the code it started with until it terminates, so for up to 8 hours two versions of your agent serve customers side by side. AWS's support article notes that "a rollback reaches active users only as their environments recycle."

When a session does restart on the new version, its session storage comes back empty. A redeploy also won't stop a session that's misbehaving, so you have to find it and stop it yourself.

Data residency needs a close read. Memory and Evaluations use cross-region inference, which keeps stored data in your region but can process prompts in other regions of the same geography. From some regions the routing is global, such as Evaluations from Mumbai or Singapore, and CloudWatch and CloudTrail don't record where a prompt was processed.

For failover, AWS's disaster recovery guide says "recovery across Regions is yours to design and operate." It also notes that Memory, which isn't offered in every region, usually decides which regions you can pair. Quotas arrive with scale. An account starts with room for 5,000 sessions at once in N. Virginia and Oregon, and 2,500 in other regions. A launch bigger than that needs a quota increase first.

Where AgentCore Fits #

If your company runs on AWS and wants AWS to operate the agent runtime under IAM, your VPC, and CloudTrail, nothing fits more natively. It's HIPAA eligible, and it runs agents from any framework on any model, in or outside Bedrock. Each session gets its own microVM that's terminated and sanitized when it ends. Instances add 14-day sessions, GPUs, and your own EC2 pricing agreements. The harness gets a configured agent running without writing a loop, and Gateway turns existing Lambda functions into tools in a few lines.

The costs you accept are the ones above, starting with an agent tied to AWS and several of its services.

How Omnara Compares #

Omnara is the open-source managed agent platform. It runs the agent loop and the pieces around it as one service, saving every step an agent takes to Postgres as it happens. Each hard case above has a direct answer:

  • There's no session lifetime to plan around. An agent keeps one history for its whole life, and when the model's context fills up, Omnara compacts what it sends to the model.
  • Approvals wait in Postgres for as long as a person needs.Custom tool calls wait the same way until your backend posts a result.
  • Deploys and crashes don't lose work, because another worker continues from the last saved step. A tool call the crash cut off isn't rerun , so the agent can check its outcome before acting again. Each custom tool call also carries a stable ID your backend can use to deduplicate it.
  • A fix reaches a running agent without a new conversation. You change its model, tools, permissions, or instructions through the API, and the change applies at its next model call.
  • Per-customer usage comes from the API, where each input can name the end user who sent it. Theusage API reports model tokens and cost per agent, project, and organization.
  • Waiting costs little, because the loop runs in Omnara's control plane, separate from the machines where agents run commands. Omnara-managed machines sleep when idle.

For an AWS team, the strongest option is running Omnara inside your own AWS account. Self-hosting needs Postgres, Redis, S3-compatible storage, and a shared filesystem, which map to RDS, ElastiCache, S3, and EFS. The agent loop and every agent's history then stay in your account, under your IAM and VPC controls, on AWS's HIPAA-eligible services. Your models and tools can stay on AWS too. Omnara connects to Amazon Bedrock with AWS credentials or an assumed role, alongside OpenAI, Anthropic, OpenRouter, and any compatible endpoint. It also signs MCP requests with SigV4, so it can call MCP servers that use IAM auth, including tools behind an AgentCore Gateway.

Omnara runs its own agent loop, where AgentCore's harness runs Strands. On Terminal-Bench 4.0, Omnara matched the pass rates of Claude Code and Codex on the same models. It ran 12% faster than Claude Code and 11% cheaper than Codex. Its 69.6% with Claude Opus 5.5 is the top score. Terminal-Bench's own runner graded every run. Every trace and the harness are public, so you can rerun it yourself.

On Omnara Cloud, there's no platform fee, and your own model keys and machines cost nothing. Models bought through Omnara cost the provider's token rates, and its machines are billed by usage. Both are paid with credits that carry a 5% service fee covering provider costs.

Self-hosting is free under Apache 2.0. Omnara's team can also deploy and manage it in your own cloud (BYOC) or on premises, with SSO, audit logs, and custom SLAs. To set that up, book a call with the founders.

You can export all your data at any time, including every agent's full history, and run it on your own self-hosted Omnara by emailing [email protected].

Which One to Use #

AgentCore fits teams that are all-in on AWS and want AWS to operate the runtime. It suits agents whose tasks each fit inside an 8-hour session, or that need GPUs on Instances, as long as you're fine building the pieces between its services.

For agents people depend on, choose Omnara. Its agents have no session lifetime and lose no work to deploys or crashes, so approvals can wait as long as a person needs. It runs any model, Bedrock included, and you can self-host all of it inside your own AWS account.

For more options, see [What AI Agents Need in Production](https://www.omnara.com/guides/ai-agent-infrastructure), [Self-Hosted Managed Agents](https://www.omnara.com/guides/self-hosted-managed-agents), and [Claude Managed Agents Alternatives](https://www.omnara.com/guides/claude-managed-agents-alternatives).

FAQ #

How much does AgentCore cost?

Runtime bills per second for the CPU and memory an agent uses, and CPU isn't charged while the agent waits. An agent that works through every workday costs about $5 a month to host. Model tokens are billed separately and are usually most of the bill.

What is AgentCore Runtime?

It's AWS's serverless host for agent code. You deploy an agent built with any framework as code or a container, and Runtime runs each session in its own microVM. Sessions last up to 8 hours and stop after 15 idle minutes by default.

How long can an AgentCore session run?

A session's compute lasts up to 8 hours on microVMs and up to 14 days on Instances. The session ID stays valid afterward, but the next call starts a fresh environment. The agent then reloads what it needs from AgentCore Memory or your own storage.

Is AgentCore worth it?

It's worth it if you're committed to AWS and want AWS to operate the runtime. If you'd rather not build session tracking, approval flows, and per-customer usage yourself, Omnara covers those and can run inside your own AWS account.

Is there an open-source alternative to AgentCore?

Yes. Omnara is an open-source managed agent platform under Apache 2.0. You can use Omnara Cloud or self-host it in your own AWS account for free, with Bedrock or any other model provider.

── more in #ai-agents 4 stories · sorted by recency
── more on @amazon web services 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/aws-agentcore-in-pro…] indexed:0 read:13min 2026-11-16 · —