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

# Agent skills

> Install the open source skills that teach an agent Tatara's write workflow, document grammars, and how to recover from a rejected write.

The Tatara agent skills teach an agent how to work with your brain correctly: the write workflow, the grammar of each document format, and what to do when a write comes back rejected.

Tatara validates every write against the document's canonical format. Without the skills, an agent learns those rules by failing: it sends a body, the gate rejects it, and it guesses again. The skills give it the grammar up front, so the first write passes.

They follow the open [Agent Skills](https://agentskills.io) standard and use only portable frontmatter, so the same skills work in Claude Code, Cursor, Codex, GitHub Copilot, Gemini CLI, and other tools that support the standard.

## Before you install

<Info>
  The skills are inert on their own. Everything they describe is a call to a Tatara MCP tool, so your agent needs a connected Tatara MCP server first. See [Connect an agent](/mcp/connect).
</Info>

## Installing

Install all five skills into every agent tool detected on your machine:

```bash theme={null}
npx skills add tatara-app/tatara-skills
```

Install a single skill:

```bash theme={null}
npx skills add tatara-app/tatara-skills --skill tatara-kanban
```

Target specific agent tools with `-a`, which is repeatable:

```bash theme={null}
npx skills add tatara-app/tatara-skills -a claude-code -a cursor
```

### As a Claude Code plugin

```bash theme={null}
claude plugin marketplace add tatara-app/tatara-skills
claude plugin install tatara@tatara
```

<Warning>
  The install identifier is `tatara@tatara`, not `tatara-skills`. The plugin and the marketplace are both named `tatara`, and the plugin bundles all five skills as one unit.
</Warning>

### On claude.ai

Download the repository, zip a folder under `skills/`, and upload it in claude.ai under **Settings → Capabilities → Skills**.

## The five skills

One core skill and four format skills.

| Skill            | What it teaches                                                                                                                                                | Load it when                                 |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| `tatara`         | The end-to-end workflow over the MCP server: search before writing, resolve folders, tag from the taxonomy, pick a render format, recover from a rejection.    | Always. Any task that touches Tatara.        |
| `tatara-kanban`  | The board grammar: `## Column` headings with `- [ ]` card items, card detail lines, minimal-diff edits.                                                        | The document is a workflow board.            |
| `tatara-tracker` | The checklist grammar: optional `## Section` headings, task items, and the signifier tokens that carry a task's tags, priority, due date, and completion date. | The document is a task checklist.            |
| `tatara-table`   | The grid grammar: one pipe table, typed columns, and formula columns.                                                                                          | The document holds typed records of its own. |
| `tatara-base`    | The saved-view grammar: one `base`-fenced YAML block with filters, properties, and views.                                                                      | The document is a view over other documents. |

## How the skills combine

The core `tatara` skill is always in play. It owns the workflow (search first, resolve the folder, tag from the taxonomy, then write) and the recovery loop when a write is rejected. A format skill loads on top of it when a document needs a rich view, and it governs only the body content.

So a plain prose document needs only the core skill. A board needs the core skill and `tatara-kanban`: the core skill decides where the document is filed and how it is tagged, and `tatara-kanban` decides what the body bytes look like.

## Choosing between the format skills

See [Document formats](/formats/overview) for what each format requires.

### Board or task checklist

Both use `- [ ]` checkbox items, so look past the checkbox to where the meaning lives.

* Choose [kanban](/formats/kanban) when the column a card sits in **is** the state. The work of the document is moving cards between columns.
* Choose [tracker](/formats/tracker) when the metadata on each task is the point: per-task tags, a priority glyph, a `📅 YYYY-MM-DD` due date, a `✅ YYYY-MM-DD` completion date. Tasks can be grouped under `## Section` headings, but the grouping is optional and is not a state machine.

### Table or base

Both render as a grid, which is where the confusion starts. The difference is what owns the rows.

* A [table](/formats/table) holds its own data. The rows live in the document body as one pipe table, with a declared type per column.
* A [base](/formats/base) holds no data of its own. It is a saved view whose rows are **other documents in your brain**, selected by filters. The body contains only the query.

Editing a table changes the data. Editing a base changes which documents appear.

## Repository

<Card title="tatara-app/tatara-skills" icon="code" href="https://github.com/tatara-app/tatara-skills">
  The skills are open source under the MIT licence. Read them to see exactly what your agent is told about each format.
</Card>