Table of Contents
- AgentCore pricing at a glance
- Runtime V1 and V2 need different estimates
- Calculate an agent workload before comparing providers
- Code Interpreter adds a separate execution bill
- Persistence changes which runtime you should buy
- Compare Agent37 using running hours and retained disk
- Keep these costs outside the execution subtotal
- Measure a small pilot, then choose the execution layer
Do not index
Do not index
AgentCore pricing depends on which execution service you use: Runtime microVMs charge for consumed CPU and memory, Code Interpreter has its own execution meter, and Runtime Instances add a management fee to EC2 costs. Model tokens, storage, and other services can add separate charges. Agent37 is another option when you want a persistent agent workspace with compute and retained disk billed separately.
The useful comparison starts with your workload. How long does it run, how much CPU does it consume, and what must survive between jobs? A rate copied from an old tutorial can miss both a platform change and the biggest part of your bill.
This guide focuses on hosting agents and executing their code. Rates and documentation were checked on November 2, 2026. The examples are calculated budgets, not measured performance results.
AgentCore pricing at a glance
AWS publishes these USD consumption rates for the execution services:
Service | CPU rate per vCPU-hour | Memory rate per GB-hour |
Runtime microVMs V1 | $0.0895 | $0.00945 |
Runtime microVMs V2, consumption | $0.1276 | $0.0169 |
Code Interpreter | $0.0895 | $0.00945 |
Browser | $0.0895 | $0.00945 |
These are resource rates, not fixed prices per agent or request. Runtime Instances use a different bill: EC2 compute plus an AgentCore management fee. AWS's pricing example applies 12% to a general-purpose compute case and lists 7.8% for G-series GPU instances. Storage and transfer are additional. Check your region and instance family before using a quote. See the AWS AgentCore pricing page.
Start your estimate by writing down the service and platform version beside every rate. Keep Runtime and Code Interpreter on separate rows if your application uses both. That small discipline prevents counting only the agent's coordinator while leaving out the machines that execute its tools.
Runtime V1 and V2 need different estimates
AWS documents V1 as the default when creating a Runtime without an explicit platform version. V2 restores a prepared snapshot and can reclaim memory as the agent releases it. The platform version is separate from the numbered revisions of your deployed application. Check the actual setting instead of assuming that a newly deployed application uses V2. See Runtime platform versions.
V2's published unit rates are higher, but a unit price alone cannot tell you which version costs less for your application. A lower billed memory footprint can change the total. So can initialization overhead and the time spent waiting between turns.
For an initial budget, keep three quantities separate: elapsed session time, consumed CPU time, and billable memory over time. A two-minute interaction might contain only twenty seconds of CPU work. Memory can remain billable while the agent waits for a model response. Background processing can also keep CPU usage above zero. AWS's cost-control guide explains why wall-clock duration alone is insufficient.
For V1 and Code Interpreter, the documented memory meter uses peak consumption up to each second. V2 can reclaim unused memory. The published consumption rules include a one-second minimum and a 128-MB memory floor, so a tiny job still needs a minimum-charge allowance.
Use the consumption rates above as your baseline. The pricing page also lists committed V2 rates, but still labels them with a launch timeline. Confirm availability and commitment terms in your account before including a discount in a purchasing decision.
Calculate an agent workload before comparing providers
Suppose your monthly workload contains 10,000 sessions. Each lasts 120 billable seconds, consumes twenty vCPU-seconds in total, and maintains one billable GB throughout. Assume those measurements already include startup, system overhead, and the session's closing period. No extra idle tail remains.
The resource arithmetic is:
CPU hours = 10,000 × 20 / 3,600 = 55.5556
Memory GB-hours = 10,000 × 1 × 120 / 3,600 = 333.3333
Runtime V1 = 55.5556 × $0.0895 + 333.3333 × $0.00945
= $8.12
Runtime V2 = 55.5556 × $0.1276 + 333.3333 × $0.0169
= $12.72This deliberately holds billed usage constant to show the effect of the rate change. It does not model V2 reclaiming memory. Replace these assumptions with the usage profile of each version before choosing between them.
Now consider a cleanup bug. Each V1 session retains that one GB for another ten minutes after useful work finishes. Across 10,000 sessions, the extra 1,666.67 GB-hours adds $15.75 in memory charges, even if the added CPU usage is zero. Your idle tail now costs more than the original $8.12 execution estimate.
That is why cost per successful job is a better planning measure than the cheapest advertised CPU unit. Include retries, failures, initialization, and abandoned sessions. Record concurrency too: ten thousand sequential jobs and ten thousand simultaneous jobs require very different capacity planning, even when their aggregate resource usage matches.
Code Interpreter adds a separate execution bill
Runtime hosts your agent application. Code Interpreter provides an execution environment that application can invoke. You can use the interpreter as a tool without treating its session as the agent's own Runtime session.
The Code Interpreter workflow is to start a session, execute code, collect results, and stop it. Python, JavaScript, and TypeScript are supported, along with file operations. Reusing a session can preserve working state across several calls.
For example, budget a separate batch of 1,000 interpreter sessions, each with thirty consumed vCPU-seconds and one billable GB for sixty seconds. At the listed interpreter rates, CPU costs about $0.75 and memory about $0.16, for roughly $0.90 before other services. Add that amount to the coordinator's bill only if both services actually ran.
The session documentation gives a fifteen-minute default timeout, configurable up to eight hours. Session files are working state; export required outputs before stopping the session. A successful tool response should trigger artifact collection and cleanup, including on application errors.
Choose the network mode deliberately. AWS documents Sandbox, Public, and VPC options for custom interpreters, with different access paths. The execution role determines which AWS resources the code can reach. Review interpreter resource settings alongside the budget: cheaper execution is not useful if the workload cannot safely access its input data.
Persistence changes which runtime you should buy
A short data transformation and a week-long coding workspace have different needs. Reinstalling dependencies and downloading the same repository for every job can turn a low unit price into a poor workflow.
For Runtime microVMs, the documented lifecycle defaults are fifteen minutes of idle time and an eight-hour maximum lifetime. Instances can support longer lifetimes, up to fourteen days. These settings govern execution resources; they should not be confused with a guarantee that all application state is durable. See Runtime lifecycle configuration.
AWS's Instances compute type provisions managed EC2 resources in your account. It supports persistent volumes across session stops and multiple collaborating agents in one session. Your EC2 pricing agreements can apply to the underlying compute. The management fee remains a separate cost component.
For an Instances budget, specify the exact EC2 shape, region, running hours, storage capacity, and storage retention. Include networking and the management fee. Do not apply the microVM rate table to an EC2-backed deployment.
For any provider, distinguish stopping compute from deleting data. A stopped workspace can still have a storage bill. A deleted workspace can have no usable project files. Decide which outcome your workflow needs before automating cleanup.
Compare Agent37 using running hours and retained disk
Agent37 offers standard gVisor sandboxes and full VM sandboxes. Standard compute shares host resources. Its published rates per 730-hour month are $0.80 per vCPU, $0.70 per GB of RAM, and $0.09 per GB of disk, metered by the minute. Compute bills while the sandbox runs, including idle time; retained disk bills separately. See current sandbox pricing.
For a 2-vCPU, 4-GB-RAM allocation, compute is $4.40 per 730 running hours. Four GB of disk retained for the full 730 hours adds $0.36. Full VMs multiply compute by 2.5 while keeping the disk rate unchanged.
Agent37 allocation: 2 vCPU, 4 GB RAM, 4 GB disk | 60 running hours, disk retained 730 hours | 730 running hours, disk retained 730 hours |
Standard gVisor | $0.72 | $4.76 |
Full VM | $1.26 | $11.36 |
The sixty-hour examples assume the instance is stopped or asleep for the rest of the period. Auto-sleep must be configured. Leaving it awake while waiting continues the compute meter. These totals exclude model and tool charges.
AgentCore's consumed resources and Agent37's allocated running resources are different meters. You cannot replace the AWS example's 333.33 aggregate session-hours with sixty hours of one Agent37 sandbox without proving the workload fits. Benchmark completion time, concurrency, isolation requirements, and failure recovery before drawing a savings conclusion. A sparse workload can favor consumption billing; a frequently used workspace can make low running rates attractive.
Runtime compatibility matters too. Standard gVisor cannot run a Docker daemon. For Docker or Compose, evaluate a full VM. The Ubuntu VM template defaults to 12 GB of disk when resources are omitted, making the corresponding 730-hour estimate $12.08. The $11.36 example requires an explicit 4-GB disk. VM creation requires a funded workspace.
Keep these costs outside the execution subtotal
Model inference is its own budget. An agent that makes ten reasoning calls can spend more on tokens than on the process coordinating them. Changing the sandbox provider does not automatically change that token consumption.
AgentCore Memory is also distinct from a runtime's RAM. It stores conversation events and longer-term knowledge, with its own service behavior and billing. If you use the AWS harness, check whether memory is enabled rather than assuming it is an optional feature you never activated. The harness memory guide explains the configuration.
Keep a separate allowance for images or source artifacts, durable files, logs, metrics, data transfer, and any other AgentCore services you enable. Track both the production system and its development copies. An abandoned test environment can consume budget without appearing in your production job count.
Apply trial credits only after calculating the recurring gross cost. AWS advertises up to $200 in credits for eligible new customers; eligibility and expiration matter. Agent37's eligible new Cloud accounts receive $5 starter credit after adding a card. Neither offer establishes a permanent free execution tier. Keep VM funding requirements separate from the trial headline.
Measure a small pilot, then choose the execution layer
Run a representative batch containing easy jobs, large inputs, retries, and timeouts. Save the number of successful outputs alongside CPU usage, memory usage, elapsed time, retained storage, and model spend. Repeat with the same workload and required isolation on the alternative runtime.
AWS exposes interpreter CPU and memory telemetry, but notes that monitoring values can differ from the final metered bill. Use the built-in tools metrics to diagnose behavior, then reconcile the result with billing records. Avoid treating a dashboard graph as an invoice.
Choose AgentCore when its AWS integration, session model, and consumption billing fit the application. Consider Agent37 when your requirement is an affordable persistent sandbox or full VM and you can own the application's orchestration. Those are architecture choices as well as pricing choices.
For a wider provider comparison, read our guide to sandbox costs for AI agents. If Agent37 fits your workload, review the instance lifecycle API and create a sandbox. Start with one representative job, verify its outputs, and measure the bill before expanding the fleet.
