---
title: "Skills"
description: "Reusable code packages that give your assistant new capabilities — from API integration to file generation."
canonical_url: "https://meingpt.com/en/docs/platform/skills"
language: en
---

# Skills

## What it is

Skills are **reusable code packages** (`.zip` files) that give your assistant capabilities beyond pure prompting or knowledge binding. They run in the **Code Sandbox** and can call external APIs, generate files, process data, or apply specialized logic.

Skills only run in the context of an assistant and require the Code Sandbox. In the assistant editor they're a standalone section, right below [Knowledge](/en/docs/platform/assistants) — not part of the [Tools](/en/docs/platform/assistants) section, even though the two work together.

## When does a skill make sense?

Skills are the right tool when your assistant needs to:

- **call an API** for which meinGPT has no native connector (e.g. your internal contract management system)
- **generate a file** in your layout (Word template, Excel report in your format, PowerPoint deck with branding)
- **process data** in a format the LLM doesn't handle natively (e.g. parsing binary data, complex table transformations)
- **apply deterministic logic** (calculations, validation, business rules)

If your need is solved by a system prompt + RAG datapool + native tools (Connectors) — no skill needed. Skills are the next escalation step for **your own executable logic**.

The assistant only gets a compact list of available skills (name/ID) in its system context, not their full instructions. Only once it decides a skill fits the current task and mounts it does it read that skill's SKILL.md and its files.

## Skill vs Tool vs Connector — quick distinction

| Tool | What it is | When |
|---|---|---|
| **Native Tool / Connector** (Connectors) | Pre-built integrations to standard services (Slack, Outlook, Salesforce, ...) | Standard integrations available in the marketplace |
| **Skill** (`.zip` package) | Your own code (Python or JavaScript/TypeScript), running in the sandbox | Custom logic, proprietary APIs, file generation in your format |
| **Knowledge / Datapools** | RAG over static documents | When the assistant should know your knowledge, not execute it |

Skills are only available when the Code Sandbox is enabled for the organization (default: on). If the Skills section is missing from the editor, check with an admin whether the sandbox was disabled for your organization.

## How to create a skill

The Skills section sits in the assistant editor as its own card, with a **Create skill** button top right and a drag-and-drop area below it.

![Skills section in the assistant editor](/images/skills/skills-editor-section-en.png)

There are two paths to it:

### Path 1: have the assistant create it via chat

Clicking **Create skill** doesn't open a special assistant or wizard — it's an entirely ordinary new chat with your assistant, just with a pre-filled first message: *"Create me a new skill for this assistant."*

![The "Create skill" button in the Skills section](/images/skills/skills-create-chat-1-en.png)

**Send the message**: the pre-filled message is already in the input field — just send it.

**Answer the follow-up questions**: the assistant is instructed to interview you before writing any code — typically about the skill's purpose, required external APIs, credentials, and whether an existing file (e.g. a Word template) should be used as a base.

**Code gets generated**: the assistant writes the skill package's files (at least one `SKILL.md`, see [Skill package structure](#skill-package-structure)) and bundles them into a `.zip`.

**Attached automatically**: the finished package shows up directly in the assistant's Skills list — no manual upload step needed.

![The assistant's follow-up questions after sending the pre-filled message](/images/skills/skills-create-chat-2-en.png)

If the skill needs credentials (API keys, tokens), the assistant creates a `secrets.json` with placeholder values for it. Fill in the real values afterward via the [file explorer](#editing-limits-and-what-doesnt-work-yet) — they're never asked for or logged in the chat.

### Path 2: upload a finished `.zip`

If you (or a colleague) already have the skill packaged, drag the `.zip` file directly into the drag-and-drop area in the Skills section, or click it to pick the file from a dialog.

![Drag-and-drop upload of a finished .zip package](/images/skills/skills-upload-dropzone-en.png)

- **Limits**: up to 20 files at once, a practical size limit of **50 MB per file**.
- **When a limit is exceeded**: if a `.zip` file exceeds 50 MB, or the assistant already has 20 skill packages, the platform rejects the upload with an error — it does not silently truncate or partially accept an oversized package.
- **No structure validation**: the platform only checks the file for technical safety (no zip bomb — a file that explodes on extraction). Whether a `SKILL.md` is included, or whether the package is structured sensibly at all, is **not** validated. Follow the recommended structure below, or the assistant won't be able to make sense of the skill.

### Skill package structure

A skill package is, at its core, a `.zip` with a `SKILL.md` as instructions for the assistant, plus the actual code. Recommended structure:

```
my-skill/
├── SKILL.md
├── scripts/
│   ├── main.py
│   └── helpers.py
└── references/
    └── api-reference.md
```

**`SKILL.md`** starts with a YAML frontmatter block, followed by free-form Markdown:

| Field / section | Purpose |
|---|---|
| `name` (frontmatter) | Short, descriptive name (lowercase, hyphenated) |
| `description` (frontmatter) | When the assistant should use this skill — this is the text the model relies on |
| `license` (frontmatter, optional) | Usually `Proprietary` or `MIT` |
| Title (H1) | One-sentence summary |
| `## Rules` | What the assistant should and shouldn't do |
| `## Workflow` | Step-by-step process |
| `## Good fits` | Concrete use cases the skill is meant for |
| `## Avoid by default` | What the skill is **not** meant for |

If `SKILL.md` gets too long (rule of thumb: 500 lines), move detail into `references/` and link to it from `SKILL.md`.

The actual language (Python or JavaScript) isn't fixed in the package — it's auto-detected the moment the assistant mounts the skill in a chat session, based on file markers like `requirements.txt` (Python) or `package.json` (JavaScript). If there's no clear marker, it defaults to JavaScript. So for a Python-only skill, make sure to include a `requirements.txt`, even an empty one.

## Security & sandbox

Skills run in the **isolated sandbox environment**:

- No direct host system access; the skill code itself (Python/JS at runtime) has no internet access. One exception: if the skill package includes a `package.json` or `requirements.txt`, the sandbox automatically fetches the listed additional packages through an internal registry proxy when the skill is mounted - see [Limits](/en/docs/platform/code-sandbox#limits) for known constraints of this install step.
- Language per skill is auto-detected when it's mounted into the session (Python or JS)
- Credentials (API keys, tokens) live as `secrets.json` inside the skill package and aren't exposed to the model itself
- Resource limits prevent infinite loops or excessive memory usage

The sandbox architecture is described in [Code Sandbox](/en/docs/platform/code-sandbox).

## Common uses in mid-sized companies

| Use case | Skill content |
|---|---|
| Generate quotes in company layout | Word template + Python script that fills data from the chat |
| DATEV export from invoice data | JS script that converts JSON data to CSV format |
| Integration with internal CRM (no standard connector) | Python API client that speaks to your CRM |
| Structured PDF extraction for your own layout | Python with `pdfplumber` for given contract structures |
| Custom validation (e.g. tax calculations) | JS with your calculation logic |

**Formatting fidelity isn't guaranteed.** A skill fills a Word template's content and carries over the template's existing styles – exact adherence to your brand guidelines (font sizes, spacing, colors, headers/footers) isn't automatically checked. For brand-critical templates, spot-check the generated document before sending it, and refine the skill code's instructions if you spot deviations.

## Editing, limits, and what doesn't work (yet)

Clicking a skill in the list opens the file explorer: file tree on the left (`SKILL.md` always sorted to the top), syntax-highlighted code editor on the right. You can view files, edit them, delete them, and save changes back to the package.

![Skill file explorer](/images/skills/skills-file-explorer-en.png)

**No version history**: saving permanently overwrites the package's previous state — there's currently no way to go back to an earlier version. Keep your own copy outside meinGPT before making larger changes.

**No sharing between assistants**: each skill belongs to exactly one assistant — there's neither a download/export button nor an "attach to another assistant" feature. To run the same skill on multiple assistants, upload the locally kept `.zip` to each assistant individually.

If you ask the assistant in chat to "improve" or "extend" an **existing** skill, it often creates an entirely new package instead of updating the existing one. Check the Skills list afterward and remove outdated duplicates manually.

## Where to go next

- **[Editor → Tools](/en/docs/platform/assistants)** — the Tools section that Skills works alongside
- **[Code Sandbox](/en/docs/platform/code-sandbox)** — how the execution environment looks in detail
- **[Assistants overview](/en/docs/platform/assistants)** — the full assistant workflow that skills plug into