If you compare managed agent hosts by their vCPU-hour rate, you are comparing the number that moves your bill least. For a chat agent with think time between turns, Google's Agent Runtime (still widely searched as Vertex AI Agent Engine) has the cheapest runtime meter, because it bills allocated vCPU only during a turn. Amazon Bedrock AgentCore Runtime is cheaper for long tasks that wait on a model, because its CPU meter stops during I/O wait. Microsoft Foundry's prompt agents carry no platform fee, so they win if your agent fits a declarative definition. Foundry's hosted agents come last for short, bursty sessions: every session gets its own sandbox, and Microsoft does not say compute stops metering before the idle timeout (default 15 minutes).
The workload behind every number below is one customer support agent: 300,000 sessions a month, 4 turns per session, 15 seconds of wall clock per turn of which 2 seconds is active CPU, 30 seconds of user think time between turns, 1 vCPU and 2 GB per session, 6 tool calls, 8 short-term memory events (12 KB each, kept 30 days) and 1 long-term memory lookup per session, 2 new long-term memories written per session, and 500,000 long-term records on file. Model tokens are excluded because they cost roughly the same wherever you call the model from. All prices are list, US regions, checked on each vendor's live pricing page on October 31, 2026.
| Monthly bill, same workload | AgentCore Runtime (v2) | Google Agent Runtime | Foundry prompt agent | Foundry hosted agent (120 s timeout) |
|---|---|---|---|---|
| Runtime compute | $845.57 | $509.85 | $0 | $2,767.50 |
| Memory and sessions | $579.72 | $8.87 plus model tokens | $875.00 | $875.00 |
| Tool gateway | $9.00 | $10.20 | no meter listed | no meter listed |
| Total before model tokens | $1,434.29 | $528.92 plus memory tokens | $875.00 | $3,642.50 |
| Who should not pick it | Chat agents with long think time between turns | Agents that need hard per-session VM isolation by default | Agents that run your own code or framework | Short, bursty sessions; anyone needing GA terms today |
Memory is the whole bill for a Foundry prompt agent and 40% of the AgentCore total. Google's memory meter looks almost free because it excludes the model tokens that generate memories, so you buy less for that $8.87 than you do on AWS.
What Each Platform Charges for Runtime
Runtime is the compute that hosts your agent's own code between and during model calls. The three vendors publish it in the same units (vCPU-hours and memory-hours), which is why buyers compare it first.
| Runtime meter (list, US) | vCPU-hour | Memory | Granularity | Source |
|---|---|---|---|---|
| AgentCore Runtime microVM v2 | $0.1276 | $0.0169 per GB-hour | per second, 1 s minimum, 128 MB memory floor | AWS AgentCore pricing |
| AgentCore Runtime microVM v1 | $0.0895 | $0.00945 per GB-hour | per second | AWS AgentCore pricing |
| Google Agent Runtime | $0.085 | $0.009 per GiB-hour | rounded to the nearest second | Google Agent Platform pricing |
| Foundry hosted agents | $0.0994 | $0.0118 per hour on the Hosted Memory Usage meter (priced here per GiB) | hourly meter on consumed container compute | Azure retail price list, Foundry Agents |
| Foundry prompt agents | no charge | no charge | not applicable | Azure Foundry Agent Service pricing |
Each vendor has a discount path. AWS lists a v2 committed baseline at $0.0997 per vCPU-hour and $0.0132 per GB-hour, launching by October 2026, per the AgentCore pricing page. Google lists 1-year and 3-year savings plans that take Agent Compute to $0.0765 and $0.068 per vCPU-hour on its Agent Platform pricing page. Microsoft's public Foundry Agent Service pricing page renders its rate cells as "$-", so the hosted-agent figures above come from Microsoft's own retail prices API, East US, effective February 1, 2026.
AgentCore v1 has the lower unit rate, but v2 reclaims idle memory automatically after 120 seconds. On a chat workload, memory held between turns is most of the AgentCore runtime bill, so v2 is usually the right choice despite its higher sticker price.
Active CPU vs Wall Clock: What You Pay While the Agent Waits
The billing rule that decides your runtime bill is what happens while the agent waits on a model. An agent spends most of each turn waiting on an LLM or a tool, so the waiting rule matters far more than the rate.
AgentCore bills active CPU and held memory. AWS says "CPU scales to zero during I/O wait (waiting for LLM responses, tool / API calls, or database queries)", while memory is still held and billed until it is reclaimed, per its pricing page. In our workload that means 8 seconds of CPU per session and 270 seconds of held memory (150 seconds of session plus the 120-second reclaim window). Memory is 90% of the AgentCore runtime line. An independent write-up by Classmethod found the same shape on a real bill: $5.36 of a $5.63 charge in under half an hour was runtime memory, 566.76 GB-hours against 3 vCPU-hours, after parallel invocations scaled out sessions that each showed several GB of memory. The same author notes that users cannot set memory size on that harness.
Google bills allocated vCPU for the length of a turn, and nothing between turns. Its pricing page says compute is the vCPU "allocated to the agent" and that "idle time spent waiting for the next prompt between turns is not billed", per the Agent Platform pricing page. So Google charges you while the agent waits on the model inside a turn, and stops charging during the user's 30 seconds of think time. AWS does the opposite on both counts. Google's scaling guide also defaults min_instances to 1 and measured cold starts at about 4.7 seconds against 0.4 seconds warm. The pricing page does not say whether that warm instance accrues charges when idle, so check your first invoice.
Foundry hosted agents bill container compute per hour, and the sandbox lives until the idle timeout. Each session runs in its own VM-isolated sandbox, and files and session state persist across scale-to-zero events, per Microsoft's hosted agents launch post, which also says the feature is in public preview. The idle timeout runs from 120 to 14,400 seconds and defaults to 900, per Microsoft Learn. Microsoft's pricing page says billing is based on "underlying container compute consumed per hour" and does not say whether provisioned idle time counts. We priced it as provisioned time. If Microsoft confirms it meters only active CPU, the hosted column drops sharply. Get that answer from your account team in writing before you size anything.
The crossover between AWS and Google is the shape of the task. Take a 10-minute background research job at 1 vCPU and 2 GB with 30 seconds of real CPU. On AgentCore v2 it costs about $0.0078 (30 CPU-seconds plus 720 seconds of held memory). On Google it costs about $0.0172, because all 600 seconds bill allocated vCPU. AgentCore is about 2.2 times cheaper for long agents that wait; Google is about 1.6 times cheaper for chat with think time. Google's container_concurrency setting lets one instance serve several requests at once, which can narrow that gap further for async agents.
Memory, Sessions and Search: The Line That Outgrows Runtime
Agent memory is the managed store for conversation events (short-term) and extracted facts about a user (long-term). For a Foundry prompt agent it is the entire bill, and on AgentCore it is 40% of the total.
On AgentCore Memory, short-term ingestion moved on October 6, 2026 from $0.25 per 1,000 events to $1.00 per GB ingested, with retrieval at $0.20 per GB and storage at $0.10 per GB-month. Every event bills at a 12 KB minimum. Long-term storage is $0.75 per 1,000 records a month for built-in strategies, $0.25 for self-managed ones (you pay the model calls yourself), and retrieval is $0.50 per 1,000, all per the AgentCore pricing page. Our workload costs $28.80 for ingestion, $23.04 for retrieval (32 event reads per session at the 12 KB floor), $2.88 for storage on a 30-day TTL, $375 long-term storage and $150 long-term retrieval, for $579.72. The 500,000 stored records cost more than everything else in the memory line combined.
Google moved Sessions and Memory Bank off per-event and per-memory SKUs onto its unified meters, with reads and writes billed as compute from September 1, 2026. Storage bills at Agent Storage rates, $0.30 per GiB-month, and API calls bill as Agent Compute: 1 vCPU-hour ($0.085) per 3 million reads and per 1 million writes, per Google's pricing page. Our workload comes to $8.53 for Sessions (2.4 million writes, 9.6 million reads, about 27 GiB stored) and about $0.34 for Memory Bank (600,000 writes, 300,000 reads, roughly 1 GB of memories at 2 KB each). The catch is that Memory Bank uses Gemini models to generate memories and embeddings, and those tokens bill under their own model SKUs. AWS's $0.75 built-in rate bundles that extraction; Google's meter leaves it out. We covered how Google's revision storage adds up in our Memory Bank billing piece.
For Foundry, Microsoft's retail price list shows $0.25 per 1,000 short-term memory events stored, $0.25 per 1,000 long-term memories a month and $0.50 per 1,000 retrievals. Per-event pricing hits a chatty agent hard: 2.4 million events is $600 of the $875 memory line. File search vector storage is a separate meter at $0.11 per GB per day regional, with 1 GB free.
If memory is your biggest line, the cheaper move is often to keep it in a database you already run. We made that case in Zep vs Mem0 vs Postgres.
Tools, Gateways and Identity Sit Outside the Runtime Meter
Tool calls are billed by separate meters that never show up in a runtime comparison, and one grounded web search per session can cost more than all the compute.
AgentCore Gateway charges $0.005 per 1,000 invocations (ListTools, InvokeTool, Ping), $0.025 per 1,000 searches and $0.02 per 100 tools indexed per month. AgentCore Identity charges $0.010 per 1,000 token or API key requests for non-AWS resources, and nothing when called through Runtime or Gateway. AgentCore Policy adds $0.000025 per authorization request. All three are on the AgentCore pricing page. Our 6 calls per session cost $9.00 a month.
Google's Agent Gateway bills as Agent Compute, at 1 vCPU-hour for every 15,000 API calls or authorization requests, starting July 13, 2026, per the pricing page. That is $10.20 for our 1.8 million calls. Google's page does not list a separate identity meter.
Foundry lists no gateway meter. Code Interpreter is $0.033 per regional session. Grounding with Bing Search is $14 per 1,000 transactions. One grounded search per session in our workload is $4,200 a month, more than any platform's total in the table at the top. If your agent searches the web, price that line first, and compare it against a standalone search API like the ones in our Tavily vs Exa vs Brave comparison.
A Worked Monthly Bill for One Agent on All Three
The worked bill uses the workload stated at the top: 300,000 sessions, each 150 seconds long (four 15-second turns plus three 30-second gaps), at 1 vCPU and 2 GB.
On AgentCore Runtime v2, 8 active CPU seconds per session is 666.7 vCPU-hours, or $85.07. Memory held for 270 seconds at 2 GB is 45,000 GB-hours, or $760.50. Add $579.72 of memory and $9.00 of gateway calls for a total of $1,434.29. Switching long-term memory to a self-managed strategy cuts $250 but moves extraction tokens onto your model bill.
On Google Agent Runtime, 60 billed seconds per session is 5,000 vCPU-hours ($425) and 10,000 GiB-hours ($90). The monthly free tier takes off $5.15, leaving $509.85. Sessions and Memory Bank add $8.87 plus Gemini tokens for memory generation, and the gateway adds $10.20, for $528.92 plus memory tokens. This assumes one request per instance; a higher container_concurrency lowers it.
A Foundry prompt agent pays $0 for runtime, since Foundry-native agents running prompts and workflows have "no additional charge", per the pricing page. Memory is $875, and that is the total. It is the cheapest option that bundles extraction, if your logic fits Foundry's declarative model.
A Foundry hosted agent at the minimum 120-second idle timeout holds a sandbox for 270 seconds per session: 22,500 vCPU-hours ($2,236.50) and 45,000 memory-hours ($531). With $875 of memory the total is $3,642.50. Leave the timeout at its 900-second default and each session holds 1,050 seconds, which makes runtime $10,762.50 and the total $11,637.50.
Two billing rules explain most of the spread between columns: memory priced per event or per stored record, and idle time that you control through a timeout setting.
Free Tiers, Credits and When Containers Are Cheaper
None of the free tiers changes a production decision. Google gives each billing account 50 vCPU-hours, 100 GiB-hours and 1 GiB of storage a month for agent runtimes, plus the standard $300 90-day trial credit for new users, per its Agent Platform product page. AWS offers new customers up to $200 in Free Tier credits and no runtime-specific allowance on the AgentCore pricing page. Microsoft gives 1 GB of file search storage a day free.
Self-hosting on containers wins on compute once traffic is steady, because one async container shares its memory across dozens of concurrent sessions while a managed per-session microVM bills memory per session. Two always-on Fargate tasks at 1 vCPU and 2 GB cost about $72 a month in US East at AWS Fargate's per-second rates (about $0.0405 per vCPU-hour and $0.0044 per GB-hour on x86). Our AgentCore runtime line works out to about $0.0028 per session, so compute alone breaks even at roughly 25,600 sessions a month.
The price of self-hosting is everything the runtime meter was bundling: per-session isolation, session lifecycle, a memory store, identity brokering and observability. If your agent runs untrusted code or holds user credentials, per-session isolation is a security property and worth paying for. Our agent sandbox comparison prices that layer on its own. If your agent is a stateless tool-calling loop behind your own auth, a container service plus Postgres is cheaper from the first month.
Who Should Not Pick Each Platform
Skip AgentCore Runtime for chat agents where users take a long time to reply. You pay for memory through every gap shorter than the 120-second reclaim window. Also check the lifecycle settings: the idle session timeout defaults to 900 seconds and the maximum lifetime to 8 hours, per the AgentCore API reference.
Skip Google Agent Runtime for long jobs that sit on a model call for minutes, since allocated vCPU bills the whole time. It also makes a poor fit if you want memory extraction priced as one bundled line, because the Gemini tokens arrive on a separate SKU.
Skip Foundry prompt agents if your agent is a LangGraph or custom framework app. The zero platform fee only applies to Foundry-native prompt and workflow agents. Code you bring runs as a hosted agent.
Skip Foundry hosted agents today for high-volume, short sessions. The feature is in preview, each session gets its own sandbox, and the default 15-minute timeout is the most expensive setting on any platform here unless Microsoft confirms active-only metering.
For this workload Foundry hosted agents lose. Google has the cheapest runtime meter, Foundry's prompt agent has the cheapest bundled price, and AgentCore is the right default for long-running agents on AWS.
How to Decide
Three facts about your agent predict whether you regret the choice. Measure them on your traffic before you sign anything.
- Wait ratio inside a turn. If the agent spends minutes waiting on a model, AgentCore's active-CPU billing wins. If turns are short, Google's per-turn billing wins.
- Think time between turns. Long gaps favour Google, which bills nothing between turns. On AgentCore, gaps under 120 seconds bill memory. On Foundry hosted agents, gaps under the idle timeout probably bill everything.
- Memory and tool volume. Count events written, records stored and grounded searches per session. If that line is larger than runtime, pick the platform with the cheaper memory meter, or move memory to a database you already run.
What changes the answer: a cloud commit you need to draw down. If you have an AWS EDP or an Azure MACC, the rate differences above are smaller than the discount, as we found in Bedrock vs Vertex AI vs Foundry. The model platform you have already chosen, among Amazon Bedrock, Google Vertex AI and Microsoft Foundry, usually decides the host too.
This Week: Pull one day of traces for your agent and compute three numbers: active CPU seconds per turn, wall-clock seconds per turn, and median gap between turns.
This Month: Price your workload on all three meters with the rates above, including memory events and search calls. If you are on Foundry hosted agents, set idle_timeout_seconds to 120 and ask Microsoft in writing whether provisioned idle time is metered.
Before You Sign a Commit: Run one week of real traffic on your first-choice platform and reconcile the invoice against your estimate line by line, starting with memory GB-hours and long-term records.
The Bottom Line
Managed agent hosting follows the pattern early serverless functions set: a cheap headline rate, with the bill set by how long you hold resources and how many side services you call. The highest vCPU-hour rate here is about 50% above the lowest, yet the runtime lines in our worked bill run from $0 to $10,762.50 for the same agent. Tag every agent's runtime, memory and tool meters separately from day one, as we recommended in our AI FinOps tooling guide, so the line that grows is visible before the invoice shows it.
Measure your agent's wait ratio and think time before you compare rates.
Continue Reading
- Bedrock vs Vertex AI vs Foundry: Your Cloud Commit Decides
- Agent Orchestration Platforms: Score Exit, Not Features
- E2B vs Modal vs Daytona: Idle Time Sets Sandbox Bills
- Zep vs Mem0 vs Postgres: Buy the Memory Store Last
- Pick Your Agent Engine by Its Limits, Not Its Meter
- Agent Authorization: Standing Privilege Is the Whole Problem