CloudZero MCP server: 17 tools, 3,000 calls a day
A cost connector that publishes its own quota, caps how much each tool may return, and treats OAuth and API keys differently.
Checked 6 October 2026 · from CloudZero's own MCP Server Reference documentation
One of 91 guides to monitoring and developer tools. Each covers what an AI coding agent can get out of the tool through MCP, the protocol that lets the agent query the tool directly.
Summary
CloudZero runs a hosted MCP server for its cloud cost platform. Its reference documents 17 tools across nine areas: allocations, context, CostFormation, Kubernetes, optimization, query, reference, resource and telemetry.
CloudZero is one of only three connectors here that publish a call limit, alongside Cypress and Honeycomb. It is the only one that publishes a daily quota. Each organization gets 3,000 API-key tool calls per UTC calendar day, and the count resets at midnight. OAuth users are not metered.
Result size is bounded too. Query-style tools enforce a maximum on the limit parameter, and requests above the cap are rejected before the tool runs.
What is the CloudZero MCP server?
It is CloudZero's server for the Model Context Protocol. CloudZero allocates cloud spend to teams, products and features, so a connected agent reaches cost as the business sees it rather than as the provider bills it.
The important tool is get_cost_data, with get_available_dimensions and get_dimension_values to find what can be grouped or filtered. get_org_context returns the organization context, the guidance every agent reads at the start of a cost session.
CostFormation is CloudZero's allocation configuration, and two tools read it: get_costformation_vers and download_costformation. That is how an agent can see why spend was attributed the way it was.
get_container_usage compares Kubernetes CPU and memory use with what workloads request. It covers only clusters running the CloudZero Agent for Kubernetes, and it returns no cost.
CloudZero gives an agent cost allocations, CostFormation data, optimization queries and resource telemetry, subject to its published daily quota. It is a cloud-finance connection, not a source of code, pipeline or model-trace evidence.
| Part of the work | What CloudZero has here | Can an agent reach it |
|---|---|---|
| Code, tests & review | None | Nothing for code or review |
| CI & release | None | No pipeline or deployment tools |
| Production observability | Resource metadata, and telemetry streams, meaning the business metrics CloudZero costs against | Partial. get_resource_metadata, the telemetry tools and get_container_usage cover resources, costing metrics and Kubernetes usage against requests. There are no traces or logs |
| Agent observability & evals | None | No traces or evaluations for your own agents |
| AI cost management | Cost allocation, optimization recommendations, realized savings | Partial. Cloud spend is the core strength. Token spend appears only where it is billed as a line item |
For an agent, that means CloudZero answers who spent what and why it was attributed that way. The CostFormation tools are the part a provider console cannot give you. It says nothing about how a service behaves, so a telemetry connector belongs beside it.
What can an AI agent do with CloudZero?
| Task | Tools | Works | Watch out for |
|---|---|---|---|
| Ask what something cost | get_cost_data get_org_context | Yes | The organization context sets rules that every cost analysis follows |
| Find out what can be grouped | get_available_dimensions get_dimension_values | Yes | get_available_dimensions caps its limit at 1,000 |
| Understand an allocation | get_costformation_vers download_costformation | Yes | This is the configuration that decides attribution, not the numbers |
| Find savings | get_optimize_recs get_realized_savings | Yes | Recommendations are suggestions; realized savings are recorded outcomes |
| Identify a resource behind a cost | get_resource_metadata | Yes | Metadata about the resource, not its runtime behavior |
| Rightsize Kubernetes workloads | get_container_usage | Yes | Covers only clusters running the CloudZero Agent, and returns no cost |
| Check custom telemetry | get_telemetry_streams get_telemetry_data | Yes | Telemetry here means the business metrics CloudZero costs against |
| See what has been asked already | get_recent_query_history get_reference_info | Yes | Query history is a useful way to reuse a working shape |
get_org_context returns the Custom Instructions and Generated Context that every agent reads first. get_org_context_versions lists earlier versions, which CloudZero keeps for 30 days.
17 tools documented across nine areas
- Allocations2
get_available_dimensionsget_dimension_values- Context4Write
get_org_contextget_org_context_versionsset_generated_contextset_org_context- CostFormation2
get_costformation_versdownload_costformation- Kubernetes1
get_container_usage- Optimization2
get_optimize_recsget_realized_savings- Query2
get_cost_dataget_recent_query_history- Reference1
get_reference_info- Resource1
get_resource_metadata- Telemetry2
get_telemetry_streamsget_telemetry_data
Groups are CloudZero's own section headings. Counts come from its MCP Server Reference, read 6 October 2026; the hosted endpoint returns 401 to an unauthenticated tools/list.
What the tool definitions cost in context
A client that loads every tool definition at the start of a session spends this much context before the first question. Claude Code defers definitions by default through tool search, and loads a tool's definition when the agent needs it. The method below gives the version and date measured.
A context window is the amount of text a model can hold at once. The 15 tools documented on 24 August 2026 measured 1,460 to 1,642 tokens on Claude. That is one of the smaller surfaces measured here for a cost platform.
The reference listed 17 tools on 6 October 2026, so a full load now costs slightly more than the figures below.
Ten of the 17 tools sit behind a named permission set. The context you pay for and the data you get back are therefore two separate questions.
| Tool set | Tools | Tokens (GPT-5.6, GPT-5.5) | Tokens (GPT-4, GPT-3.5) | Tokens (Claude Haiku 4.5 to Opus 5) | Share of a 200,000-token window |
|---|---|---|---|---|---|
| Every tool documented on 24 August 2026 | 15 | 530 to 666 | 538 to 674 | 1,460 to 1,642 | 0.3% to 0.8% |
Encodings: GPT-5.6, GPT-5.5 o200k_base; GPT-4, GPT-3.5 cl100k_base; Claude Haiku 4.5 to Opus 5 count_tokens. Counted from the 15 tool entries in the vendor's own documentation on 24 August 2026. That documentation is the only public inventory.
The server could not be run for a live tools/list. No input schemas are available, so these figures cover each tool's name and description only. They are a floor, not the figure.
The Claude columns are measured through the API's count_tokens endpoint with an empty schema per tool. So they cover the same content as the GPT columns. The range there is two tokenizer generations. Haiku 4.5 and Opus 4.6 are at the low end. Opus 5 and Sonnet 5 are at the high end. The gap between them is about a tenth.
CloudZero MCP server limits: where answers come back incomplete
The limits below are documented ones, which is unusual enough to be the reason to read them.
The agent says: “CloudZero stopped responding.” The daily quota may be spent.
Each organization gets 3,000 API-key tool calls per UTC calendar day, and the quota resets at midnight UTC. The server appends a warning to responses as the limit approaches.
An agent that loops over dimensions can consume a meaningful share of that in one session.
Guard: Use OAuth where the client supports it, since OAuth users are not metered, and have the agent report quota warnings rather than discarding them.
The agent says: “These are all the dimensions.” The limit is capped per tool.
Query-style tools enforce a maximum value for limit, and requests exceeding the cap are rejected before the tool runs. get_available_dimensions caps at 1,000.
Guard: Require the agent to say whether a list was capped before it describes it as complete.
The agent says: “That team spent this much.” That is an allocation, not an invoice.
CloudZero attributes spend using CostFormation, which the get_costformation_vers and download_costformation tools expose. The attribution is a configuration decision.
Guard: Have the agent name the CostFormation version behind a figure when the number is contested.
How to configure CloudZero MCP for agents
- 1
Prefer OAuth if you will use it heavily
API-key calls are metered at 3,000 per UTC day per organization; OAuth users are not metered.
- 2
Expect caps on result size
Query-style tools enforce a maximum
limit, and a request above the cap is rejected before the tool runs. - 3
Decide who writes the organization context
set_org_contextreplaces the Custom Instructions that every agent follows. It needs the Organization Administration permission set. - 4
Check the permission sets
CloudZero documents data access controls and permission sets that decide what the connection can see. API-key connections bypass both.
Paste this into your agent’s instructions
Cost figures depend on an allocation configuration the reader never sees, and results are capped. Both belong in the answer.
When you answer using CloudZero MCP tools, state: - The organization context and the period the numbers cover. - Whether the result was capped by a limit, and whether a quota warning was appended to the response. - Whether a figure is allocated cost, an optimization recommendation, or a realized saving. These are different tools. Never state that data does not exist. State that no cost data matched the context and filters above. Write your answer in ASD-STE100 Simplified Technical English. Use short sentences with one idea in each.
Do you need the MCP server at all?
Yes, for the attribution question. For a scheduled export, the CloudZero API costs no context and brings no quota surprises.
The connector earns its place on the allocation question. Asking why spend landed on a team, and reading the CostFormation that decided it, is awkward anywhere else.
For provider-native billing rather than allocation, AWS Cost Explorer answers what the invoice says, and Vantage covers spend across providers.
Connect it to ask why spend was attributed a certain way. Use the API for scheduled reporting.
CloudZero MCP server setup
The server is hosted, so nothing is installed. CloudZero documents both OAuth and API-key authentication, and they are metered differently.
A Claude Code plugin marketplace entry ships the server pre-configured, which is the shortest route for that client.
Claude Code
No credentials appear here with OAuth: the client opens a browser to authorize, and OAuth use is not metered.
claude mcp add --transport http cloudzero \ https://czca-server.discovery.cloudzero.com/mcp
Cursor
In ~/.cursor/mcp.json. Authorization runs in the browser; nothing is stored in the file.
{"mcpServers":{"cloudzero":{
"url":"https://czca-server.discovery.cloudzero.com/mcp"}}}Codex CLI
Codex reads TOML, so the JSON blocks above will not transfer. OAuth still runs in a browser.
[mcp_servers.cloudzero] url = "https://czca-server.discovery.cloudzero.com/mcp"
Every other client
Each block below is the configuration for one client, with the file path and the key that client expects.
Claude Desktop
macOS ~/Library/Application Support/Claude/claude_desktop_config.json. Windows %APPDATA%\Claude\claude_desktop_config.json. There is no CLI. Edit through Settings, Developer, Edit Config.
Quit and restart fully for changes to load. Paths in args must be absolute. Logs at ~/Library/Logs/Claude/mcp.log.
No credentials appear in the file. The client opens a browser to authorize with OAuth, and OAuth use is not metered.
{"mcpServers":{"cloudzero":{"url":"https://czca-server.discovery.cloudzero.com/mcp"}}}Gemini CLI
~/.gemini/settings.json globally, or .gemini/settings.json per project. Key mcpServers. CLI: gemini mcp add.
No credentials appear in the file. The client opens a browser to authorize with OAuth, and OAuth use is not metered.
{"mcpServers":{"cloudzero":{"url":"https://czca-server.discovery.cloudzero.com/mcp"}}}VS Code Copilot
.vscode/mcp.json per workspace, or your user profile. CLI: code --add-mcp.
No credentials appear in the file. The client opens a browser to authorize with OAuth, and OAuth use is not metered.
{"servers":{"cloudzero":{"url":"https://czca-server.discovery.cloudzero.com/mcp"}}}`.vscode/mcp.json` uses the key `servers`. VS Code's portable files, .mcp.json at the project root and ~/.copilot/mcp-config.json, use mcpServers. VS Code recommends them for new servers.
Windsurf
~/.codeium/windsurf/mcp_config.json, which is the path Windsurf documents. Key mcpServers, the same JSON shape as Cursor, carrying the same credential.
Zed
~/.config/zed/settings.json, carrying the same credential as the blocks above.
The key is `context_servers`. Zed does not call them MCP servers in config, so searching its settings for mcp finds nothing.
Google Antigravity
~/.gemini/config/mcp_config.json globally, or .agents/mcp_config.json per project. Key mcpServers. There is no CLI. Use the /mcp overlay in the editor. Supports stdio, streamable HTTP, SSE and websocket.
No credentials appear in the file. The client opens a browser to authorize with OAuth, and OAuth use is not metered.
{"mcpServers":{"cloudzero":{"url":"https://czca-server.discovery.cloudzero.com/mcp"}}}Amp (Sourcegraph)
~/.config/amp/settings.json or .amp/settings.json, carrying the same credential. The amp mcp CLI covers approve, doctor and oauth.
The key is `amp.mcpServers`, namespaced. A bare mcpServers block is ignored.
Cline
~/.cline/mcp.json per the docs. The source also reads ~/.cline/data/settings/cline_mcp_settings.json. Key mcpServers, standard JSON shape, carrying the same credential. Supports stdio, streamable HTTP and SSE.
Goose (Block)
~/.config/goose/config.yaml, carrying the same credential.
YAML, and servers are called `extensions`. Goose does not use the MCP vocabulary in config at all. Add one interactively with goose configure, or per session with goose session --with-extension.
Kiro (AWS)
.kiro/settings/mcp.json per workspace, or ~/.kiro/settings/mcp.json globally. Key mcpServers, standard JSON shape, carrying the same credential.
Warp
~/.warp/.mcp.json or .warp/.mcp.json. Key mcpServers, standard shape, carrying the same credential. Also addable through the /agent-add-mcp skill.
JetBrains Junie
.junie/mcp/mcp.json per project, or ~/.junie/mcp/mcp.json. Key mcpServers, carrying the same credential. Use /mcp in the CLI to manage.
Roo Code
.roo/mcp.json per project. The global file is mcp_settings.json, opened from the Roo Code MCP settings view with Edit Global MCP. Key mcpServers, carrying the same credential.
Continue
.continue/mcpServers/*.yaml, one file per server, carrying the same credential.
YAML, and `mcpServers` is a list, not an object. Every JSON client keys servers by name. Continue takes an array, so a converted config will not parse.
Trae
.trae/mcp.json per project, or paste into the UI under Raw Config (JSON). Key mcpServers, standard shape, carrying the same credential.
Devin
Devin has no config file to edit. Servers are added through a web form in the settings UI, and Devin's documentation states you do not need to write or paste JSON. The block below is the shape those fields describe, shown for reference. Either route uses the same credential.
API key, and the quota that comes with it
Key-based calls count against 3,000 per UTC day for the organization. The key travels in an X-Api-Key header and reaches every tool and all cost data.
{"mcpServers":{"cloudzero":{
"url":"https://czca-server.discovery.cloudzero.com/mcp",
"headers":{"X-Api-Key":"<your-api-key>"}}}}Read-only access, permissions and security
Almost everything reads
Of the 17 documented tools, only
set_org_contextandset_generated_contextchange anything. They replace the organization-wide guidance that every agent reads.Permission sets gate the data
CloudZero documents data access controls and permission sets separately from the tool list. API keys bypass both and reach all cost data.
Quota exhaustion is visible
As an organization approaches the daily limit the server appends a warning to responses, so it degrades loudly rather than silently.
Response size is bounded
A documented response size limit and per-tool
limitcaps stop a single call returning an unbounded result.
Troubleshooting
- Calls stop working partway through a day
- API-key calls are capped at 3,000 per UTC calendar day per organization, resetting at midnight UTC. OAuth users are not metered.
- A request is rejected before the tool runs
- Query-style tools cap the
limitparameter.get_available_dimensionsallows up to 1,000, and requests above a tool's cap are refused. - The agent ignores a cost rule your team uses
- Agents follow the organization context. Read it with
get_org_context, and save lasting rules as Custom Instructions withset_org_context. Running/initreplaces only the Generated Context. - The numbers disagree with the provider console
- CloudZero allocates spend using CostFormation. Read
download_costformationto see the configuration that produced the attribution.
CloudZero MCP server: Reference
| Item | Value |
|---|---|
| Endpoint | czca-server.discovery.cloudzero.com/mcp |
| Auth | OAuth, or an API key in an X-Api-Key header |
| Tools | 17 documented across nine areas |
| Quota | 3,000 API-key tool calls per UTC day, per organization |
| OAuth metering | Not metered |
| Limit cap example | get_available_dimensions, maximum limit 1,000 |
| Distribution | Also shipped pre-configured in a Claude Code plugin marketplace entry |
| Inventory source | CloudZero's MCP Server Reference, read 6 October 2026 |
What engineers report
CloudZero publishes operational limits most vendors leave unstated, so the figures below are its own.
| What was checked | What it shows |
|---|---|
| Documented tools | 17 |
| Documented areas | 9 |
| Daily API-key quota | 3,000 tool calls per organization |
| Quota reset | Midnight UTC |
| OAuth metering | None |
| Highest documented limit cap | 5,000, on get_cost_data and get_telemetry_data |
Tool inventory, quotas and limit caps read from CloudZero's own MCP Server Reference on 6 October 2026. An unauthenticated tools/list against the endpoint returned 401 on the same date, so the figures come from documentation rather than from the server itself.
Should you connect an agent to CloudZero?
Yes. Best for OAuth from an interactive client, with get_org_context read at the start of every session.
- Strongest fit
- CloudZero customers who want an agent to explain attribution rather than restate a provider invoice.
- Main advantage
- Published quotas, permission sets and per-tool caps, which makes capacity planning possible before you connect.
- Main weakness
- API-key use is metered at 3,000 calls a day, which an exploratory agent can consume quickly.
- Operational risk
- Low. Almost every tool reads. The two writes replace the organization context that every agent follows.
From Oodle
One platform for agent traces and infrastructure
Agent traces usually sit in a different product from the rest of your telemetry, so when a slow database makes an agent slow the symptom is in one tool and the cause is in another. Oodle keeps both in one query surface.
See agent observabilityFrequently asked questions
How many tools does the CloudZero MCP server have?
17 documented across nine areas, read from CloudZero's MCP Server Reference on 6 October 2026, because the hosted endpoint returns 401 without credentials.
Is there a call limit?
Yes. 3,000 API-key tool calls per UTC calendar day per organization, resetting at midnight UTC. OAuth users are not metered.
What happens as the quota runs out?
The server appends a warning to responses as the organization approaches the daily limit, so it is visible before calls start failing.
Why do the numbers differ from my cloud bill?
CloudZero allocates spend using CostFormation. download_costformation returns the configuration that decided the attribution.
Can an agent change anything?
Only the organization context. set_org_context and set_generated_context replace the guidance every agent reads. The other documented tools read cost, telemetry, Kubernetes, resource and optimization data.