Skip to main content
Skills are reusable bundles of instructions, supporting files, and tool requirements that you can attach across Cotool workflows. Use them when you have guidance that should stay consistent across chats or agents, such as:
  • A standard investigation procedure
  • A reporting format or escalation template
  • A repeatable enrichment workflow
  • Reference material that belongs with one specific workflow
Instead of copying the same instructions into every system prompt, you can maintain them once and reuse them wherever needed.

​
What a Skill Includes

Each skill can contain:
  • Name: A short identifier used across your workspace
  • Description: What the skill does and when an agent should use it
  • Content: The main markdown instructions the agent will follow
  • Required tools: Tools the skill expects the agent to have
  • Resources: Optional supporting files such as runbooks, schemas, templates, or scripts

Reusable

Attach the same skill to multiple agents instead of duplicating instructions

Discoverable

Search, browse, and sort skills from a dedicated Skills library

Versioned

Track changes over time from the Versions tab

Portable

Import or export skills as standard skill folders or zip files

​
Organization, private, and managed skills

Cotool supports more than one kind of skill:
Private skills do not attach to agents. They stay user-scoped and only load into your own chats.
Cotool can also show managed skills that are read-only in the Skills page:
  • Built-in skills are generated from a connected integration and can link back to that integration.
  • System-generated skills are created by another product surface, such as Threat Model, and stay in sync from there.

​
When to Use a Skill

Skills are best for repeatable workflow logic that should travel with an agent.

​
Good use cases

  • “Triage Microsoft 365 login alerts”
  • “Write executive-ready incident summaries”
  • “Enrich IPs and domains before making a recommendation”
  • “Follow our standard offboarding checklist”

​
Better handled elsewhere

  • System prompt: The agent’s overall role, scope, and decision-making rules
  • Context documents: External reference material that is maintained in Google Docs or Notion

​
Creating a Skill

1

Open the Skills page

Navigate to Skills from the main sidebar.
2

Create a new skill

Click Create Skill and fill in:
  • Name: Lowercase letters, numbers, and hyphens
  • Description: A clear summary of when the skill should be used
  • Content: The actual procedure, instructions, examples, or output format
3

Add required tools

Select the tools the skill depends on.When someone attaches the skill to an agent that is missing one of those tools, Cotool shows a warning so the gap is visible before runtime.
4

Add supporting files

Upload optional reference files that belong with the skill, such as:
  • Runbooks
  • Lookup tables
  • Response templates
  • Schemas or sample payloads
5

Save and attach

Save the skill, then attach it to one or more agents from the agent builder.
Prefer to stay in chat? Use /create-skill to build a new skill through a guided conversation, or /update-skill to revise an existing one. See Slash Commands.

​
Writing Good Skill Content

The Content field is the heart of the skill. Write it like a focused operating procedure. Good structure:
Keep the core instructions concise. If you need long reference material, move that content into resource files instead of putting everything in the main skill body.

​
Importing Existing Skills

Cotool can import skills that follow the Agent Skills folder format. The importer accepts more than a single skill archive. You can point it at:
  • A single skill folder
  • A parent folder that contains multiple skills
  • A folder of plain markdown files that Cotool converts into starter skills
  • A .zip archive

​
Expected structure

​
What each folder is for

Only text-based files are supported for import. If a file type is not supported, Cotool will skip it and show you which files were ignored.
If you import plain markdown, Cotool creates starter skills from those files and lets you rename them and adjust their descriptions before the import finishes.

​
Managing Resources

On an individual skill page, the Resources tab lets you organize supporting files into:
  • References for documentation and lookup material
  • Assets for static templates or data files
  • Scripts for executable helpers
Scripts are marked as sandbox only, which makes them most relevant for agent workflows that run in sandbox mode.

​
Version History

Each editable skill has a Versions tab and a version picker so you can review how it has changed over time. This is useful when you want to:
  • Track prompt or procedure changes
  • Confirm what version was active during testing
  • Compare required tools or resource files across revisions
  • Safely iterate on a shared skill used by multiple agents
1

Open the version you want to inspect

Use the version picker to switch from Current/latest to an earlier version.
2

Review the historical snapshot

Historical versions open in read-only mode. The instructions, required tools, and resource files all reflect that point-in-time snapshot.
3

Restore when needed

If you want to bring an older version back, choose Restore. Cotool copies that snapshot forward as a new current version, while keeping the full history intact.
Built-in integration skills and other managed skills are read-only in the Skills page, so you inspect them there but edit them from their source surface instead.

​
Attaching Skills to Agents

You attach organization and built-in skills from the agent builder.
1

Open an agent

Go to Agents and open the agent you want to update.
2

Find the Skills section

In the editor, open the Skills panel below tool selection.
3

Attach one or more skills

Browse or search the available skills, then select the ones you want.
4

Resolve any tool warnings

If a skill requires tools the agent does not have, Cotool highlights the missing tools so you can grant access before saving.
5

Test in Builder

Run the agent with representative inputs to confirm the skill improves behavior the way you expect.
Agent setup guide -> See where skills fit in the full agent creation workflow
Managing agents as code? You can define a skill directly in your repo as a SKILL.md file (with its references/, assets/, and scripts/), synced from the skills path. Agents then reference it by name — the same as attaching one that already exists. See Response Agents as Code → Skills.

​
Skills vs Context Documents

These features complement each other, but they solve different problems:

​
Best Practices

A skill should solve one repeatable problem well. If it starts covering multiple unrelated jobs, split it into smaller skills.
The description should help humans and agents understand the trigger conditions for using the skill.
If the workflow depends on specific integrations, mark them as required so missing access is visible when the skill is attached.
Put large examples, tables, schemas, or templates into resource files instead of overloading the main instruction body.
After attaching or editing a skill, run the agent with realistic examples in Builder to confirm the instructions behave as intended.

​
Troubleshooting

Add the missing tools to the agent, or remove the tool dependency from the skill if it is no longer required.
Check that your folder or zip contains a valid SKILL.md file and only supported text-based files.
Keep the main content focused and move supporting material into references/, assets/, or separate skills.
Use the export action on the skill detail page to download the active version as a zip file.