# Skills

Skills are installable packages that extend Sorin's capabilities. Each skill adds something Sorin can do: a new data feed runtime, an integration with a specific exchange or service, a domain-specific reasoning module, or a named tool the agent can invoke during a task.

If Trading Bots are Sorin's execution layer and Data Feeds are its ingestion layer, **Skills are the extensibility layer** — how you shape what Sorin knows how to do.

<figure><img src="/files/IbdemC8qWKtOv1lsiN4s" alt=""><figcaption></figcaption></figure>

### What a Skill Is

A skill is a self-contained package that describes a capability. At minimum, a skill includes:

* A **name** (e.g., `binance`, `fiat`, `crypto-market-rank`)
* A **package** identifier — the directory or module Sorin loads the skill from
* A **SKILL.md** file that describes what the skill does, when to use it, and how to invoke it

The SKILL.md's description is what Sorin reads to decide when a skill is relevant to a task. A skill without a SKILL.md description will install, but Sorin won't have guidance on when to use it — the directory will show "No description found in SKILL.md".

### Skill Scopes: System vs. User

Skills live in two scopes:

| Scope      | Source                                 | What It's For                                                        |
| ---------- | -------------------------------------- | -------------------------------------------------------------------- |
| **System** | Bundled with Sorin                     | Core, always-available capabilities shipped by the product.          |
| **User**   | Installed locally to `~/.sorin/skills` | Capabilities you've added yourself — downloaded, built, or authored. |

On a fresh install, you'll typically have a small set of system skills and no user skills. Adding your own skills is how you specialize Sorin for your workflows.

#### Conflict Resolution

If a system skill and a user skill share the same name, **the user skill wins**. This lets you override or customize bundled behavior without editing system packages directly. Sorin will always prefer `~/.sorin/skills/<name>` over the system version when both exist.

### The Skills Directory

The Skills view — under **Customize → Skills** — lists every installed skill with:

* An **icon** indicating scope (system or user)
* The skill **name**
* Its SKILL.md **description**
* The **package** path Sorin loaded the skill from
* A **delete** action for user skills

The header shows totals: how many skills are installed, how many are system, and how many are user.

<figure><img src="/files/f3J23xjVu1KCNlvDjfJx" alt=""><figcaption></figcaption></figure>

#### Filtering and Searching

You can filter installed skills by:

* **Scope** — show all, only System, or only User
* **Free-text search** — match against name, description, or package path

Filtering is useful when you have a lot of skills installed and want to quickly find, for example, all Binance-related skills or anything mentioning tokenized securities.

### Importing a Local Skill

Click **+ Import Local** to add a skill from your local filesystem.

You'll point Sorin at a directory containing the skill package. Sorin verifies:

1. A **SKILL.md** exists and is readable
2. The package structure matches expectations
3. No existing user skill with the same name would be silently overwritten (Sorin will prompt before overwriting)

Once imported, the skill appears in the User list and becomes available to Sorin immediately.

{% hint style="info" %} **Imports are local.** "Import Local" loads a skill from a directory on your machine. It does not upload your skill to any shared catalog or to other users. {% endhint %}

### What Skills Can Do

Skills are a general extensibility mechanism. Some common patterns:

#### Exchange and Service Integrations

Skills that wrap a specific venue's API so Sorin can call it by name.

**Example: `binance`** *"Use binance-cli for Binance Spot, Futures (USD-S), and Convert. Requires auth."*

When installed, Sorin can use Binance as a runtime for data feeds, as an execution route for Trading Bots, and as a callable tool during conversational tasks.

#### Domain-Specific Queries

Skills that encode specialized knowledge or data access.

**Example: `fiat`** *"Query Binance fiat payment capabilities — supported countries, currencies, payment methods, limits, and crypto on/off-ramps."*

Instead of Sorin having to reason through raw API documentation every time, a well-designed skill exposes a clean interface for a specific kind of question.

#### Market-Data Runtimes

Skills that act as runtimes for Data Feeds.

**Example: `crypto-market-rank`**

A skill like this can back a Market-type data feed, supplying ranked market data that reactions can then act on.

#### Information Modules

Skills that bundle reference information — supported securities, instrument definitions, protocol metadata — so Sorin has consistent, versioned answers rather than reaching for ad-hoc searches.

**Example: `binance-tokenized-securities-info`**

### How Sorin Uses Skills

Skills aren't invoked manually. During a task, Sorin reads each relevant SKILL.md's description and decides which skills apply.

Skills interact with the rest of Sorin in three main ways:

| Surface                  | How Skills Plug In                                                                              |
| ------------------------ | ----------------------------------------------------------------------------------------------- |
| **Conversational tasks** | Sorin invokes a skill during a chat when it needs the capability the skill provides.            |
| **Data Feeds**           | Some skills supply runtimes that back specific data feed kinds.                                 |
| **Trading Bots**         | Skills can expose execution routes or venue integrations that bots then use under their policy. |

This means installing a skill can unlock new feed runtimes, new bot execution routes, and new in-conversation capabilities simultaneously — depending on what the skill provides.

### Skill Quality and SKILL.md

A skill's usefulness is capped by the quality of its SKILL.md description. A good description:

* **Names the capability clearly** — "Query Binance fiat payment capabilities" is better than "Binance tool"
* **States the scope** — what it covers and what it doesn't
* **Notes preconditions** — auth required, keys needed, regional limits
* **Gives an example call or use case** where helpful

Skills showing "No description found in SKILL.md" will still install, but Sorin is less likely to invoke them correctly. If you author skills, invest in the SKILL.md file — it's how Sorin decides when to reach for the skill in the first place.

### Managing Skills

From the Skills directory you can:

* **Delete** a user skill — removes it from `~/.sorin/skills` and the catalog
* **Inspect** a skill — click into it to see its full SKILL.md and package contents
* **Re-import** — run Import Local again to update a skill with new local changes

System skills can't be deleted from the UI; they're part of the Sorin install.

### Example: A Trading-Focused Setup

A user set up for active crypto trading might install:

| Skill                  | Purpose                                         |
| ---------------------- | ----------------------------------------------- |
| `binance`              | Spot, futures, and convert execution on Binance |
| `fiat`                 | Reference for fiat on/off-ramp routing          |
| `crypto-market-rank`   | Market-ranking runtime for feeds                |
| `onchain-pay-open-api` | On-chain payment API integration                |
| `meme-rush`            | Specialized narrative-tracking module           |

With these installed, Sorin can run Binance-backed data feeds, route execution through Binance under a Trading Bot's policy, and invoke each skill during conversational tasks — all without the user having to tell Sorin which tool to use.

### Authoring Your Own Skills

If a skill you want doesn't exist, you can author your own. The key pieces:

1. A directory that becomes the skill's package
2. A **SKILL.md** at the root describing name, scope, preconditions, and usage
3. The code or configuration the skill provides

Once ready, place it under `~/.sorin/skills/<your-skill-name>` or use **Import Local** to load it from elsewhere on your machine.

Skill authoring specifics — conventions, APIs, file layouts — are covered in the separate skill authoring guide.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.saharaai.com/sorin/core-features/skills.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.