---
title: Skills
sidebar:
  order: 9
---
## Overview

A **skill** is a stored, versioned procedure — written in Markdown — that Roboto's AI can apply during a conversation. Skills capture your team's know-how ("how we review a flight log", "our QA checklist") so the AI works from the same instructions for everyone who uses it.

Key properties:

- Skills are **versioned**: editing a skill's content creates or updates versions, and each user chooses which version their AI uses.
- Skills have one of three **accessibility tiers** — Private, Org, or Org-editable — chosen by the author.
- AI usage is **opt-in per user**: subscribing to a skill and exposing it to your AI are your choices, not the author's. Making a skill **Available to AI** pins a specific version for you.
- The AI applies skills two ways: **automatically**, when it decides a skill is relevant to your request, or **manually**, when you invoke one at the start of a turn.

## Creating a skill

**From the Agents page.** Go to **Agents → Skills** in the web app and create a skill with a name, a short description of when it should be used, and a Markdown body containing the procedure. The description matters: it's what the AI reads when deciding whether the skill applies to a request.

**From a conversation.** If a chat produced a workflow worth keeping, ask AI Chat to turn it into a skill. It drafts a name, description, and body, and — on your approval — opens the skill editor pre-filled with the draft. Nothing is saved until you click **Save**.

**From the SDK.**

```python
from roboto.domain.skills import Skill, SkillAccessibility

skill = Skill.create(
    name="qa-review",
    description="Run when the user asks for a QA review of a dataset.",
    body="1. Load the dataset summary...\n2. Check each topic for dropouts...",
    accessibility=SkillAccessibility.Org,
    tags=["qa-review", "triage"],
)
```

As the author, you are automatically subscribed to your new skill, and its first version is pinned as **Available to AI**.

## Accessibility tiers

When you create a skill, choose who can see and edit it (you can change this later):

- **Private** — only you can see and use it.
- **Org** — everyone in your organization can see, subscribe to, and use it; only you can edit it.
- **Org-editable** — everyone in your organization can use it, and any subscribed member can also edit its content and create new versions.

Changing a skill's accessibility and deleting the skill are author-only on every tier.

## Subscribing and making skills available to AI

Skills shared with your org appear in the **Org** tab of the Skills page. Subscribing adds a skill to your **Personal** tab and enables manual invocation. Subscribing alone does not let the AI use the skill automatically — that requires a second step: marking it **Available to AI**, which pins a specific version for your conversations.

Version pins don't move on their own. If the author publishes a new version, you stay on the version you pinned until you re-pin; the Skills page shows when a newer version is available.

From the SDK:

```python
from roboto.domain.skills import Skill

skill = Skill.from_name("qa-review")
skill.subscribe()          # adds to your Personal tab
skill.set_ai_version(2)    # expose version 2 to your AI
skill.set_ai_version(None) # stop AI auto-invocation, stay subscribed
```

## How the AI uses skills

**Automatic invocation.** On every turn, the AI sees the names and descriptions of the skills you've made **Available to AI**. When it decides one applies, it loads the skill's body and follows the procedure. A skill's full body is loaded only when the skill is used, so making many skills available adds only names and descriptions to each turn.

**Manual invocation.** From the chat composer, you can invoke any skill in your **Personal** tab directly, telling the AI to apply that procedure this turn. Manual invocation always runs the skill's latest version, regardless of which version (if any) you've pinned as **Available to AI**.

**Per-thread overrides (SDK).** When starting a thread programmatically, you can invoke skills up front with `invoke_skills`, or replace your subscription-derived skill set for the thread's lifetime with `available_skills`:

```python
from roboto.ai import AgentThread
from roboto.ai.agent_thread import AvailableSkillSpec, InvokeSkillSpec

# Apply a skill at the start of the thread
thread = AgentThread.start(
    "Review dataset ds_abc123",
    invoke_skills=[InvokeSkillSpec(skill_id="sk_abc123")],
)

# Or: make exactly this set auto-invocable for the whole thread,
# ignoring your subscriptions and AI-version pins
thread = AgentThread.start(
    "Review dataset ds_abc123",
    available_skills=[AvailableSkillSpec(skill_id="sk_abc123")],
)
```

## Versioning and deletion

Versions are editable in place: updating an existing version changes what everyone pinned to it sees on their next turn. Adding a new version moves nobody — every subscriber's pin stays put until they re-pin. Deleting an individual version clears the AI pin of anyone pinned to it, but their subscription survives. Deleting a skill's last remaining version deletes the skill itself.

Deleting a skill removes it permanently for everyone, including all versions and subscriptions. Conversations that already loaded the skill keep the text they captured at the time.

## Related pages

- [Agents and Threads](/docs/learn/ai/agents) — where skills are applied.
- [Goals](/docs/learn/ai/goals) — structured outcomes, complementary to skills: a skill shapes *how* the AI works; a goal makes an outcome *required*.