{"slug": "aws-agentcore-in-production", "title": "AWS AgentCore in Production", "summary": "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.", "body_md": "[All guides](https://www.omnara.com/guides)\n\n# AWS AgentCore in Production\n\nWhat Amazon Bedrock AgentCore costs, what you still build around it, and where it breaks once customers depend on it\n\n## On this page\n\n[Amazon Bedrock AgentCore](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html) 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.\n\nAWS 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.\n\n## What You're Actually Buying\n\nAgentCore spans many services, and each maps to one problem an agent runs into in production:\n\n- 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.\n- The [harness](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness.html) 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.\n- 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.\n- 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.\n- Memory stores conversation events for the short term and extracts facts, summaries, and preferences for the long term, kept separately for each user.\n- Observability sends OpenTelemetry traces, logs, and metrics to CloudWatch.\n\nBeyond 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.\n\nRuntime also has a second compute type, [AgentCore Instances](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-instances-how-it-works.html). It runs sessions for up to 14 days on EC2 machines that AWS operates inside your own account.\n\nHere'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.\n\nWhen 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.\n\n## What It Really Costs\n\nMost of the bill comes from model tokens, which AgentCore doesn't sell. Runtime [bills per second](https://aws.amazon.com/bedrock/agentcore/pricing/) 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.\n\nThe examples below assume each agent holds about 1 GB of memory and, like [AWS's own pricing example](https://aws.amazon.com/bedrock/agentcore/pricing/), spends most of its time waiting on the model and tools.\n\nHosting 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](https://platform.claude.com/docs/en/about-claude/pricing#claude-managed-agents-pricing) at Claude Sonnet 5.5's list price.\n\nSo 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](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness-operations.html#harness-costs) keeps the session warm, up to its 8-hour limit.\n\nApprovals 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.\n\nWith 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.\n\nInstances can hold the agent for the whole day, but [each session there is its own EC2 instance](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-instances-how-it-works.html#runtime-instances-session). The instance bills for every hour it waits. At the size in [AWS's own example](https://aws.amazon.com/bedrock/agentcore/pricing/), that's about $8 a day for every approval still waiting, or about $2,300 for a hundred left over a three-day weekend.\n\nLong, 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](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/bedrock-agentcore-limits.html#invocation-limits).\n\nThe other services add smaller amounts, priced by use. Gateway charges [$5 per million tool calls](https://aws.amazon.com/bedrock/agentcore/pricing/), and AWS's Memory example of 100,000 events and 20,000 retrievals comes to about $19 a month.\n\n## What You Still Assemble\n\nAgentCore'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](https://www.omnara.com/guides/deploy-ai-agents-to-production) covers the same pieces for any platform.\n\nStart with who owns a session. AgentCore [doesn't enforce session-to-user mappings](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-sessions.html), so your backend keeps track of which sessions belong to which customer.\n\nNext is state that outlives the session. Runtime's docs call session state [ephemeral](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-how-it-works.html#runtime-sessions-overview) 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](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/bedrock-agentcore-limits.html#memory-limits). Files need session storage, a [preview feature](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-filesystem-configurations.html) capped at 1 GB per session, or your own EFS or S3 file system.\n\nApprovals are still mostly yours. The harness can [hand a tool call back](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness-tools.html#harness-inline-functions) 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.\n\nCrashes land on your code as well. When a microVM fails its health checks or reaches its lifetime, [Runtime stops it](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-sessions.html#session-lifecycle), 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.\n\nPer-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](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway-rate-limits.html), but a spending budget per customer comes from your own metering. AWS says its [observability](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/harness-operations.html#harness-costs) \"explains activity but is not a billing report.\"\n\nWiring Gateway and Identity together adds its own setup. For a tool that acts as the user, you host a [public HTTPS callback](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/oauth2-authorization-url-session-binding.html) that confirms who is signed in, unless your gateway uses AWS's hosted [consent portal](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/identity-consent-portal.html). AWS also recommends putting the gateway in front of the runtime and [restricting the runtime](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-security-best-practices.html#security-bp-front-with-gateway) to calls from it, so its policies apply to every request.\n\n## Where It Breaks in Production\n\nNone of the limits below are hidden. Each one turns into a specific failure once customers use the agent every day.\n\nSession length comes first. A microVM's lifetime timer [starts at creation and can't be reset](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-lifecycle-settings.html#lifecycle-and-session-relationship), so even a busy session ends at 8 hours. An AWS Enterprise Support [article on re:Post](https://repost.aws/articles/AR-pO0BoxiSUe0Z4JT41z_hQ) notes that AWS documents no warning before that cutoff, so agents have to save their progress on their own schedule.\n\nBackground jobs can run the full 8 hours, but only while your agent [keeps reporting that it's busy](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-long-run.html), so one stuck thread can end the job. One team's [production write-up](https://www.letsdodevops.com/p/agentcore-deployment-operations-and) describes a blocked thread that stopped those reports, after which \"AgentCore’s service recycles the app.\"\n\nFixes are slow to reach customers. Every deploy takes several minutes while AWS prepares a [snapshot of your started agent](https://aws.amazon.com/blogs/machine-learning/the-new-agentcore-runtime-elastic-optimized-and-consistently-fast-starts/), which is how Runtime keeps cold starts short.\n\nEven then, a deploy doesn't move running sessions. Each microVM keeps the code it started with [until it terminates](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-troubleshooting.html#troubleshoot-code-updates), 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.\"\n\nWhen a session does restart on the new version, its [session storage](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-filesystem-configurations.html#session-storage-data-lifecycle) comes back empty. A redeploy also won't stop a session that's misbehaving, so you have to find it and [stop it yourself](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-stop-session.html).\n\nData residency needs a close read. Memory and Evaluations use [cross-region inference](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/cross-region-inference.html), 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.\n\nFor failover, AWS's [disaster recovery guide](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/disaster-recovery-resiliency.html) 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.\n\nQuotas arrive with scale. An account starts with room for [5,000 sessions at once](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/bedrock-agentcore-limits.html#runtime-service-limits) in N. Virginia and Oregon, and 2,500 in other regions. A launch bigger than that needs a quota increase first.\n\n## Where AgentCore Fits\n\nIf 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](https://aws.amazon.com/bedrock/agentcore/faqs/), and it runs agents from any framework on any model, in or outside Bedrock.\n\nEach 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.\n\nThe costs you accept are the ones above, starting with an agent tied to AWS and several of its services.\n\n## How Omnara Compares\n\n[Omnara](https://github.com/omnara-ai/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:\n\n- 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](https://docs.omnara.com/agents/configuration) what it sends to the model.\n- Approvals [wait in Postgres](https://docs.omnara.com/tools/permissions) for as long as a person needs.[Custom tool](https://docs.omnara.com/tools/custom) calls wait the same way until your backend posts a result.\n- 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](https://docs.omnara.com/agents/failure-handling) , 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.\n- A fix reaches a running agent without a new conversation. You [change its model, tools, permissions, or instructions](https://docs.omnara.com/events/sending-input#change-the-config-mid-conversation) through the API, and the change applies at its next model call.\n- Per-customer usage comes from the API, where each input can name the [end user](https://docs.omnara.com/events/sending-input#who-said-that-actors-and-attribution) who sent it. The[usage API](https://docs.omnara.com/api-reference/endpoints/agents/get-agent-usage) reports model tokens and cost per agent, project, and organization.\n- Waiting costs little, because the loop runs in Omnara's control plane, separate from the [machines](https://docs.omnara.com/machines/overview) where agents run commands. Omnara-managed machines sleep when idle.\n\nFor an AWS team, the strongest option is running Omnara inside your own AWS account. [Self-hosting](https://docs.omnara.com/self-hosting/deployment) 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.\n\nYour models and tools can stay on AWS too. Omnara connects to [Amazon Bedrock](https://docs.omnara.com/organization/model-providers) with AWS credentials or an assumed role, alongside OpenAI, Anthropic, OpenRouter, and any compatible endpoint. It also signs [MCP requests with SigV4](https://docs.omnara.com/tools/mcp#aws-signature-version-4-auth), so it can call MCP servers that use IAM auth, including tools behind an AgentCore Gateway.\n\nOmnara 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](https://terminal-bench.omnara.com/) and [the harness](https://github.com/omnara-ai/omnara-terminal-bench) are public, so you can rerun it yourself.\n\nOn [Omnara Cloud](https://www.omnara.com/pricing), 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.\n\nSelf-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](https://cal.com/ishaan-sehgal-8kc22w/chat-with-omnara).\n\nYou 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\\]](https://www.omnara.com/cdn-cgi/l/email-protection#9ffcf0f1ebfefcebdff0f2f1feedfeb1fcf0f2).\n\n## Which One to Use\n\nAgentCore 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.\n\nFor 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.\n\nFor 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).\n\n## FAQ\n\n### How much does AgentCore cost?\n\nRuntime 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.\n\n### What is AgentCore Runtime?\n\nIt'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.\n\n### How long can an AgentCore session run?\n\nA 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.\n\n### Is AgentCore worth it?\n\nIt'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.\n\n### Is there an open-source alternative to AgentCore?\n\nYes. 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.", "url": "https://wpnews.pro/news/aws-agentcore-in-production", "canonical_source": "https://www.omnara.com/guides/agentcore-in-production", "published_at": "2026-11-16 00:00:00+00:00", "updated_at": "2026-11-17 20:23:46.217675+00:00", "lang": "en", "topics": ["ai-agents", "ai-infrastructure", "ai-products", "mlops"], "entities": ["Amazon Web Services", "Amazon Bedrock AgentCore", "AgentCore Runtime", "AgentCore Gateway", "AgentCore Identity", "AgentCore Memory", "Strands Agents", "CloudWatch"], "also_reported_by": [], "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.", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/aws-agentcore-in-production", "markdown": "https://wpnews.pro/news/aws-agentcore-in-production.md", "text": "https://wpnews.pro/news/aws-agentcore-in-production.txt", "jsonld": "https://wpnews.pro/news/aws-agentcore-in-production.jsonld"}}