The shape of the meter
Lesson 4 of 5 in The Cloud Agent Landscape: Three Managed Platforms, One Map.
This lesson contains no prices, on purpose. Rates change, differ by region, and are the first thing to go stale in any course; quoting them would make this module wrong within a quarter. What does not change nearly as fast is the shape of the meter — which dimensions you are billed on — and that is what actually drives architecture.
The shape is what tells you that a chatty retry loop costs compute, that a five-hour session costs money while it sits idle, that registering three hundred tools in a gateway is not free, and that turning evaluation sampling to 100% has a bill attached. Learn the dimensions; look up the numbers on the vendor’s pricing page the day you build the estimate.
| What you are billed for | AWS — Bedrock AgentCore | Microsoft — Foundry Agent Service | Google — Agent Platform |
|---|---|---|---|
Compute while the agent runs | Consumption-based per capability: Runtime bills actual CPU consumed and peak memory, per second, from micro-VM start to termination. Browser and Code Interpreter meter active CPU and memory per session. Runtime Instances add managed-compute charges on top of the underlying EC2 cost. (Developer Guide — cost controls) | Prompt agents: per-call inference plus tool usage, no compute of yours to bill. Hosted agents: the same plus container compute, which Foundry scales per session and request volume. (Learn — Compare agent types) | A unified structure over three resource SKUs — Agent Compute (per vCPU-hour), Agent Memory (per GiB-hour of RAM), Agent Storage — with Runtime and sandboxes billed on allocated vCPU and RAM, rounded to the nearest second. A monthly free tier exists. (Agent Platform pricing) |
Idle time inside a live session | The trap worth knowing: no CPU charge while the agent waits on model or tool I/O if nothing is consuming CPU, but memory stays billable for the whole session. A session held open for hours is not free. (Developer Guide — cost controls) | Hosted agents scale to zero at the idle timeout you set (2–60 minutes) and resume statefully — so the idle-timeout setting is directly a cost dial, traded against resume latency. (Learn — hosted agents) | Documented explicitly: for Runtime, idle time spent waiting for the next prompt between turns is not billed. Sandbox environments bill on allocated resources while they exist. (Agent Platform pricing) |
Memory and session state | Metered on three things: short-term events written, long-term records stored, and long-term retrieval requests. So the cost of memory scales with conversational volume and with how eagerly you retrieve. (Developer Guide — cost controls) | Conversations and the state store are platform-managed on Basic setup; on Standard setup you bring your own Azure Storage, AI Search, and Cosmos DB, and pay for them directly — Cosmos needs at least 3000 RU/s total throughput because Foundry provisions three containers at 1000 RU/s each. (Learn — Use your own resources) | Sessions and Memory Bank bill as storage plus read and write operations, with request counts converted into Agent Compute units; the model tokens spent generating memories are billed under the model’s own SKU. (Agent Platform pricing) |
Tool gateway usage | Gateway meters API operations, search queries, and indexed tools — note that third dimension: a gateway holding hundreds of tool definitions is itself a metered asset, independent of how often the tools are called. (Developer Guide — cost controls) | Tool usage is billed alongside inference for both agent types; connectors and managed MCP servers in the Tools Catalog are provisioned in your Foundry account. Check the pricing page for how each platform tool meters. (Learn — Compare agent types; Connectors) | Agent Gateway converts API calls and authorisation requests processed during agent execution into Agent Compute units at a published ratio — a per-call meter wearing a vCPU-hour costume. (Agent Platform pricing) |
Guardrails, policy, and evaluation | Bedrock Guardrails bill on their own dimensions; Evaluations costs scale with what you turn on — online evaluation samples live traffic at a rate you configure, and each evaluator that runs is work performed. Sampling rate is a cost dial. (AWS ML Blog — Evaluations) | Guardrail controls and evaluators run as platform work on top of inference; content-safety classification and evaluator models are the underlying consumption. Verify current metering per feature. (Learn — Guardrails overview; Observability) | Semantic Governance Policies bill as Agent Compute per batch of agent-model response evaluations plus the evaluation model’s tokens — the honest cost of a guardrail that is itself model-evaluated. (Agent Platform pricing) |
The adjacent bills people forget | Model inference (billed by the model provider) and CloudWatch ingestion, storage, and query for observability. There is no separate charge for the managed harness orchestration itself. (Developer Guide — cost controls) | Model inference, Application Insights ingestion and retention for traces, plus whatever your BYO stores cost. Publishing to Teams or M365 Copilot brings its own licensing questions. (Learn — tracing; environment setup) | Model inference and embedding SKUs, storage for the Skill Registry and retrieval indexes, and any savings-plan commitment you have signed. (Agent Platform pricing) |
Notice how differently the three vendors express the same underlying costs. AWS meters each capability on its own dimensions and tells you plainly that memory stays billable while a session idles. Microsoft collapses the story into two agent shapes — inference plus tools, or inference plus tools plus container — and pushes the durable-store bill onto resources you own. Google normalises everything, including request counts, into three resource SKUs so that gateway calls and memory operations arrive as compute units.
None of these is cheaper in the abstract. They are cheaper or dearer for a workload, and the workload variables that dominate are the same three everywhere: how many model tokens per task, how long a session stays open, and how much telemetry you keep. Model those three and you can estimate on any of the platforms; model none of them and no pricing page will save you.
Interactive sorting exercise: Each of these is a real design decision. Which meter does it move first? (Several move more than one — pick the dimension it moves most.)
Interactive checkpoint quiz (2 questions) — open this page in a browser to take it.