---
title: Skills | Letta Docs
description: Create and use reusable skills to extend your agent's capabilities
---

Skills are **knowledge** your agent loads into memory (like a reference guide). For delegating **work** to separate agents, see [subagents](/letta-code/subagents/index.md).

Letta Code implements the open [Agent Skills](https://agentskills.io) standard. Skills are portable across Cursor, Claude Code, VS Code, and other compatible agents.

Skills are directories containing instructions and resources that your agent can load when relevant. Think of them as reference guides your agent consults for specialized tasks—API patterns, testing workflows, deployment procedures.

Unlike [memory](/letta-code/memory/index.md) (which persists in the agent’s context), skills are loaded on-demand by the agent using a tool call. Your agent sees what skills are available and pulls in the full content only when working on a relevant task.

## Installing new skills

The easiest way to install a skill is to simply **ask your agent to install it**. For example, to install the [frontend design](https://github.com/anthropics/claude-code/tree/main/plugins/frontend-design/skills/frontend-design) skill from Anthropic’s example skills repo (which teaches your agent how to build pretty websites), you can simply ask Letta Code:

```
> Can you install the following skill? https://github.com/anthropics/claude-code/tree/main/plugins/frontend-design/skills/frontend-design
```

You can also install skills from the Letta Code desktop app:

1. Open the **Skills** page.
2. Click **Add skill**.
3. Choose **Import from GitHub**.
4. Paste a GitHub URL that points to a skill directory containing `SKILL.md`.
5. Click **Import**.

The desktop app validates the URL, clones the repository, verifies the skill, and installs it globally on your machine. You can then attach that skill to an agent from the Skills page.

To install directly into an agent’s MemFS from the CLI, use:

Terminal window

```
letta install <skill-source> --agent <agent-id>
letta skills list --agent <agent-id>
letta skills delete <skill-name> --agent <agent-id>
```

`<skill-source>` can be a GitHub skill directory, a Hermes-style `official/...` skill, or a ClawHub `clawhub/...` or `clawhub:<slug>` skill.

You can also manually install skills by copying the folder to one of the supported skills folders that Letta Code reads from (see below).

### Where can I find new skills?

Start by browsing (or ask your agent to browse) the [Letta](https://github.com/letta-ai/skills) and [Anthropic](https://github.com/anthropics/skills/tree/main/skills) skills repos. A few recommend skills include:

- [Letta API client](https://github.com/letta-ai/skills/tree/main/letta/letta-api-client): become an expert at building apps on the Letta API
- [Frontend design](https://github.com/anthropics/skills/tree/main/skills/frontend-design): build beautiful websites with consistent styles
- [Slack GIF creator](https://github.com/anthropics/skills/tree/main/skills/slack-gif-creator): teach your agent to build Slack GIFs
- [PDF skill](https://github.com/anthropics/skills/tree/main/skills/pdf): tools for parsing PDF documents
- [Powerpoint (.pptx) skill](https://github.com/anthropics/skills/tree/main/skills/pptx): tools for editing .pptx files
- [Excel (.xlsx) skill](https://github.com/anthropics/skills/tree/main/skills/xlsx): tools for editing Excel files
- [Remotion skill](https://github.com/remotion-dev/skills/tree/main/skills/remotion): teach your agent how to make product videos using the Remotion React video editor

Only download skills from trusted sources. Skills can contain malware and dangerous prompts that trick your agent into leaking your data.

## Invoking skills directly

Letta Code automatically decides when to load a relevant skill, but you can also invoke one explicitly from the prompt with slash syntax:

Terminal window

```
/<skill-name> [optional instructions]
```

For example:

Terminal window

```
/acquiring-skills find and install a skill for browser testing
```

Direct invocation is useful when you already know which skill should guide the work. Letta Code loads the skill’s instructions into the conversation, then continues with the rest of your request.

Use `/skills` to browse available skills by source before invoking one by name.

## Creating new skills

You may want to create new skills to capture important reusable behaviors. For example, while working on your project, there may be certain sequences of actions taken by developers (e.g. a database migration) that is best represented to the agent as a *skill* to be used by many agents, rather than a memory.

Letta Code agents have a built-in “skill creator” skill, so you can simply prompt your agent to create a new skill:

```
> Can we turn the database migration we just did into a project-scoped skill?
```

For creating skills by hand, refer to the official [Agent Skills](https://agentskills.io) documentation.

Letta Code also ships a built-in `letta-help` skill. The Tutor personality uses it for guided onboarding, and you can invoke it directly when you want a walkthrough of memory, delegation, tools, skills, search, subagents, or schedules:

Terminal window

```
/letta-help help me get started
```

## Skill scopes

Each skill is a directory containing a `SKILL.md` file. Letta Code automatically registers skills from multiple locations:

| Location                              | Scope                      | Description                                                                                                 |
| ------------------------------------- | -------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `.agents/skills/`                     | Project-scoped (preferred) | Primary project-local location for interactive client-side skills                                           |
| `.skills/`                            | Project-scoped (legacy)    | Older project-local location, still supported as a fallback                                                 |
| `~/.letta/agents/{id}/memory/skills/` | Agent-scoped MemFS         | Persistent skills specific to one Letta Code agent, stored inside that agent’s git-backed memory filesystem |
| `~/.letta/skills/`                    | Global                     | Skills shared across all Letta Code agents running on this machine                                          |
| (bundled with Letta Code)             | Built-in                   | Skills that ship with Letta Code (always available to any Letta Code agent)                                 |

For MemFS-enabled agents, the agent-scoped skills directory is also available as `$MEMORY_DIR/skills` in shell tools. For example, if `MEMORY_DIR=/Users/me/.letta/agents/agent-123/memory`, then that agent’s persistent custom skills live under `/Users/me/.letta/agents/agent-123/memory/skills`.

## How skills are discovered

When you start Letta Code, it scans all skill directories and makes available skills visible to the agent via system reminder messages in the conversation. Skills with conflicting (same) names are resolved by priority - project skills override agent-scoped MemFS skills, which override global skills, which override bundled skills.

For new project-local skills, prefer `.agents/skills/`. If you already have project skills in `.skills/`, Letta Code still loads them as a legacy fallback.