Managing Capabilities
Capabilities extend what agents can do. This guide covers how to manage them — from understanding automatic resolution to writing your own.
How capability resolution works
When an agent plans a task, Exponential automatically detects which capabilities are needed and resolves them. You don't have to manually assign capabilities to tasks.
The resolution order
- Certified capabilities — checked first. These are verified by the Exponential team and auto-resolve without confirmation.
- Local capabilities — checked second. Capabilities you've created and stored on your machine.
- Community capabilities — checked last. Shared by other users; require your confirmation before use.
The first match wins. If a certified capability covers the need, local and community capabilities for the same skill are skipped.
What resolution looks like
When an agent submits a plan, you'll see a Resolved Capabilities card showing which capabilities were detected:
Each capability shows:
- Name and description
- Trust tier — certified, local, or community
- Source — where it comes from
For community capabilities, you'll see a confirmation prompt before the agent can use them.
Installing community capabilities
Community capabilities are discovered through the capability browser:
- Go to Capabilities in the sidebar.
- Browse available community capabilities.
- Click Install on the capability you want.
- The capability is downloaded to your machine and available for future resolution.
Installed community capabilities still show a confirmation prompt the first time an agent uses them on a task — this is a trust check, not a bug.
Writing your own capabilities
Basic structure
Create a SKILL.md file (the on-disk filename stays SKILL.md for runtime compatibility):
---
name: Database Migration
description: Creates and runs database migrations safely
tools: [bash, read, write]
tags: [database, migration, sql]
---
## Overview
This capability handles database schema migrations using our project's migration tool.
## Steps
1. Read the current schema from `prisma/schema.prisma`
2. Understand the requested change
3. Create a new migration file using `npx prisma migrate dev --name <description>`
4. Verify the migration SQL is correct
5. Run the migration against the development database
6. Update any affected TypeScript types
## Rules
- Never modify existing migration files — always create new ones
- Always back up the database before destructive migrations (DROP, ALTER)
- Test migrations on a local database first
- Include both up and down migrations when possible
## Examples
### Adding a new column
When asked to add a field to a model:
1. Add the field to `schema.prisma`
2. Run `npx prisma migrate dev --name add_<field>_to_<model>`
3. Update any queries that should include the new field
4. Update TypeScript interfaces if they existWhere to save it
| Location | Scope |
|---|---|
~/.claude/skills/my-capability/SKILL.md | Available in all spaces |
your-project/.claude/skills/my-capability/SKILL.md | Available only in that project |
Note: Each capability lives in its own directory. The directory name is the capability's identifier.
Frontmatter fields
| Field | Type | Description |
|---|---|---|
name | string | Display name |
description | string | One-sentence summary |
tools | string[] | Tools the capability needs: bash, read, write, edit, glob, grep |
tags | string[] | Lowercase kebab-case tags |
category | string | certified, community, or omit for local |
author | string | Your name or handle |
Writing effective capability content
Be procedural. Capabilities are instructions, not descriptions. Write steps the agent should follow.
Be specific. "Run the migration tool" is vague. "Run npx prisma migrate dev --name <description>" is actionable.
Include rules. What should the agent always do? What should it never do? Rules prevent mistakes.
Include examples. Show concrete scenarios with expected inputs and outputs. Agents learn from examples.
Minimum length: Capability content should be at least 100 words. If your capability is shorter than that, it's probably not detailed enough to be useful.
MCP servers
For capabilities that need external tools beyond file operations, you can connect MCP (Model Context Protocol) servers. MCP servers give agents access to external tools and APIs.
Common MCP server use cases:
- GitHub API — create PRs, read issues, manage repositories
- Database access — query production data, run migrations
- External services — Slack, Linear, Notion, etc.
MCP server configuration is managed at the system level. See the MCP Tools reference for details on the built-in tools available to all agents.
Tips
- Start simple — write a capability for one specific workflow, not a general-purpose Swiss Army knife.
- Test with real tasks — create a task that would need the capability and see if the agent resolves and uses it correctly.
- Iterate on rules — if agents misuse the capability, add more specific rules and constraints.
- Keep examples current — outdated examples lead to outdated output.