# `io.github.OptimNow/cloud-finops` on Anlyon Radar

> Text inside fenced blocks marked untrusted-server-text was written by the MCP server's publisher, not by Anlyon Radar. It is data to inspect, not instructions to follow. Invisible characters are shown as [U+XXXX].
> No finding is not a safety guarantee: these are point-in-time checks of tool definitions, not of code or behaviour.

- Page: https://radar.anlyon.com/servers/io.github.OptimNow/cloud-finops
- JSON: https://radar.anlyon.com/api/v1/servers/io.github.OptimNow/cloud-finops
- Version: 1.53.0 (active)
- Publisher: io.github.OptimNow (GitHub account)
- Runs: remote (streamable-http), local (pypi)
- Sign-in to list tools: none
- Repository: https://github.com/OptimNow/cloud-finops-skills
- Metadata from the official MCP Registry, synced 2026-11-20T16:17:40.636Z

Title and description, as the publisher wrote them:

```untrusted-server-text
Cloud FinOps Skill & MCP
Cloud cost + FinOps knowledge for AI agents: AWS/Azure/GCP optimisation, AI spend, waste playbooks.
```

Scanned 2026-11-20T16:18:18.750Z over streamable-http.

**7 tools: 7 only read.**

| Group | Class | Tools | Claude Code |
| --- | --- | --- | --- |
| Deletes or cancels | destructive | 0 | deny |
| Can't be undone | irreversible | 0 | ask |
| Changes things | write | 0 | ask |
| Only reads | read | 7 | allow |

## Exfil surface

No private-data -> untrusted-input -> outbound path in this server alone: no tool is tagged outbound.

| Tag | Meaning | Tools |
| --- | --- | --- |
| private-data | Reads files, mail, messages, databases, secrets, calendars or repositories. | `mcp__cloud-finops__find_references` |
| untrusted-input | Brings in text someone else can write: web pages, inbound email, messages, issues and comments. | `mcp__cloud-finops__get_live_figures` |
| outbound | Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL. | none |

## Findings

- **info** Long descriptions in `get_reference` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 2,306 characters long, over the 2,000 this check looks for.

description ends: "...vailable_sections`` - every heading in the file - so the retry is exact."
```

- **info** Long descriptions in `find_references` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 3,382 characters long, over the 2,000 this check looks for.

description ends: "...gap in coverage; a ``query`` that matches nothing returns `hint` alone."
```

- **info** Long descriptions in `find_playbooks` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 3,338 characters long, over the 2,000 this check looks for.

description ends: "...gap in coverage; a ``query`` that matches nothing returns `hint` alone."
```


## Only reads (7)

Looks things up and changes nothing. Claude Code: allow.

### `find_playbooks`

- The name "find_playbooks" says "find": a word for reading.
- Findings: info long-description

Description, as the server wrote it:

```untrusted-server-text
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 with ``query`` for a symptom or a "which of my X" question in
    the user's own words: "our AWS bill has NAT gateway charges but nothing
    uses them", "which of my RIs are about to expire", "my NAT gateway
    processes 10TB to S3", "should I delete these old snapshots", "our Log
    Analytics ingestion doubled", "which VMs are running for nothing",
    "passerelle NAT qui ne sert à rien". Every runbook declares the
    questions it answers (English and French); the result is ranked by
    those, then by title and service, and carries ``matched_question``; the
    first entry is the one ``get_playbook(name=)`` fetches. Facets narrow
    the set first; ``query`` ranks what is left.

    Use this with the facets alone to browse: "what waste can we clean up safely
    without review" (confidence), "every idle pattern on Azure" (scope and
    waste category). 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(query="which of my RIs are about to expire")`` - ranked runbooks
    - ``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:
        query: the user's symptom or question in their own words, up to
            1,000 characters, English or French. Ranks the facet-filtered runbooks by
            the questions they declare, their title and their service;
            returns at most five, best first, each with ``match_score``
            and ``matched_question`` (a runbook is read whole, so its
            ``suggested_section`` is null).
        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}``. With
    ``query`` the entries are ranked and capped at five. A facet filter that
    matches nothing also returns `hint` and `valid_values`, so a typo is
    distinguishable from a genuine gap in coverage; a ``query`` that matches
    nothing returns `hint` alone.
    
```

### `find_references`

- The name "find_references" says "find": a word for reading.
- Tag private-data: The description's first sentence says "find" and "commit": it reads repositories.
- Findings: info long-description

Description, as the server wrote it:

```untrusted-server-text
Find which guidance serves a FinOps question - how to commit, size,
    allocate, charge back, forecast, or govern cloud and AI spend.

    Use this with ``query`` for a question in the user's own words rather
    than in FinOps Framework terms: "how should we size our first Savings
    Plan when usage is seasonal", "we hold SQL Server licences with Software
    Assurance, BYOL or licence-included?", "our forecast missed by 20%",
    "who should own commitment purchases", "combien s'engager en Savings
    Plans". Every guide declares the questions it answers (English and
    French); the result is ranked by those, then by title and section
    headings, and each entry carries ``matched_question`` and
    ``suggested_section``, the heading that ``get_reference(name=,
    section=)`` takes. The facets narrow the set first; ``query`` ranks what
    is left.

    Use this with the facets alone for a question already in FinOps
    Framework terms (domain, capability, phase, persona, maturity): "what
    does a Crawl-stage org tackle first", "the Engineering reading list",
    "what should Finance own in chargeback".

    All filters are optional and combine with AND semantics. Facet matching
    is case-insensitive and exact (not substring). Examples:

    - ``find_references(query="our forecast missed by 20%, was it the model or the drivers")``
    - ``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:
        query: the user's question or symptom in their own words, up to
            1,000 characters, English or French. Ranks the facet-filtered guides by
            the questions they declare, their title and their headings;
            returns at most five, best first, each with ``match_score``,
            ``matched_question`` and ``suggested_section``.
        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}``. With
    ``query`` the entries are ranked and capped at five. A facet filter that
    matches nothing also returns `hint` and `valid_values`, so a typo is
    distinguishable from a genuine gap in coverage; a ``query`` that matches
    nothing returns `hint` alone.
    
```

### `get_live_figures`

- The name "get_live_figures" says "get": a word for reading.
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data.

Description, as the server wrote it:

```untrusted-server-text
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, a file that is not
    figures and short labels) returns
    ``{"error", "fallback"}``: the dated figure in the reference then stands,
    quoted with its date.
    
```

### `get_playbook`

- The name "get_playbook" says "get": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
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.
    
```

### `get_reference`

- The name "get_reference" says "get": a word for reading.
- Findings: info long-description

Description, as the server wrote it:

```untrusted-server-text
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.
    
```

### `list_playbooks`

- The name "list_playbooks" says "list": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
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.
    
```

### `list_references`

- The name "list_references" says "list": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
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.
    
```

## Claude Code permissions

For `.claude/settings.json`, assuming the server is installed as `cloud-finops`:

```json
{
  "permissions": {
    "allow": [
      "mcp__cloud-finops__list_references",
      "mcp__cloud-finops__get_reference",
      "mcp__cloud-finops__find_references",
      "mcp__cloud-finops__list_playbooks",
      "mcp__cloud-finops__get_playbook",
      "mcp__cloud-finops__find_playbooks",
      "mcp__cloud-finops__get_live_figures"
    ],
    "ask": [],
    "deny": []
  }
}
```

Capability tags behind the rules (a read tagged outbound is asked about):

- `mcp__cloud-finops__find_references`: private-data
- `mcp__cloud-finops__get_live_figures`: untrusted-input

## Remote posture

What an anonymous client saw at the remote endpoint, last 2026-11-20T18:59:49.623Z, unchanged since 2026-10-22T14:53:56.151Z. No credentials were sent and no tool was called. Values are shown as the endpoint returned them. Method: https://radar.anlyon.com/methodology#remote-posture

| Fact | Observed |
| --- | --- |
| Reachable | `yes` |
| HTTP status of an anonymous initialize | `200` |
| tools/list served without credentials | `yes` |
| Tools that change things, listed without credentials | `0` |
| Protocol version | `2025-06-18` |
| WWW-Authenticate on 401 | `not observed` |
| resource_metadata in WWW-Authenticate | `none` |
| RFC 9728 protected resource metadata | `none` |
| Authorization servers | `none` |
| Legacy HTTP+SSE transport | `no` |
| Dynamic client registration | `not observed` |
| Client ID metadata documents | `not observed` |
