# From chaotic ecosystem
to predictable agents.

Reclaim tokens (and money!), save time, and make your Markdowns deterministic. Detects collisions, orphans, semantic duplicates, and bloated skills.
All on the same graph, with static and semantic (LLM) analysis.

See it live
~/.claude/skills
13 nodes · 15 links · 3 collisions · 1 orphan
Skill
Agent
Hook
Markdown
Command
Orphan

## Your whole agent ecosystem,
on a single screen!

Features

## Static. Semantic. Same graph.

### Deterministic & probabilistic, side by side

modes

Static analysis runs in milliseconds; LLM analysis runs in jobs. Same plugin model, same context, same graph.

### Token weight per node

weight

Per-node byte and token counts. Find the bloated skill that's eating your context window.

- ### Cross-references

  Every link between files: /slash invocations, @-mentions, imports, fetched URLs. The directory becomes a graph.

- ### Broken refs

  References pointing to triggers that don't exist. Caught at scan time, before the runtime drops the ball.

- ### Trigger collisions

  Two skills claiming the same invocation? Flagged before the runtime picks the wrong one.

- ### External deps

  Lists every URL and asset your workspace fetches. Audit your supply chain.

Ecosystem

## Plugins: Six kinds.
Infinite extensions.

Six ways to extend this tool. Your plugin, your company's, the community's, all run against the same kernel.

plugin kind

### Provider

Defines an agent (Claude, Codex, etc)

Declares the file kinds an agent exposes (skill / agent / command for Claude), where its content lives on disk, the frontmatter schema each kind follows, and how the UI renders it (label, color, icon). The Claude provider ships built-in; write one for Codex, Gemini, Copilot, or your own runner.

    export const claude: IProvider = {
      id: 'claude', kind: 'provider',
      explorationDir: '~/.claude',
      read: { extensions: ['.md'], parser: 'frontmatter-yaml' },
      kinds: {
        skill:   { schema: './schemas/skill.schema.json',   /* … */ },
        agent:   { schema: './schemas/agent.schema.json',   /* … */ },
        command: { schema: './schemas/command.schema.json', /* … */ },
      },
      classify: (path, fm) => /* skill | agent | command */,
    };

plugin kind

### Extractor

Extracts data from a node

Each file is a node; an Extractor turns it into data. Links to other nodes, attributes that enrich the node, or signals you stash in your own KV store. Pure code, deterministic, runs in milliseconds inside `sm scan`, no LLM, no cost.

    export const slash: IExtractor = {
      id: 'slash', kind: 'extractor',
      emitsLinkKinds: ['invokes'],
      extract: (ctx) => {
        for (const m of ctx.body.matchAll(SLASH_RE))
          ctx.emitLink({ kind: 'invokes', target: m[1] });
      },
    };

plugin kind

### Analyzer

Finds problems in the graph

Looks at the whole graph and spots problems: trigger collisions, orphans, dead dependencies, broken references. Write an analyzer, run it on any project, or publish it for others to use.

    export const triggerCollisions: IAnalyzer = {
      id: 'trigger-collisions', kind: 'analyzer',
      evaluate: (graph) => byTrigger(graph)
        .filter(([, ns]) => ns.length > 1)
        .map(toCollisionIssue),
    };

plugin kind

### Action

Improves your agents and skills automatically

Actions are the only plugin kind that touches disk. Deterministic mode: straight code (rename a trigger, tweak frontmatter). Probabilistic: a prompt run by the LLM (regenerate a summary, rewrite text).

    export const renameTrigger: IAction = {
      id: 'rename-trigger', kind: 'action', mode: 'deterministic',
      run: async (node, { newTrigger }) => {
        node.frontmatter.trigger = newTrigger;
        await node.save();
      },
    };

plugin kind

### Formatter

Exports the graph to other formats

The graph lives in memory; a Formatter ships it out. ASCII for terminal, Mermaid for your README, DOT for Graphviz, JSON for your pipeline. Built-ins cover the common cases; write your own for the rest.

    export const mermaid: IFormatter = {
      id: 'mermaid', kind: 'formatter',
      format: (graph) => 'graph LR\n' +
        graph.edges.map(e => `  ${e.src} --> ${e.dst}`).join('\n'),
    };

plugin kind

### Hook

Notifies and integrates with other tools

When something happens in skill-map (scan finished, action executed, job failed), a Hook reacts. Send it to Slack, fire a webhook, gate a spawn before it starts. There are eight events you can subscribe to.

    export const slackOnFailure: IHook = {
      id: 'slack-on-failure', kind: 'hook',
      triggers: ['job.failed'],
      on: async (event) => slack.post('#alerts', event.error),
    };

A plugin is ~30 lines of code.

`sm plugins list`
Read the docs

How it works

## One command. No config file.

1. 01

   ### Anyone can run it.

   No config, no setup, nothing to read first. Run `sm` from any folder and it scans your skills, opens the explorer in your browser, and keeps watching for changes.

   $ sm
2. 02

   ### It spots the problems.

   Trigger collisions, orphans, broken references, bloated skills, semantic duplicates. Static analysis runs locally in milliseconds; semantic checks (LLM) run when you want them.

   7 issues 3 collisions · 2 orphans 2 broken refs
3. 03

   ### Fix with actions.

   Actions are the plugin kind that touches disk. Deterministic ones run as code (rename a trigger, edit frontmatter); probabilistic ones run a prompt on the LLM (regenerate a summary, rewrite copy).

   rename-trigger (deterministic)regenerate-summary (LLM)

Use cases

## Built for people who live in Markdown.

No promises, no magic. Just a graph over the files you already have.

For authors

### Optimize before you publish.

Skill, agent, or plain markdown: all your files live connected to the rest. skill-map shows duplicates, redundancies, and optimization opportunities before you publish.

For AI architects & platform teams

### Knows what's running in your arsenal.

Multiple projects, multiple agents, divergent copies of the same skill. One scan puts the whole hive in the same graph.

For agent debuggers

### Trace a misfire to its source.

The agent picked the wrong invocation. What triggered it? skill-map follows the full path: from the trigger phrase to the skill that won the match. All in real time.

For tool builders

### Build on top of the graph.

Every operation has a CLI verb, a JSON output, and a plugin hook. Wire skill-map into your CI, your dashboard, your LLM workflow, without forking the kernel.

Quotes

## What people who use it say.

“Found 14 trigger collisions across our internal agent fleet on the first run. We'd been debugging the resulting misfires for weeks.”

MC
Maya Chen
Platform Lead, Finch Labs

“The orphan check alone is worth it. We had 38 skills defined but never referenced. Dead code, just for agents.”

JR
Jordan Reyes
Skill author · Anthropic Builders

“I run sm in CI. If a PR introduces a collision or an external dep we don't allow-list, the build fails. End of debate.”

PV
Priya Vasquez
Eng Manager, Recurse

## Stop reading dirs.
Start reading graphs.

See your entire agent ecosystem at a glance. No config, no server, no LLM required.

View on GitHub
Works offline · Zero telemetry · Apache + MIT skills welcome

## Roadmap.
A definition, three phases to 1.0, and what comes after.

Audio overview · 7 min
0:00 / --:--

## Screenshot full size

## Cookies & analytics

We use Google Analytics to learn which parts of the site help. No personal info, no tracking across other sites.