.png){kind=logo}
The Model Context Protocol (MCP) has become the standard interface between AI agents and external systems. Developers are wiring LLMs into everything- task managers, databases, observability platforms, and now cloud cost tools.
That last category is getting crowded fast.
Several announcements this week have made a version of the same claim: connect your AI agent to our platform, and it will understand your cloud costs. In theory, that's true. LLMs don't struggle with reasoning. But there are things LLMs are simply not equipped to do reliably. Turning raw billing data into accurate, meaningful, easily understandable cloud cost intelligence is something LLMs weren’t built to do.
And most MCP integrations do exactly that anyway — expose raw billing data and expect the model to sort it out. The agent ends up reconstructing cost allocation, normalization, and context from scratch. Without pre-computed, structured data, it fills in the gaps wrong.
That means the framing is correct. The implementation is where it gets interesting.
PointFive's MCP is different. It doesn't give agents raw data to analyze. It gives them answers.
There are two ways to build and implement a cost intelligence MCP.
The first: expose your raw data retrieval API and write detailed prompt templates, like scripted recipes, that tell the LLM how to analyze what it receives. The agent queries raw billing exports, then executes the analysis in its own context- computing means, standard deviations, z-scores, and growth rates on the fly. This approach keeps the platform thin and puts the intelligence burden on the model while also constraining it to what the recipe anticipated.
The second: embed the intelligence in the platform, and expose the results through the MCP. Anomalies are detected continuously by the system, not computed ad hoc by the agent. Opportunities are pre-scored for savings, risk, and effort. Commitment recommendations come with hourly breakdowns and payment option comparisons already calculated. The agent queries outcomes, not raw inputs — and because the intelligence is already in the platform, the agent is free to compose tools, follow the evidence, and adapt based on what it finds.
PointFive chose the second path not because it was easier, but because it's the only approach that produces trustworthy results at scale.
LLMs are capable reasoners. They are not reliable calculators. An agent computing z-scores across 30 days of billing data in its own context window will hallucinate. An agent querying pre-computed anomalies with severity scores and root-cause contributors will not.
How the agent operates matters too. Keeping the platform thin has another consequence beyond bad math — it makes the agent rigid.
When intelligence lives in prompt templates, the agent has no choice but to follow them. Even when the recipe seems comprehensive and includes several steps, it will still hit a ceiling. The same 11 steps, in the same order, every time limits the power of the LLM. It can't adapt based on what earlier steps return. It can't compose with other tools. It just executes the recipe. And in an environment where cloud costs can spike and shift in real time, a rigid script won’t keep up.
To truly benefit from a cloud cost MCP, you need one flexible enough to meet the question where it is. PointFive's architecture is composable by design. The agent decides which tools to call, in what order, based on what the question actually requires. An anomaly query might call list_anomalies once, then get_anomaly_contributors for a specific spike, then get_resource for the contributing service, then get_opportunities filtered by that resource. The agent follows the evidence, not a preset script. The result is an agent that can handle whatever your cloud environment throws at it.
This is what it looks like when the platform and the agent are actually built for each other.
PointFive's MCP exposes 34 tools organized across 11 domain groups, accessed through a three-tier meta-tool architecture: search, describe, invoke. This structure lets agents discover and compose the right capabilities dynamically, rather than reasoning over a flat list of endpoints.
Agents don't receive a flat list of 34 endpoints to reason about. Instead, three meta-tools are exposed at the top layer. The agent uses natural language to discover the right internal tool via fuzzy search, retrieves its schema and example invocations, then executes with validated parameters. Tool descriptions average 50 lines of semantic guidance- enough context to reason well, not enough to bloat the context window. The result is a large capability surface that remains discoverable and composable for the agent.
Opportunities: Four tools covering the full lifecycle of cost saving opportunities, from detection to resolution. Each opportunity carries a savings estimate, effort score of 1–3 (from quick wins to complex changes), risk score 1–3 (from safe to high impact), and service attribution. Aggregate and group views let agents summarize across provider, team, project, or detection category without raw data processing. This lets agents prioritize the highest-impact remediation work without analyzing raw billing data.
Anomalies: Three tools returning pre-detected cost anomalies with severity, cost impact, detection time, and contributing resources. The agent doesn't compute the anomaly. It queries one that the platform has already found. Agents can focus on explaining the anomaly rather than detecting it.
Commitments: Two tools delivering AWS Reserved Instance and Savings Plan recommendations with 24-entry hourly coverage breakdowns and five payment option comparisons, all pre-calculated. This means the coverage modeling and payment comparisons are computed by the platform, not the agent.
Resources: Six tools providing resource inventory, attribute detail, cost aggregations by service and region, infrastructure dependency graphs, associated opportunities, and change event history. This is infrastructure topology, not just billing dimensions.
Data Explorer: Three tools give users raw SQL access against their organization's cloud cost data in PointFive. When pre-computed results aren't enough, agents can write custom queries. This gives you complete control and visibility into your billing data — ask any question, slice the data any way you need, and get answers that are specific to your business. Something most cost MCP integrations don't offer at all.
Teams, Projects, Users, Automations, Schema: The remaining domain groups let agents understand organizational context, team hierarchy with resource allocation rules, existing automation workflows with Jira/Slack/email actions, and live GraphQL schema introspection for dynamic API discovery. This gives agents the organizational and operational context needed to interpret cost data correctly.
Like any platform, we're still building — but on the dimensions that matter most for cloud cost intelligence, the architecture speaks for itself.
A common framing in this space is "semantic layer": the idea that structured, allocated data mapped to teams, services, and business dimensions is what makes AI-driven cost analysis trustworthy.
PointFive agrees with this framing. The semantic layer is real and it matters.
The real question is where that semantic layer lives.
Prompt templates that instruct an LLM to perform multi-step analysis on raw cost data are not a semantic layer. They are a scripted workaround. They produce different results depending on context window state, model version, and how the agent interprets the instructions. They can't be composed. They burn context on procedural instructions instead of signal.
PointFive's semantic layer is the platform itself. Anomaly detection runs continuously against cloud telemetry. Opportunity scoring is computed at detection time, not derived on-demand. Commitment math is done once by a system built for it, not re-derived by a language model in each session.
When an agent calls list_anomalies, it gets authoritative results- severity, cost impact, detection time, contributing resources- not a recipe for how to calculate them.
That is what makes AI-driven analysis trustworthy.
MCP is the right interface and the industry is moving in the right direction. But a connection to structured cost data is not the same as a connection to a platform that has already done the work of understanding it.
PointFive's MCP exposes pre-computed anomalies, opportunities, commitment recommendations, resource relationships, team attribution, automation workflows, and raw SQL access through a composable, role-aware architecture built to give agents authoritative answers, not raw material to analyze.
The platform is the intelligence layer. The MCP is how agents access it.
What's on the other end of the connection is what has always separated PointFive from the field.
PointFive redefines how enterprises continuously optimize cloud, infrastructure, and AI environments. By combining a real-time cloud and infrastructure data fabric with AI-driven detection and guided remediation, PointFive transforms efficiency from a reporting exercise into an operational discipline. Customers achieve sustained improvements in cost, performance, reliability, and engineering accountability, at scale.
To learn more, book a demo.
