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

# Skills

> Reusable instructions that agents discover and load on demand.

Skills are reusable instructions that persist across conversations. An agent can load a skill when it recognizes a matching task, giving it step-by-step guidance without you repeating yourself every time.

Dash ships with a **bundled library** of ready-made skills (research, drafting, summarizing, code review, and more), and agents can **install more** from the public skill ecosystem — by chat or from Desktop. Users can also list and run skills directly from a chat channel with slash commands.

## How skills work

Each skill is a directory containing a `SKILL.md` file with metadata (frontmatter) and instructions (content). When an agent starts processing a message, it sees a compact index of available skills in its system prompt — just names and descriptions. When it identifies a relevant skill, it loads the full instructions on demand.

```
my-skill/
  SKILL.md     ← metadata + instructions
```

This two-phase approach keeps token usage low: the agent always sees *what's available* but only loads *what's needed*.

## System prompt structure

When an agent processes a message, its system prompt is assembled from multiple sources in this order:

1. **Your system prompt** — the prompt you configured when deploying the agent
2. **Memory** — the agent's memory index and any recalled memories (see [Memory](/memory))
3. **Skill index** — a compact listing of available skills with names, descriptions, and triggers

The skill index looks like this in the system prompt:

```
## Available Skills
- **deploy-staging**: Use when deploying to staging (trigger: user mentions staging deploy)
- **db-migration**: Use when running database migrations (trigger: working with schema changes)

Use the load_skill tool to load a skill's full instructions when a task matches one of these skills.
```

The agent uses the `load_skill` tool to fetch full instructions when it decides a skill is relevant.

## Skill format

A `SKILL.md` file has YAML frontmatter followed by markdown content:

```yaml theme={null}
---
name: deploy-staging
description: Use when deploying to the staging environment via AWS
trigger: when user mentions staging deploy or asks to push to staging
tools: [bash, read]
tags: [deployment, aws]
---

## Deploy to Staging

1. Verify the current branch is clean: `git status`
2. Run the deploy script: `./scripts/deploy-staging.sh`
3. Check the deployment dashboard at https://staging.example.com
4. Report the deployment status back to the user
```

### Frontmatter fields

| Field           | Required | Description                                                                                                 |
| --------------- | -------- | ----------------------------------------------------------------------------------------------------------- |
| `name`          | Yes      | Skill identifier (lowercase, hyphens). Becomes the directory name.                                          |
| `description`   | Yes      | When to use this skill. Shown in the skill index — write it for discovery.                                  |
| `trigger`       | No       | Specific phrases or contexts that should activate this skill. Shown in the index alongside the description. |
| `tools`         | No       | Tools this skill needs (e.g. `[bash, read]`). Informational in v1.                                          |
| `tags`          | No       | Categories for organizing skills in Desktop.                                                                |
| `model`         | No       | Model override for this skill. Stored but not acted on in v1.                                               |
| `context`       | No       | Set to `fork` for subagent execution. Stored but not acted on in v1.                                        |
| `allowed-tools` | No       | Restrict tools during skill execution. Stored but not acted on in v1.                                       |
| `dependencies`  | No       | Other skills to load alongside this one. Stored but not acted on in v1.                                     |

<Tip>
  Write the `description` as if answering "when should an agent use this?" — it's what the agent reads to decide whether to load the skill. Be specific: "Use when deploying to staging via AWS" is better than "Deployment helper".
</Tip>

## Skill storage

Skills are discovered from three tiers, in precedence order — a per-agent skill overrides a bundled skill with the same name:

### Managed directory

Each agent has a managed skills directory outside its workspace:

```
~/.dash/gateway/skills/{agent-name}/
```

This directory is created automatically. Skills here are managed through Desktop or created by the agent itself (if allowed). The agent's file tools cannot reach this directory — it's outside the workspace sandbox.

### Additional paths

From the agent's **Skills** tab in Desktop, you can add extra directories to scan for skills. If a path is inside the agent's workspace, the agent's file tools can read and write to it. This is an opt-in choice for power users who want to manage skills alongside project files.

### Bundled library

Dash ships a curated library of ready-made skills covering assistant, dev, creative, and communication tasks. These are available to every agent by default and are read-only. To stop using one, install a same-named skill to shadow it — or turn the whole bundled library off from the agent's **Skills** tab.

## Squad member skill creation

Squad members can create their own skills when given the `create_skill` tool. This is opt-in — include `create_skill` in the squad member's tool list when deploying.

When a user says something like "remember how to deploy to staging", the agent uses `create_skill` to write a `SKILL.md` to the managed directory. The skill is available in future conversations.

Squad member-created skills:

* Are saved to the managed directory (outside the workspace)
* Are labeled "Squad member" in Desktop so you can distinguish them from skills you pushed
* Cannot overwrite existing skills — the agent can only create new ones
* Can be reviewed, edited, or deleted by the operator through Desktop

<Warning>
  The `create_skill` tool lets the agent write persistent instructions that affect its own future behavior. Only enable it for agents you trust to self-modify responsibly.
</Warning>

## Learning from experience

Squad members also pick up skills on their own. After a turn where the squad member did real work, Dash runs a short review that asks the squad member's own model one question: did this session teach anything worth keeping? Anything it finds is written into a skill the squad member owns, so the next conversation starts already knowing it.

You don't have to do anything to switch this on — it is on by default.

### What gets learned

A lesson is one short, self-contained instruction: a technique that worked, a correction you made, a dead end worth avoiding next time. Corrections are the richest source — telling the agent "always use X here, never Y" is what turns into a lasting rule. Lessons are grouped into skills named for a **kind of task** rather than for one job, so a handful of useful skills build up instead of a long list of near-duplicates.

The review is told not to record a few things that look like lessons but age badly:

* **Problems with your setup** — a missing program, an unset key, a path that only breaks on this machine. Those get fixed; they aren't lasting rules.
* **"This tool is broken."** A claim like that would be repeated back to the agent for months after the real cause was fixed. If something failed because of setup, the lesson is the fix, not the failure.
* **Errors that went away on their own.** If retrying worked, the lesson is to retry.
* **One-off jobs.** Summarising a single document isn't a kind of work worth a skill.

Nothing sensitive should ever be recorded. As with memory, that is an instruction the agent is given, not a filter Dash enforces — so don't paste passwords or keys into chat.

### Seeing it happen

When the review records something, a small chip appears in the conversation where it happened — "Learned: write-files", or "Remembered: …" for a memory. It is part of the conversation, so it is still there when you scroll back or reopen it later. The same chip shows in Desktop, on iPhone, and on the web.

### Where it lives

Learned skills sit in the same managed directory as any other squad member skill, are labelled **Squad member** in Desktop, and can be read, edited, or deleted there like the rest. Beside each one is a `lessons.json` file holding the individual lessons.

Open a learned skill in Desktop and you see its lessons one by one, each with how often the agent has judged it helpful or harmful, and a **Retire** button. On iPhone and on the web the list is read-only — you can see what an agent knows and read the lessons, but changing them is done from Desktop.

Learning only ever writes to skills the agent created itself. A skill you wrote, one installed from the ecosystem, and anything in the bundled library are never modified. When the agent learns something about one of those, it records it in a companion skill that is loaded alongside the original, so the lesson still arrives when it is relevant.

### Correcting a lesson

Each lesson carries a count of how often the review judged it right and how often it judged it wrong. A lesson that keeps proving wrong and never proves useful retires itself, and retired lessons are kept in the file rather than deleted, so you can see what happened and put one back by hand.

To correct something immediately, open the skill in Desktop and **Retire** the lesson. Retiring keeps it in the file and stops the agent proposing it again. To stop Dash managing a learned skill altogether, delete its `lessons.json` — the skill stays as an ordinary one that learning no longer touches.

### Settings

From the agent's **Skills** tab, or via the API:

| Setting        | Default | What it does                                                                                                                    |
| -------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `learning`     | `auto`  | `auto` and `on` both enable learning; `off` disables it.                                                                        |
| `minToolCalls` | `3`     | How much work a turn must involve before it is reviewed. A turn that was just conversation is never reviewed and costs nothing. |

A turn where you **correct** the agent is always reviewed, however little work it involved — "stop doing that", "use X instead", "always do it this way" is the most useful thing a session can teach, and those turns are usually short.

Each review that runs costs one extra model call, on the agent's own model.

<Note>
  Learning applies to turns that complete normally. A turn that fails or is cancelled is not reviewed — there is no finished outcome to learn from.
</Note>

## Installing skills from the ecosystem

Skills use the open `SKILL.md` standard, so an agent can install skills published by the wider ecosystem (for example `anthropics/skills`, `openai/skills`, or `NousResearch/hermes-agent`). Give an agent the `install_skill` tool, then ask it in chat:

> "Install the arxiv skill from NousResearch/hermes-agent"

Skills can be installed from any of these sources:

* **Git** — `git:owner/repo[/subpath][@ref]` (e.g. `git:NousResearch/hermes-agent/skills/research/arxiv@main`)
* **URL** — a direct link to a `SKILL.md`
* **Local path** — a folder on the HQ host

Installed skills land in the managed directory and are labeled **Remote**.

<Warning>
  Installing a skill adds instructions the agent will follow. Two safeguards keep this safe:

  * Skills are **text-only** — any bundled scripts are stripped on install, so an installed skill can never run code on your HQ.
  * Every install passes through a **security scan** that refuses skills containing prompt-injection, secret-exfiltration, or destructive instructions. If the scan can't run, the install is refused.

  Only enable `install_skill` for agents whose audience you trust.
</Warning>

Use the `remove_skill` tool to uninstall a skill the agent installed or created. Bundled skills can't be removed.

## Chat commands

When an agent serves a messaging channel, users can manage skills inline:

| Command                 | What it does                                          |
| ----------------------- | ----------------------------------------------------- |
| `/skills`               | List the agent's available skills                     |
| `/skill:<name> [input]` | Run a specific skill (e.g. `/skill:summarize-thread`) |
| `/help`                 | Show the available commands                           |

Natural language works too — "what skills do you have?" or "install the arxiv skill from …" — when the agent has the relevant tools.

## Managing skills in Desktop

The agent detail page has a **Skills** tab where you can manage an agent's skills directly:

* **View** every skill the squad member can use, with a source badge (Bundled / Managed / Squad member / Remote). Click a skill to read its `SKILL.md`.
* **Create** a new skill from a name, description, and content.
* **Edit** the body of a managed, installed, or agent-created skill (bundled skills are read-only).
* **Install** a skill from a git repo, URL, or local path — security-scanned, dangerous skills refused.
* **Remove** a skill the agent installed or created.
* **Configure** the skill library: toggle the bundled library on/off and add extra skill directories.

Changes take effect on the agent's next message — no restart needed.

Separately, the deploy / edit-agent wizard has a **Skills** tool group that controls what the *agent itself* can do over chat: **Create Skill**, **Install Skill**, and **Remove Skill**.

## Skill tools reference

### `load_skill`

Loads a skill's full instructions into the conversation. Always available when skills are configured. The agent calls this automatically when it identifies a matching task from the skill index.

| Parameter | Type     | Required | Description            |
| --------- | -------- | -------- | ---------------------- |
| `name`    | `string` | Yes      | The skill name to load |

### `create_skill`

Creates a new skill in the managed directory. Only available when included in the agent's tool list.

| Parameter       | Type       | Required | Description                                         |
| --------------- | ---------- | -------- | --------------------------------------------------- |
| `name`          | `string`   | Yes      | Skill identifier (lowercase, hyphens, max 64 chars) |
| `description`   | `string`   | Yes      | When to use this skill                              |
| `content`       | `string`   | Yes      | Full skill instructions                             |
| `trigger`       | `string`   | No       | Activation phrases or contexts                      |
| `tools`         | `string[]` | No       | Required tools                                      |
| `tags`          | `string[]` | No       | Categories                                          |
| `model`         | `string`   | No       | Model override                                      |
| `context`       | `string`   | No       | `"fork"` for subagent execution                     |
| `allowed_tools` | `string[]` | No       | Tool restrictions                                   |
| `dependencies`  | `string[]` | No       | Related skills to load together                     |

### `install_skill`

Installs a text-only skill from a git repo, URL, or local path, after a security scan. Only available when included in the agent's tool list.

| Parameter | Type     | Required | Description                                                                     |
| --------- | -------- | -------- | ------------------------------------------------------------------------------- |
| `source`  | `string` | Yes      | `git:owner/repo[/subpath][@ref]`, an https URL to a `SKILL.md`, or a local path |
| `name`    | `string` | No       | Override the installed skill's name                                             |

### `remove_skill`

Uninstalls a managed, installed, or agent-created skill. Bundled skills cannot be removed. Only available when included in the agent's tool list.

| Parameter | Type     | Required | Description              |
| --------- | -------- | -------- | ------------------------ |
| `name`    | `string` | Yes      | The skill name to remove |