Agent Skills

Agent Skills are portable packages that give your agent specialized abilities — from generating images and analyzing data to interacting with third-party APIs. Each skill follows the open Agent Skills standard and includes a SKILL.md manifest that describes what the skill does, when to use it, and how to invoke it.

Errand supports two ways to provide skills to the agent: built-in skills that you create directly in the UI, and Git repository skills that are synced from a shared repository.

How Skills Work

When a task runs, Errand injects the selected skills into the agent’s working environment at /workspace/skills/. The agent receives a manifest listing all available skills and is instructed to read a skill’s SKILL.md before using it. Each skill directory can contain:

• SKILL.md — The manifest with frontmatter (name, description) and full instructions.
• scripts/ — Executable scripts the agent can run (Python, Node, shell, etc.).
• references/ — Reference materials the agent can read for context.
• assets/ — Static files the skill needs (templates, images, data files).
• requirements.txt — Python package dependencies (installed automatically).
• package.json — Node package dependencies (installed automatically).

Built-In Skills

Built-in skills are created and managed directly in the Errand UI. This is the simplest way to get started.

To create a skill:

1. Go to Settings > Agent Configuration.
2. Scroll to the Skills section and click Add Skill.
3. Enter a name and description for the skill.
4. Write the skill instructions in the Instructions field (this becomes the body of SKILL.md).
5. Optionally attach files — for example, a Python script at scripts/generate.py or a requirements.txt for dependencies.
6. Click Save.

Built-in skills are stored in Errand’s database and are available immediately. You can edit or remove them at any time from the Settings page.

Example: A Simple Web Research Skill

A basic skill might not need any dependencies at all. Here is an example of a skill that instructs the agent to perform structured web research:

Name: web-research Description: Perform structured web research with source citations Instructions:

## Web Research

When asked to research a topic:

1. Use the `web_search` tool to find relevant sources.
2. Read the top 3-5 results using `read_url`.
3. Synthesize the findings into a clear summary.
4. Include source URLs as citations.

Always verify claims across multiple sources before including them.

This skill has no scripts or dependencies — it simply provides instructions that guide the agent’s behavior.

Git Repository Skills

For teams that maintain a shared library of skills, Errand can sync skills from a Git repository. This keeps all your agents up to date with the latest skill definitions and makes it easy to version-control your skills alongside your other code.

To configure a skills repository:

1. Go to Settings > Agent Configuration.
2. In the Skills Repository section, enter the Repository URL in SSH format (for example, git@github.com:your-org/agent-skills.git).
3. Set the Branch to pull from (for example, main).
4. Specify the Skills Path — the folder within the repository where your skill directories live (for example, skills/).
5. Click Save.

Errand pulls the repository at task execution time, parses each skill directory, and makes them available to the agent. If a built-in skill and a Git skill have the same name, the built-in skill takes priority.

Repository Structure

A typical skills repository looks like this:

agent-skills/
  skills/
    web-research/
      SKILL.md
    image-generator/
      SKILL.md
      requirements.txt
      scripts/
        generate.py
        batch_generate.py
      references/
        prompts.md
    data-analyzer/
      SKILL.md
      package.json
      scripts/
        analyze.js

Each subdirectory under the skills path is treated as a separate skill. The directory name becomes the skill name if no name field is specified in the SKILL.md frontmatter.

For a curated collection of ready-to-use skills, see the Agent Skills community repository.

Skill Dependencies

Many skills include scripts that require Python or Node packages not already present in the agent runtime environment. For example, an image generation skill might use the google-genai and pillow Python packages, or a data processing skill might rely on the lodash Node library.

Errand handles this automatically. When a skill includes a requirements.txt or package.json file in its root directory, the agent runtime installs the declared dependencies at startup — before the agent begins executing the task.

Python Dependencies

To declare Python dependencies, add a requirements.txt file to the skill’s root directory. This file uses standard pip requirements format:

requirements.txt

google-genai
pillow

When the agent runtime starts and finds this file, it installs the packages before handing control to the agent. The agent can then import and use them normally:

scripts/generate.py

from google import genai
from PIL import Image

client = genai.Client()
response = client.models.generate_images(
    model="gemini-3-pro-image-preview",
    prompt="a friendly robot mascot",
)

Node Dependencies

To declare Node dependencies, add a package.json file to the skill’s root directory:

{
  "dependencies": {
    "lodash": "^4.17.21",
    "csv-parse": "^5.5.0"
  }
}

The runtime installs these packages and makes them available via NODE_PATH, so the agent’s scripts can require them directly:

scripts/analyze.js

const _ = require('lodash');
const { parse } = require('csv-parse/sync');

// Process data...

Multiple Skills with Dependencies

If several skills declare dependencies, they are all installed together. Python dependencies from multiple requirements.txt files are installed into the same target directory. Node dependencies from multiple package.json files are merged into a single manifest before installation.

Note

Dependency installation adds a small amount of time to task startup (typically 10-30 seconds depending on the packages). Tasks that do not use skills with dependencies are unaffected — the startup check is a fast no-op. You can use Task Profiles to control which skills are available for different types of tasks, keeping lightweight profiles fast.

Security Model

Errand takes a deliberate approach to dependency security. Package managers (pip, npm) are used during the startup phase to install declared dependencies, and are then completely removed before the agent gains control. This means:

• The agent cannot install additional packages at runtime.
• Only dependencies explicitly declared in a skill’s requirements.txt or package.json are installed.
• You control what gets installed by choosing which skills to make available.

This design keeps the agent runtime minimal and secure while still supporting skills that need additional libraries.

Dependency Trust

When you add a skill — whether built-in or from a Git repository — you are trusting its declared dependencies. Review a skill’s requirements.txt or package.json before making it available, just as you would review any third-party code before running it.

Limitations

• System-level packages (installed via apt or apk) are not supported. Skills must use Python wheels or pre-built Node packages that do not require system libraries beyond what the runtime image provides. Most popular packages (including Pillow, numpy, and pandas) ship self-contained wheels that work out of the box.
• Version conflicts between skills are resolved by the package manager. If two skills declare conflicting versions of the same package, only one version will be installed. Use Task Profiles to isolate conflicting skills into separate profiles if needed.

Controlling Skill Access with Profiles

Not every task needs every skill. Task Profiles let you choose which skills are available for different types of work. For example:

• A Creative profile might include an image generation skill with heavyweight dependencies.
• A Quick Reply profile might exclude all skills for the fastest possible startup.
• A Research profile might include web research and data analysis skills but not image generation.

This keeps task startup fast for simple work while still supporting complex skills when you need them.

The SKILL.md Format

Every skill must include a SKILL.md file. This file uses YAML frontmatter followed by Markdown instructions:

---
name: image-generator
description: Generate images using Google Gemini
---

## Image Generation

Generate images from text descriptions using Google's Gemini model.

### Prerequisites

- `GEMINI_API_KEY` environment variable must be set.

### Usage

Generate an image:
```bash
python3 <skill_dir>/scripts/generate.py "a sunset over mountains" -o sunset.png

The `name` and `description` fields appear in the agent's skill manifest. The body contains the full instructions
that the agent reads when it decides to use the skill.

For the complete specification and more examples, visit [agentskills.io](https://agentskills.io).