/skills/atlas

Use when choosing, comparing, or integrating a third-party service, API, or SDK (auth, payments, email, storage, etc.). Query MadeForMachine Atlas — an intelligence engine for product and feature discovery and comparison — over MCP, jumping straight to the doc evidence for a capability instead of crawling a provider's docs or recalling from stale training data.

Public skill artifact for humans to inspect and agents to install.

https://mfm.dev/skills/atlas

beta · v0.1.0

$ manifest

slugatlas

nameatlas

version0.1.0

latest_version0.1.0

statusbeta

connectormfm

licenseMIT

$ requires — MCP tools

atlas_capabilities

Read FIRST. The evidenced capability vocabulary across the field — canonical terms, each with the number of providers grounding it. It gives you the term ids that atlas_select, atlas_compare, and atlas_providers filter on, and it is the honest denominator for non-features. Public — no account needed.

atlas_select

Select across the whole field by required and excluded capability term ids (get the ids from atlas_capabilities). Returns the matches AND the transparent elimination — which providers were cut and on which missing requirement, the missing one shown as an inferred non-feature. No black-box ranking; the transparency is the point.

atlas_compare

Pivot a bounded shortlist of providers against one topic into a provider-by-capability matrix. Each cell is a grounded claim with its evidence node, or an inferred absence. Pass the topic as capability term ids, or as a term group id. No verdict — you weigh the evidence.

atlas_provider

One provider's profile: its grounded capabilities, each tied to the exact doc node (and URL) that evidences it — so you jump straight to the evidence instead of crawling the docs.

atlas_tree

Walk one provider's documentation tree top-down — titles, summaries, child counts, no bodies — pinned with the capabilities grounded on each node, so you read only the nodes that carry evidence. The public drill-down (digest) surface.

$ install

Give this prompt to an agent that can read URLs and write local files:

Install the MFM skill 'atlas' for this agent.
Use the skill page as the source of truth: https://mfm.dev/skills/atlas
Fetch the current skill artifact, write the full skill folder to the right skills directory for this harness, and do not hand-edit generated files.
Also configure the 'mfm' MCP server at https://mcp.mfm.dev/mcp, complete OAuth, and verify these tools are visible before claiming setup is done: atlas_capabilities, atlas_select, atlas_compare, atlas_provider, atlas_tree.
After installation, start a fresh agent session or reload the tool/skill registry if this harness requires it.

Manual fallback by harness:

general

1. Install the full skill folder from https://github.com/MadeForMachine/mfm-skills.git.
2. Copy 'skills/atlas/' into your agent's skills directory without renaming files.
3. Configure the 'mfm' MCP server at https://mcp.mfm.dev/mcp.
4. Complete OAuth and confirm the required tools are visible.

Claude Code

git clone https://github.com/MadeForMachine/mfm-skills.git
mkdir -p ~/.claude/skills
cp -R mfm-skills/skills/atlas ~/.claude/skills/atlas
claude mcp add --transport http mfm https://mcp.mfm.dev/mcp
claude mcp login mfm

Codex

git clone https://github.com/MadeForMachine/mfm-skills.git
mkdir -p ~/.agents/skills
cp -R mfm-skills/skills/atlas ~/.agents/skills/atlas
codex mcp add mfm --url https://mcp.mfm.dev/mcp
codex mcp login mfm

Cursor

git clone https://github.com/MadeForMachine/mfm-skills.git
mkdir -p ~/.agents/skills
cp -R mfm-skills/skills/atlas ~/.agents/skills/atlas

// Add this to ~/.cursor/mcp.json for global setup,
// or .cursor/mcp.json for project setup:
{
  "mcpServers": {
    "mfm": {
      "url": "https://mcp.mfm.dev/mcp"
    }
  }
}

Then open Cursor MCP settings and authenticate the mfm server.

install paths
.claude/skills/atlas/     # project-local Claude Code fallback
.agents/skills/atlas/     # project-local Codex & Cursor fallback

Raw manifest: /skills.json · source & manual fallback: MadeForMachine/mfm-skills/tree/main/skills/atlas

$ artifact — SKILL.md body

You are about to evaluate an external service. Do **not** crawl the provider's docs and
do **not** answer from memory. Both fail the same way: docs overload you before you find
the part that matters, and recall is stale, version-blind, and unsourced.

Instead, query **Atlas**, MadeForMachine's intelligence engine for product and feature
discovery and comparison. It has already sent many agents through each provider's docs and
recorded, for every capability, **the exact doc node that evidences it**. Your job is not to
re-read the docs — it is to let Atlas point you at the six URLs worth reading and skip the
other fourteen hundred.

Three things make this work, and you must respect all three:

1. **Jump, don't crawl.** Every capability resolves to a grounded evidence URL. Follow the
jump; never start at a provider's docs root and walk down.
2. **Read only what is pinned.** The doc tree flags which nodes carry evidence. Read the
pinned nodes and the reading list — nothing else.
3. **Trust typed absence, not blank space.** A missing capability is one of two things:
`mined-absent` ("we researched this area, it isn't there" — a real non-feature) or
`dark` ("we haven't researched here — unknown"). **Never report `dark` as "doesn't
support."** If a dark area decides the call, say so, or jump to that one provider URL and
read it yourself.

## When to use

- "What should I use for X", "compare A vs B", "does X support Y".
- Before scaffolding an integration against a third-party service.
- When pricing, limits, capabilities, or auth methods affect a decision.
- When the user wants options weighed against real constraints, not one guess.

## Tools (surgical — narrow input, exact answer)

Each tool takes a tight query and returns a precomputed answer. Pass the narrowest input you
can; the power is in the precompute, not in options.

1. `atlas_capabilities` — the controlled vocabulary: canonical capability terms and how many
providers ground each. Learn valid terms here *before* querying the field.
2. `atlas_select` — query the whole field by **required** and **excluded** capabilities.
Returns matches **and** the transparent elimination: who was cut and on which missing
requirement, each absence typed `mined-absent` vs `dark`. The elimination is evidence,
not noise.
3. `atlas_compare` — pivot a shortlist (2–4 providers) against one topic into a
capability-by-provider matrix. It also returns the **reading list**: the exact evidence
URLs to read to judge the topic across the shortlist. Read those, not the doc sites.
4. `atlas_provider` — one provider's grounded capabilities, each with its evidence URL and the
coverage provenance (how thoroughly researched, which areas are dark).
5. `atlas_tree` — the provider's **pinned** doc tree: depth-collapsed, each node flagged with
the capabilities grounded on it. Use it to find the one node to read when a `atlas_compare`
cell is dark or you need detail below a capability.

## Workflow

1. Restate the requirement as **hard constraints** (must-haves) vs **soft preferences**.
2. If unsure of valid terms, call `atlas_capabilities` first — query the vocabulary, not free
text.
3. `atlas_select` with the hard constraints. Read the elimination: a provider cut on a
`mined-absent` requirement is genuinely out; one cut on a `dark` area is *unknown*, not
out — flag it.
4. Take the top 2–4 to `atlas_compare` on the deciding topic. Follow the **reading list** to
the evidence URLs; read those nodes, nothing more.
5. Recommend one and say why — cite the capability terms, the evidence URLs, and the
coverage. Name the runner-up and the exact axis it lost on. If a `dark` area could change
the answer, say so plainly.

## Rules

- **Jump over crawl.** If you read a provider page, it should be one Atlas pointed you
to, not a page you found by walking their docs.
- **`dark` is not `absent`.** Only a `mined-absent` edge is a real non-feature. Never let an
unresearched area read as "doesn't support" — that is the one mistake Atlas exists
to prevent.
- **Cite the grounded URL.** Every capability claim you make should trace to an evidence node
Atlas returned, not to recall.
- **The term-set is the summary.** Don't ask for or synthesise prose blurbs; compare on the
machine-readable capability terms.
- **Don't invent.** No capability, limit, or price that isn't in a grounded answer.
- **Surface coverage honestly.** If the field is thinly researched for this requirement, say
so and fall back to reading the specific provider URL — never to ungrounded recall.

← all skills