Cloud cost + FinOps knowledge for AI agents: AWS/Azure/GCP optimisation, AI spend, waste playbooks.
io.github.OptimNow/cloud-finops MCP Server
This MCP server provides open-source FinOps knowledge for AI agents. It supports cloud cost optimization across AWS, Azure, GCP, and OCI, including AI spend management and inference economics. The knowledge also covers Kubernetes and data platforms, allocation, chargeback, anomaly management, and waste detection playbooks with named patterns.
🛠️ Key Features
Cloud cost optimization for AWS, Azure, GCP, and OCI
AI cost management and inference economics
Kubernetes and data platform cost guidance
Allocation and chargeback concepts
Anomaly management and waste playbook patterns
🚀 Use Cases
Help AI agents answer questions about cloud governance and cloud financial management
Support agent skills for AI cost control and llm-cost optimization
Provide FinOps foundation guidance for tagging and chargeback workflows
Inform waste detection and anomaly management playbooks
⚡ Developer Benefits
Built for MCP-compatible clients and AI agent tooling
Exposes up to 6 tools (toolCount: 6) aligned to FinOps topics
Reusable across multiple model context protocol clients (e.g., Claude, ChatGPT, Gemini)
⚠️ Limitations
Only described as providing knowledge skills; no specific authentication, deployment, or API behavior is detailed.
See what FinOps guidance is available: billing mechanics, commitment
strategy, allocation and chargeback, AI cost management, and per-provider
cost handbooks (AWS, Azure, GCP, OCI, Databricks, Snowflake, ...).
Use this to discover what the library covers. When the question already
names a FinOps domain, phase, persona or maturity, ``find_references``
returns only the matching references.
Returns a dict shaped ``{"references": [...], "total": N}`` where each
entry includes ``name``, ``title``, a one-line ``description``, the
discriminating FCP facets (``fcp_domain``, ``fcp_capability``,
``fcp_phases``, ``fcp_personas_primary``, ``fcp_maturity_entry``) and
``approx_tokens``.
``approx_tokens`` gives each file's size before it is fetched: the library
runs from about 2,000 to about 15,000 tokens per file, and
``get_reference(name, section=...)`` returns one section of a large one.
Fetch the guidance on one FinOps topic - the billing mechanics,
decision rules and worked examples behind a defensible answer - either
whole or one section at a time.
Use this when you need the actual content of one known reference,
after ``list_references`` or ``find_references`` told you which one
serves the question. Advisory questions (commitment sizing, chargeback
design, allocation methodology) are served by the reference's decision
rules and worked examples, which a summary does not carry.
``section`` is useful when the question is narrower than the file. The
``approx_tokens`` hint in the listing shows when this matters: the
largest references run to about 15,000 tokens and the Azure pattern
catalogue is an enumerated list, so a question about storage lifecycle is
served by one section of ``finops-azure-patterns``. Without ``section``
the whole file comes back, with its cross-cutting reasoning.
Args:
name: Reference name as returned by ``list_references`` (e.g.
``"finops-aws"``, ``"finops-genai-capacity"``,
``"optimnow-methodology"``).
section: Optional H2 or H3 heading to return on its own. Matched
case-insensitively and partially against the headings, so a
natural phrase works - ``"storage"``, ``"commitment decision
tree"``. A heading's trailing count is ignored, so
``"storage optimization patterns"`` matches
``"Storage Optimization Patterns (28)"``. If it matches nothing
you get the list of available headings back, not the whole file.
Without ``section``, returns ``{"name": ..., "content": "...",
"lines": N}`` where ``content`` is the file verbatim. With ``section``,
returns ``{"name", "title", "section", "section_level", "partial": true,
"content", "lines", "full_lines"}`` where ``content`` is that section
prefixed by the reference's title, plus ``other_matching_sections`` when
the phrase matched more than one heading.
On a miss, returns ``{"error": ..., "suggestions": [...]}``. An unknown
name gives up to three string-distance matches; an unmatched ``section``
gives ``available_sections`` - every heading in the file - so the retry
is exact.
Find which guidance serves a FinOps question - how to commit, size,
allocate, charge back, forecast, or govern cloud and AI spend.
Use this for questions like "how should we size Savings Plans",
"what should Finance own in chargeback", "what does a Crawl-stage org
tackle first" - anything that maps to FinOps Framework facets (domain,
capability, phase, persona, maturity) - and you want only the
references that serve it, instead of scanning the full list.
All filters are optional and combine with AND semantics. String matching
is case-insensitive and exact (not substring). Examples:
- ``find_references(domain="Optimize Usage & Cost")``
- ``find_references(phase="Optimize", persona="Engineering")``
- ``find_references(persona="Engineering", persona_primary_only=True)``
- ``find_references(capability="Rate Optimization")``
- ``find_references(maturity="Crawl")``
Args:
domain: FinOps Framework domain (e.g. ``"Optimize Usage & Cost"``,
``"Quantify Business Value"``, ``"Manage the FinOps Practice"``).
capability: FinOps capability (matches ``fcp_capability`` and
``fcp_capabilities_secondary``).
phase: FinOps phase (``"Inform"``, ``"Optimize"``, ``"Operate"``).
persona: Persona (matches ``fcp_personas_primary`` and
``fcp_personas_collaborating``).
maturity: Entry maturity level (``"Crawl"``, ``"Walk"``, ``"Run"``).
persona_primary_only: when True, ``persona`` matches only the primary
list. Useful when the default match barely narrows the set -
broad personas like Engineering collaborate on nearly every file,
so filtering on collaboration is descriptive, not discriminating.
``persona="Engineering", persona_primary_only=True`` is the
engineering reading list; the default is the everything-they-touch
view.
Returns ``{"filters": {...}, "references": [...], "total": N}``. A query
that matches nothing also returns `hint` and `valid_values`, so a typo is
distinguishable from a genuine gap in coverage.
See every ready-made runbook for finding and fixing cloud waste:
idle, orphaned and overprovisioned resources, egress surprises,
schedule blindness and AI/ML inefficiency across AWS, Azure and GCP.
Use this to discover which waste patterns have a runbook. When the
question already names a provider, waste category, or confidence tier,
``find_playbooks`` returns only the matching runbooks.
Each playbook is a small (~90-170 line) runbook scoped to one waste
pattern (e.g. ``aws-zombie-nat-gateway``, ``azure-orphan-disks``). Returns
``{"playbooks": [...], "total": N}`` where each entry includes ``name``,
``title``, ``scope`` (aws/azure/gcp/cross-cloud), ``service``,
``waste_category``, ``confidence`` (obvious/likely/possible), and
``approx_tokens`` - the same size hint the reference listing carries, so a
multi-playbook answer can be budgeted before fetching.
Fetch the step-by-step runbook for one specific waste pattern:
symptoms, the detection queries to run, the fix, and the anti-pattern
to avoid.
Use this when the user asks how to detect, confirm, or fix one specific
named waste pattern (zombie NAT gateway, snapshot sprawl, idle SageMaker
endpoint, ...), including questions about the user's own resources
("which of my X..."). Each runbook includes a detection query the user
can run in their own cloud account; this connector has no access to the
user's accounts.
Args:
name: Playbook slug as returned by ``list_playbooks`` (e.g.
``"aws-zombie-nat-gateway"``, ``"azure-orphan-disks"``,
``"cross-cloud-untagged-spend-drift"``).
Returns ``{"name": ..., "title": ..., "content": "...", "lines": N}``.
On miss, returns ``{"error": ..., "suggestions": [...]}`` with up to
three string-distance matches so the caller can self-correct.
A host with MCP Apps (SEP-1865) support may render this result via the
linked ``ui://cloud-finops/playbook-viewer`` resource instead of showing
the raw markdown.
Finds runbooks for a suspected cloud-waste pattern, filterable by
provider, service, waste category or detection confidence. Useful when
the user asks how to detect or fix a specific waste pattern; each
runbook includes a detection query the user can run in their own
account. This connector has no access to the user's accounts.
Use this for questions like "which VMs are running for nothing",
"why is our NAT bill so high", "my NAT gateway processes 10TB to S3",
"should I delete these old snapshots", "which of our RIs are about to
expire", "what waste can we clean up safely without review" - anything
that names a provider, a waste category, or how confident the
detection needs to be before acting. Patterns
covered include NAT gateways and VPC endpoints, expiring Savings
Plans / RIs / reservations, snapshot sprawl, S3 lifecycle gaps, idle
or stopped VMs, orphaned disks / public IPs / EBS volumes, GPU and
SageMaker sizing, Kubernetes idle capacity, and schedule blindness.
All filters are optional and combine with AND semantics. String matching
is case-insensitive and exact. Examples:
- ``find_playbooks(scope="aws")`` - all AWS-specific playbooks
- ``find_playbooks(waste_category="idle")`` - every idle-resource pattern
- ``find_playbooks(scope="cross-cloud", confidence="obvious")``
Args:
scope: ``"aws"``, ``"azure"``, ``"gcp"``, or ``"cross-cloud"``.
service: Provider service exact-match (e.g. ``"AWS NAT Gateway"``).
waste_category: ``"orphaned"``, ``"idle"``, ``"overprovisioned"``,
``"commitment-mismatch"``, ``"schedule-blindness"``,
``"modernization"``, ``"ai-ml-inefficiency"``, or ``"egress"``.
confidence: ``"obvious"`` (single signal is enough),
``"likely"`` (two signals required), or ``"possible"``
(needs human review). From the OptimNow three-tier confidence
model in `finops-waste-detection-playbooks`.
Returns ``{"filters": {...}, "playbooks": [...], "total": N}``. A query
that matches nothing also returns `hint` and `valid_values`, so a typo is
distinguishable from a genuine gap in coverage.
Get the current value of a figure a reference quotes with a date.
Use this when a reference quotes a figure from an OptimToken guide
("measured on the 2026-10-25 OptimToken catalogue") and the answer needs
the current value: the Compute Savings Plan or reservation discount, the
gap between a flexible and a locked commitment, the ARM discount against
Intel and AMD, the share of LLM models with a batch rate. It fetches the
guide's figures file, rebuilt daily, and returns it as published.
Args:
guide: The guide slug, lowercase letters, digits and hyphens. Guides
with figures today: ``"savings-plans-vs-reserved-instances"``,
``"arm-against-x86"``, ``"batch-api-economics"``.
Returns ``{"document": {...}, "fetched_at": ..., "source": "live" |
"cached", "note": ...}``, plus ``cache_age_seconds`` when cached (six-hour
cache). ``document`` is the file unchanged: ``guide``, ``title``,
``url``, ``dataSource``, ``snapshotDate`` (the catalogue the figures come
from), ``dateModified`` and ``figures``, where discounts are fractions
(0.2743 is 27.4%) and each key names a median, a range or a count.
An unknown slug returns ``{"error", "available_guides", "suggestions"}``.
Any other failure (timeout, HTTP error, invalid JSON) returns
``{"error", "fallback"}``: the dated figure in the reference then stands,
quoted with its date.
FinOps knowledge for AI assistants: billing mechanics, commitment decisions and waste runbooks for AWS, Azure, GCP, AI and data platforms. By OptimNow.
Both are in the Claude directory. The plugin loads the FinOps library into
Claude's context; the connector serves the same library as seven MCP tools that
Claude calls when a question needs them. Using Claude, start with the plugin: with
both installed, Claude answers from the plugin and leaves the connector unused. The
connector suits other assistants and search by question. See
which to choose.
Not using Claude? The same library works in ChatGPT, Gemini, Cursor, Copilot and other
tools: see Install.
Ask your assistant how to reduce a cloud bill, size a commitment, read a term sheet
or allocate shared AI costs, and it answers from how billing works, with decision
rules and worked examples, instead of general advice. The same files work in Claude,
ChatGPT, Gemini, Cursor and any MCP-compatible tool. Open source, written by
OptimNow
from enterprise FinOps delivery, and aligned with the FinOps Foundation framework.
What you can ask, by role
Each question below is answered by a file that exists in this repository today.
FinOps lead
Question
File
Which of our Savings Plans and reservations expire in the next 90 days, and what should we decide before they do?
Neither the skill nor the connector can see your cloud account. For a question about
your own resources, the answer is a detection query you run yourself, taken from the
matching runbook. If you have connected your cloud account or your cost platform to
the same session, the skill tells the model to ask before reading it, and to run the
runbook's detection only, never its fix. That is an instruction, not a lock: a
read-only role on that connector is the guarantee
(what was measured).
What it covers
The FinOps Framework
The reference library is mapped to the 22 capabilities of the FinOps Foundation
framework, grouped in its 4 domains. A filled square means at least one reference
owns the capability; a grey square means the capability is covered inside another
file; a dashed square is a known gap, listed with its reasoning in
docs/ROADMAP.md.
This map is generated from the frontmatter of every reference file, and the CI
pipeline fails when the committed map no longer matches the files
(fcp-coverage.md).
Providers and business needs
The matrix reads the library by business need. Every cell comes from a named
reference file, listed in the notes under the tables.
Level
Meaning
● deep
A dedicated reference or section, with decision rules, worked examples or detection queries
◐ partial
Covered inside a broader file, or mechanics only
–
Not covered today
n/a
The combination does not exist
Hyperscalers
Business need
AWS
Azure
GCP
Understand and allocate the bill
●
●
●
Budget and forecast
●
●
●
Commitments and discounts
●
●
●
Contract negotiation and renewal
●
●
●
Reduce waste
●
●
●
AI and GenAI spend
●
●
●
Data platforms
◐
●
◐
SaaS and licences
◐
◐
◐
Carbon footprint
●
◐
◐
Other estates
Business need
OCI
On-prem
Understand and allocate the bill
◐
●
Budget and forecast
◐
◐
Commitments and discounts
◐
◐
Contract negotiation and renewal
–
–
Reduce waste
◐
◐
AI and GenAI spend
–
◐
Data platforms
–
–
SaaS and licences
–
◐
Carbon footprint
–
–
Platforms
Business need
AI
Data
SaaS
Understand and allocate the bill
●
●
◐
Budget and forecast
●
◐
◐
Commitments and discounts
●
●
◐
Contract negotiation and renewal
–
◐
◐
Reduce waste
●
●
●
AI and GenAI spend
●
◐
●
Data platforms
n/a
●
n/a
SaaS and licences
◐
◐
●
Carbon footprint
–
–
–
On-prem covers owned data centres and the hybrid platforms (Outposts, Azure Local,
Arc). AI covers the AI platforms: Anthropic, AWS Bedrock, Azure OpenAI, GCP Vertex AI
and the open-weight vendor APIs. Data covers Databricks, Snowflake and Microsoft
Fabric. SaaS covers SaaS applications, AI coding tools and licences.
Where each cell comes from
All paths are under plugins/cloud-finops/skills/cloud-finops/.
Understand and allocate the bill. AWS: references/finops-aws-billing.md, finops-allocation-showback.md, finops-focus.md, finops-tagging.md. Azure: finops-azure-billing.md, finops-focus.md, finops-tagging.md. GCP: finops-gcp.md (cost data foundation), finops-focus.md, finops-kubernetes.md. OCI, partial: finops-oci.md (cost reports, cost-tracking tags), finops-focus.md. On-prem: finops-on-prem-hybrid.md (internal bill, usage ingestion). AI platforms: the "Cost visibility and allocation" sections of finops-bedrock.md, finops-azure-openai.md, finops-vertexai.md, finops-anthropic.md; finops-for-ai.md. Data platforms: finops-databricks.md (system tables, allocation), finops-fabric.md (shared-capacity allocation), finops-snowflake.md (query attribution). SaaS, partial: finops-sam.md (discovery), finops-focus.md (FOCUS for SaaS vendors), finops-ai-dev-tools.md (attribution patterns).
Budget and forecast. AWS and Azure: finops-forecasting.md, finops-anomaly-management.md, and the Budgets sections of finops-aws-billing.md and finops-azure-billing.md. GCP: finops-gcp.md (budgets, spend caps), finops-anomaly-management.md. OCI, partial: finops-oci.md (Budgets). On-prem, partial: finops-on-prem-hybrid.md (rate setting); capacity planning is on the roadmap. AI platforms: finops-ai-value-management.md (AI investment budgets, stage gates), finops-forecasting.md (AI forecast scenarios), finops-anthropic.md (spend limits). Data platforms, partial: budget controls in finops-snowflake.md, finops-databricks.md, finops-fabric.md. SaaS, partial: finops-sam.md (renewal calendar, metrics), finops-ai-dev-tools.md (spending caps).
Contract negotiation and renewal. AWS, Azure, GCP: finops-cloud-contracts.md, plus finops-azure-billing.md (EA-to-MCA). Data platforms, partial: the data platform section of finops-cloud-contracts.md, finops-databricks.md, finops-snowflake.md. SaaS, partial: finops-sam.md (renewal governance), finops-itam.md (pre-renewal checkpoint, joint negotiation). OCI, on-prem and AI platforms: no file. See "Contract negotiation and renewal" below.
Reduce waste. AWS: finops-aws.md, the 5 finops-aws-patterns-*.md files, 23 runbooks. Azure: finops-azure.md, finops-azure-data.md, finops-azure-patterns.md, 10 runbooks. GCP: the pattern catalogue inside finops-gcp.md, 7 runbooks. OCI, partial: finops-oci.md (6 patterns, no runbook). On-prem, partial: finops-on-prem-hybrid.md (idle capacity line, cost score). AI platforms: finops-for-ai.md (anti-patterns), finops-genai-capacity.md (provisioned-capacity waste), the optimisation sections of the 4 AI platform files, 2 cross-cloud runbooks. Data platforms: the pattern sections of finops-databricks.md, finops-snowflake.md, finops-fabric.md. SaaS: finops-sam.md (sprawl patterns), finops-ai-dev-tools.md (optimisation levers).
AI and GenAI spend. AWS: finops-bedrock.md, finops-aws.md (SageMaker), the GPU and SageMaker runbooks. Azure: finops-azure-openai.md. GCP: finops-vertexai.md. On-prem, partial: finops-ai-self-hosted-vs-managed.md. AI platforms: finops-for-ai.md, finops-agentic.md, finops-ai-value-management.md, finops-genai-capacity.md, finops-anthropic.md, finops-open-weight-vendors.md. Data platforms, partial: Cortex in finops-snowflake.md, model serving in finops-databricks.md. SaaS: finops-ai-dev-tools.md, playbooks/cross-cloud-coding-agent-token-waste.md.
Data platforms. AWS, partial: finops-databricks.md on AWS, Redshift commitments in finops-aws-patterns-databases.md. Azure: finops-fabric.md, finops-databricks.md. GCP, partial: BigQuery in finops-gcp.md. Data platforms: finops-databricks.md, finops-snowflake.md, finops-fabric.md.
SaaS and licences. AWS, Azure, GCP, partial: marketplace channel governance in finops-itam.md, Marketplace private offers in finops-cloud-contracts.md, Azure Hybrid Benefit in finops-azure-commitments.md. On-prem, partial: VMware core licensing in finops-on-prem-hybrid.md, BYOL in finops-itam.md. AI platforms, partial: licensing in finops-open-weight-vendors.md. Data platforms, partial: Pro, PPU and F-SKU licences in finops-fabric.md. SaaS: finops-sam.md, finops-itam.md, finops-ai-dev-tools.md.
Carbon footprint. AWS: greenops-cloud-carbon.md (Sustainability Console, Well-Architected pillar). Azure and GCP, partial: the same file, with the Azure and GCP depth pass on the roadmap; finops-gcp.md (Cloud Carbon Footprint).
Contract negotiation and renewal
The reference finops-cloud-contracts.md
covers negotiated spend commitments with the 3 hyperscalers: AWS Private Pricing
(EDP and PPA), Azure MACC and the Azure Commitment Discount, and Google Cloud Minimum
Commitment. It describes the 12 clauses of an enterprise agreement, where the discount
shows in billing data, migration funding (MAP, Azure Accelerate, RaMP), Marketplace
private offers as a commitment lever, the reseller channel, 9 intake questions to ask
before advising, a 15-point review grid for a term sheet, the usual pitfalls and the
timing of a renewal. A closing section covers Databricks and Snowflake commitments
inside a cloud contract. Benchmarks come from public sources named in the file; the
library carries no observed contract figure.
Also covered: SaaS renewal governance (renewal calendar, auto-renewal review) in
finops-sam.md and
the pre-renewal checkpoint and marketplace channel governance in
finops-itam.md.
Not covered today: negotiation with AI providers (Anthropic, OpenAI and the hosted
model vendors; the library covers their reservation mechanics, not their enterprise
agreements), OCI Universal Credits beyond their mechanics, and colocation or hosting
contracts.
Waste runbooks
A runbook is a step-by-step procedure for one specific waste pattern: the symptoms, a
detection query you run in your own account, the fix in safest-first order, and the
mistake to avoid. The library files them by provider and by waste category, and each
one carries a confidence level that says whether a single signal is enough to act.
What it does not do
Live prices. The files carry billing mechanics, which stay true for years. Price
figures go stale inside a packaged skill within weeks, so they are left out. For a
current price the skill points to OptimToken,
OptimNow's free comparison of LLM token rates and compute instance rates, each
figure with its as-of date.
Your cloud account. Nothing here reads a bill or an API. For "which of my
resources" questions, the deliverable is the runbook's detection query.
Legal, tax or accounting advice. The contract and chargeback references describe
mechanics and the questions to ask; your counsel, tax adviser and auditors decide.
Topics still open. Accounting for owned capacity (depreciation, lease treatment),
AI provider and OCI contract negotiation, and the FinOps Education & Enablement
capability. Each is listed in docs/ROADMAP.md with the trigger
that would reopen it.
Guaranteed routing. The model decides which file to read. When an answer arrives
without a visible file read or tool call, ask for the library by name ("check the
playbook library"). See docs/CONCEPTS.md.
Install
Where
How
Claude.ai, Claude Desktop
From the Claude directory, one click each: the plugin (the skill) and the connector (the MCP server)
Claude Code
Plugin: /plugin marketplace add https://github.com/OptimNow/cloud-finops-skills.git then /plugin install cloud-finops@optimnow. Connector: claude mcp add --transport http cloud-finops https://mcp.optimnow.io/mcp
curl -sL https://raw.githubusercontent.com/OptimNow/cloud-finops-skills/main/install.sh | bash -s -- --tool <name> (drop -s -- --tool <name> to auto-detect the tool)
Any MCP client
Hosted: add an HTTP MCP server at https://mcp.optimnow.io/mcp, exactly that form. Local: pip install cloud-finops-mcp, config snippets from ./install.sh --tool mcp
ChatGPT, Gemini (web)
Self-host for now: ./install.sh --tool chatgpt --grouped or ./install.sh --tool gemini
Full options, troubleshooting, and the model-agnostic API loader: see
INSTALLATION.md. A version-tagged zip
(cloud-finops-vX.Y.Z.zip) is attached to every
GitHub release.
How it works
The skill is a folder of markdown files: an entry point that routes a question
to the right reference, the reference library and the runbooks. Installed in Claude,
Kiro or through the installer for other tools, the guidance sits in the model's
context before it answers. No code runs, no data leaves your machine.
The MCP connector serves the same library the other way round, as 7 read-only
tools the model calls when it decides to: list, search by FinOps capability or
waste category or by a question in your own words, fetch one reference or runbook,
and read the current figures of an OptimToken pricing guide. One click from its
Claude directory listing, or one URL to paste
(https://mcp.optimnow.io/mcp), nothing to install. Tool calls go to a server
OptimNow runs in Paris; see "Data handling" below.
The plugin in the Claude directory is the skill only. The connector is a
separate listing, so that the same content is not loaded twice in one session.
Live prices come from OptimToken, queried at
answer time, never copied into these files.
The 2 delivery shapes behave differently: a loaded skill grounds advisory and
symptom questions without a decision to make, while the connector depends on the
model choosing to call a tool. What that means in practice, with the results measured
in November 2026 (adding both behaves as the plugin alone; the connector alone depends
on the model), is in docs/CONCEPTS.md. Using a non-Claude model through an API,
add the response contract from INSTALLATION.md to your system
prompt so answers stay structured and billing-grounded.
Usage examples
One question, asked twice
The same question put to Claude Opus 5.5 on 11 November 2026, first alone, then with
the plugin installed: "Our AWS bill has NAT gateway charges but I do not think anything
uses them - what should I do?"
Claude alone gave sound advice, checked by hand in the console. With the plugin it
read the runbook first, and the answer differs in 4 places: one Athena query that
checks every gateway in one pass, 2 months of observation where Claude alone asked for
30 days, a price that carries its date and its source, and a sentence saying it cannot
see the account. Each version was run once: an example, not a measurement.
Every reference and runbook declares the questions it answers in its frontmatter
(questions:), in English and French. The role list above is generated from the ones
tagged with a persona and checked in CI. Ask in your own words: the connector's query
parameter and the skill's routing both search those lists.
Design principles
Visibility before optimisation. Establish what you spend and what drives it,
then act. The skill does not recommend commitments to a team that cannot allocate
its bill.
Provider mechanics first, vendor claims second. Guidance is grounded in how
billing works (CUR columns, Azure cost-management semantics, BigQuery export, FOCUS
conformance), with primary sources cited. Vendor savings and sustainability claims
are read critically.
Maturity is contextual. Where cloud is a cost centre, Crawl plus selective Walk
is often the right state; where cloud is the product, Run pays for itself in gross
margin. The skill assesses maturity before recommending.
Cost connects to business value. Every recommendation answers the CFO question:
which business outcome does this protect or create.
Mechanics live here, price figures do not. Any figure a reference quotes carries
its date and source; current prices route to OptimToken.
AI cost management is a first-class domain, with a reference per AI platform
and a discipline file for agents, capacity and investment governance.
Data handling
What the skill and the hosted connector run, send and fetch, so you can decide where
each is appropriate. Full policy in PRIVACY.md.
The skill is static text. The entry point, the references and the runbooks are
markdown files read into the model's context. They run no code, call no network
endpoint and carry no credentials. The runbooks contain detection queries (billing
export SQL, CLI commands) that you run in your own cloud account; nothing in this
repository reads a cloud account.
The hosted MCP connector, if you add it, sends tool calls to mcp.optimnow.io.
When the model calls one of the 7 tools, the tool arguments (a reference or runbook
name, a section phrase, facet filters, a guide slug, or a query in the user's own
words, ranked in memory and never stored) travel over HTTPS to that server and the
matching content comes back. The server requires no account and no authentication,
holds no database and no per-user state, and serves the same public files as this
repository. Its application log writes one line per request (method, path, status
and request type, never the arguments); when a lookup matches nothing, it also
writes the tool name and the arguments that missed, which are short strings the
model writes and can include a word copied from your question; a query is the
exception, logged as its word count only. The server runs on
Fly.io, primary region Paris, which holds that log stream, possibly with the client
IP address, under its default retention. OptimNow does not sell, share or profile
from it.
Price lookups route to a live tool, not to this repo. Whether the model opens
OptimToken is its decision in the conversation.
One tool makes an outbound request.get_live_figures sends one HTTPS GET to
optimtoken.optimnow.io (an OptimNow site) for a guide's figures.json, carrying the
guide slug and a cloud-finops-mcp User-Agent, nothing from the conversation. On the
hosted connector the request leaves the server; with the PyPI package it leaves your
machine. No other tool touches the network.
Nothing else. No telemetry, no analytics beacon, no update check, no package
launcher, no credential read from your environment.
Maintenance
The library is updated weekly. Every Saturday an automated scan checks around 30
sources: cloud and AI provider release notes, billing changelogs and pricing pages,
plus FinOps community publications. Each change is confirmed on the provider's own
documentation and reviewed by a practitioner before it is applied. Every merge to
main becomes a new plugin version in the Claude directory, and a version-tagged
release ships the same content to the Claude Code marketplace install, PyPI, the MCP
Registry and the hosted connector. Watch or star the
repository to be notified, and read CHANGELOG.md for what each
version changes for you, in plain words. The provider changes verified over the last
90 days, and those already scheduled, are in one dated file,
finops-whats-new.md:
ask "what changed in cloud billing last month?" and the answer comes from it.
Contributing
Practitioner experience is the highest-value contribution. Frameworks and vendor docs
are already public; what is rare is "we tried X in production, this is what it
billed". Corrections to billing mechanics, new or improved runbooks, real-world
counter-examples and adversarial review of the recommendations are all welcome: the
repository is opinionated, and it should also be falsifiable.
The shortest contribution is a report. Two issue forms, at
https://github.com/OptimNow/cloud-finops-skills/issues/new/choose, take an
answer that was wrong or incomplete, or a question the library did not cover, with
the wording you used. Each confirmed report is fixed on the provider's documentation
and becomes a test question run before every release.
The full guide, including the repository structure, contribution types, process and
conventions, is in CONTRIBUTING.md. If your change names another
OptimNow tool (an MCP tool name, an endpoint URL, a provenance field), read
DEPENDENCIES.md first.
Adapting this skill for your organisation
Two paths, both first-class.
An overlay is a second, private skill folder beside this one. It cites the public
sections it builds on by heading and adds what this repository deliberately leaves
out: your negotiated rates, your tag taxonomy, your coverage targets, the decisions
your committee already took, one client account's profile. It copies nothing, so a
public update never breaks it, and a check tells you when a heading it cites has
moved. Start from docs/OVERLAYS.md and the template in
docs/overlay-template/.
A fork is the right tool when you want to change the public text itself: a
different methodology, your own house style, a provider this repository does not
cover. A fork gives you a stable base you can pull upstream updates into at your own
pace. Typical customisations:
Adding organisation-specific tag requirements to finops-tagging.md
Adding reference files for internal tools or platforms not covered here
Adjusting the methodology file to your team's own approach
About OptimNow
OptimNow is a boutique FinOps consultancy that helps organisations connect cloud and
AI spend to measurable business value. Based in France, with European reach.
Compare what 250+ models cost per request, with caching and batch factored in, plus compute instance rates across 7 clouds. Also an MCP connector; this skill routes price questions here
This skill incorporates content derived from the following sources:
FinOps Foundation: framework definitions, capability
descriptions and maturity model structure are based on the FinOps Framework.
Tokenomics Foundation: the token complexity
classes in the agentic FinOps reference are adapted from Big-T Notation by
Dan Neff (Adobe), published by the Tokenomics Foundation under
CC BY 4.0. The AI cost and value
references also draw on the Foundation's five-layer tokenomics stack paper, its
proposed definition of the total cost of AI, and the drafts of its consumption and value
working groups, each cited where it is used.
Every other source is credited inline, in the file that uses it. Billing mechanics
cite the provider's own documentation with the date it was read; figures and
opinions from practitioner talks (FinOps X 2026 and others) are attributed to the
speaker and organisation where they appear.
All referenced content has been adapted with additional context from OptimNow's
consulting delivery experience. Any errors or opinionated interpretations are our own.
This skill is independently maintained and is not affiliated with or endorsed by the
FinOps Foundation.
You are free to use, adapt and redistribute this skill, including for commercial
purposes, as long as you credit OptimNow and share any derivatives under the same
licence. When redistributing the material, please include this attribution: