> ## Documentation Index
> Fetch the complete documentation index at: https://docs.decimal.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Vocabulary

> Six words, one meaning each — install, fork, export, installs, uses, instrument.

Six things happen to a skill. Each has exactly one word. This page is the only
place they are defined, so that they cannot drift apart again.

## The three verbs

<CardGroup cols={3}>
  <Card title="Install" icon="download">
    **Link a skill into your workspace.** No copy. Your agents get the author's
    updates as they publish them, the way an extension marketplace works.
  </Card>

  <Card title="Fork" icon="code-branch">
    **Take an editable copy.** It becomes your skill, in your org, and it stops
    tracking the author. Same meaning as on GitHub.
  </Card>

  <Card title="Export" icon="file-arrow-down">
    **Write the files to disk.** For runtimes that load `SKILL.md` themselves —
    Claude Code, Cursor. Takes no copy and needs no fork.
  </Card>
</CardGroup>

Each verb has an inverse, and only Install's is a distinct action: **Uninstall**
removes the link. It clears the skill from every agent at once, and it is safe to
repeat — removing a skill you no longer have succeeds and reports that nothing
changed. A fork is your own skill, so you delete it like any other; an export is
just files, so you delete the files.

Install and Fork answer *what do I have*. Export answers *where do the bytes
live*. They are separate questions, so you can export a skill you installed
without forking it:

```bash theme={null}
decimalai skills export pdf --agent claude-code
```

```python theme={null}
router.use("pdf")                          # Install — the link
router.export("pdf", agents=["cursor"])    # the files, no copy
router.fork("pdf")                         # only if you intend to edit it
```

Uninstall is in the app and on the API today. The SDK call ships in a later
release — until then, remove a link with:

```bash theme={null}
curl -X DELETE https://api.decimal.ai/api/v1/registry/skills/pdf/use \
  -H "Authorization: Bearer dai_sk_..."
```

<Note>
  `decimalai skills install` and `router.install()` still exist and still do
  fork-then-write. They are deprecated in favour of the three above, and they
  have not changed behaviour — only the recommendation.
</Note>

<Note>
  The [Claude Code plugin](/guides/use-skills-without-the-sdk#claude-code-plugin)'s
  `/decimalai:install` is an **Export** by the table above: it writes `SKILL.md` and
  its attachments to `.claude/skills/`, takes no copy, creates no link, and leaves no
  record on the platform. It is spelled install because that is the word a plugin user
  types — nothing about your workspace changes when you run it.
</Note>

## The two numbers

| Number       | Counts                         | Unit                                    |
| ------------ | ------------------------------ | --------------------------------------- |
| **Installs** | how widely a skill is deployed | **agent setups** it is installed on     |
| **Uses**     | how much it actually runs      | **invocations** — times an agent ran it |

Installs is counted in agents, not teams, because a team that rolled a skill out
to ten agents did ten times the adoption of a team that put it on one. An agent
only exists once a trace has landed for it, so the number cannot be inflated by
clicking.

Under the surface, a run passes through four stages and only the last one is
what "Uses" means:

| Stage         | Happens when                                  |
| ------------- | --------------------------------------------- |
| offered       | the router put the skill in the menu          |
| served        | the agent fetched its body                    |
| delivered     | the body reached the model                    |
| **activated** | the model actually used it — **this is Uses** |

The first three are diagnostic: *offered* against *activated* is how you tell a
skill nobody picks from a skill nobody is shown. They never appear as a headline
number, because four counts labelled slightly differently is how the vocabulary
came apart in the first place.

## One more, for the SDK

**`instrument`** turns on tracing for a framework — `decimalai.langchain`,
`decimalai.openai_agents`, and so on. It has nothing to do with skills; it is
here only because it used to be spelled `install()` too.

```python theme={null}
import decimalai
decimalai.init(langchain=True)
```

## Words we deliberately do not use

* **"Used by N teams"** — the wrong unit. See Installs above.
* **"Subscribe"** — an older name for Install. The database table is still
  called `skill_subscription`; nothing user-facing says it.
* **"Activations"** — the internal name for the last stage above. Say Uses.
* **`install_count`** — counts fork *events*, never decremented. It is not the
  adoption number and is not rendered as one.