Skills

Define how your AI behaves with YAML skill files. Skills are behavioral definitions that control personality, tool access, triggers, and execution rules.

7 min read

Skills

Skills are the behavioral building blocks of Chvor. A skill is not code — it is a YAML definition that describes how the AI should behave in a given context. Think of skills as specialized personas your AI can adopt, each with its own personality, tool access, rules, and trigger conditions.

Skill Simulation

waiting

Type a message:

⚓ Planner

Decomposes complex tasks into ordered steps

⌘ Coder

Writes and executes code in sandboxed environments

≡ Summarizer

Condenses long content into key points

⌕ Researcher

Searches the web and aggregates information

What is a skill?

A skill defines:

When the AI should activate it (trigger patterns)
How the AI should behave (personality and rules)
What the AI can use (tool access)
Where results go (output format and channel routing)

Skills are composable. In Constellation mode, the AI picks the right skill for each query. In Pipeline mode, you chain skills together into deterministic workflows.

Bundled skills

Chvor ships with several built-in skills to get you started:

Planner

Breaks down complex tasks into structured steps. Useful as the first stage in a pipeline.

name: planner
description: "Breaks complex requests into actionable step-by-step plans"
trigger: "/plan *"
personality: |
  You are a methodical planner. Given a goal, you decompose it into
  concrete, ordered steps. Each step should be actionable and specific.
  Do not execute — only plan.
tools: []
rules:
  - Always number your steps
  - Each step must be independently verifiable
  - Flag dependencies between steps
  - Estimate time for each step when possible

Coder

Writes, reviews, and explains code. Has access to filesystem and code execution tools by default.

name: coder
description: "Writes, reviews, debugs, and explains code"
trigger: "/code *"
personality: |
  You are a senior software engineer. Write clean, well-documented code.
  Prefer simplicity over cleverness. Always consider error handling
  and edge cases.
tools:
  - filesystem
  - code_execution
rules:
  - Include comments for non-obvious logic
  - Handle errors explicitly, never silently swallow them
  - Use the language idioms appropriate to the ecosystem
  - When reviewing code, be specific and constructive

Researcher

Searches the web and synthesizes information from multiple sources.

name: researcher
description: "Searches the web and synthesizes findings"
trigger: "/research *"
personality: |
  You are a thorough researcher. Search multiple sources, cross-reference
  claims, and synthesize findings into clear summaries. Always cite
  your sources.
tools:
  - web_search
rules:
  - Search at least 2-3 sources before drawing conclusions
  - Always include source URLs
  - Distinguish between facts and opinions
  - Note when information might be outdated

YAML schema

Every skill is a YAML file with the following structure:

# Required fields
name: my-skill                    # Unique identifier (lowercase, hyphens)
description: "What this skill does" # Shown on the Brain Canvas node

# Trigger — when this skill activates
trigger: "/my-skill *"            # Pattern match (supports glob)
# OR
trigger:
  pattern: "/my-skill *"
  auto: true                      # Also activate via AI routing in Constellation mode

# Personality — the system prompt injected when this skill is active
personality: |
  You are a helpful assistant specialized in...

# Tools — which tools this skill can access
tools:
  - web_search
  - filesystem
  - code_execution
  - mcp:github                    # MCP server tools use the mcp: prefix

# Rules — hard constraints the AI must follow
rules:
  - Always respond in markdown
  - Never execute destructive commands without confirmation
  - Limit responses to 500 words unless asked for more

# Optional fields
model: anthropic:claude-sonnet-4-20250514   # Override the default model for this skill
temperature: 0.3                  # Override temperature
max_tokens: 4096                  # Override max tokens
output_format: markdown           # markdown | json | plain

Field reference

Field	Type	Required	Description
`name`	string	Yes	Unique skill identifier
`description`	string	Yes	Human-readable description
`trigger`	string or object	Yes	Activation pattern
`personality`	string	Yes	System prompt for this skill
`tools`	string[]	No	Tool IDs this skill can use
`rules`	string[]	No	Hard constraints
`model`	string	No	Override default LLM
`temperature`	number	No	Override temperature (0-1)
`max_tokens`	number	No	Override max output tokens
`output_format`	string	No	Response format hint

Where skills live

Skills are stored as YAML files in your Chvor data directory:

~/.chvor/
├── skills/
│   ├── planner.yaml          # Bundled skill
│   ├── coder.yaml            # Bundled skill
│   ├── researcher.yaml       # Bundled skill
│   ├── my-custom-skill.yaml  # Your custom skill
│   └── team-standup.yaml     # Your custom skill
├── db/
├── memory/
└── config.yaml

On Windows, the default path is %APPDATA%\chvor\skills\.

You can also configure a custom skills directory in your config.yaml:

skills_dir: /path/to/my/skills

Creating a custom skill

Create a new YAML file in your skills directory:

# ~/.chvor/skills/daily-digest.yaml
name: daily-digest
description: "Generates a daily summary of activity across all channels"
trigger: "/digest"
personality: |
  You are an executive assistant who creates concise daily digests.
  Summarize the key points from recent conversations, highlight
  action items, and flag anything that needs attention.
tools:
  - web_search
rules:
  - Keep the digest under 300 words
  - Group items by topic, not by time
  - Bold action items
  - End with a "Needs Attention" section if applicable
output_format: markdown

Save the file. Chvor picks it up automatically — no restart required.

Hot reload

Chvor watches the skills directory for changes. When you add, modify, or delete a skill file:

The server detects the filesystem change
The skill registry reloads
A WebSocket event notifies the client
The Brain Canvas updates — new nodes appear, removed nodes fade out, modified nodes flash briefly

This means you can iterate on skills in your editor and see changes reflected on the canvas instantly. If a YAML file has syntax errors, the server logs a warning and keeps the previous valid version loaded.

# Watch the server logs while editing skills
tail -f ~/.chvor/logs/server.log

# You'll see:
# [skills] Reloaded: daily-digest (modified)
# [skills] Loaded: new-skill (added)
# [skills] Removed: old-skill (deleted)
# [skills] Error in broken-skill.yaml: invalid YAML at line 12 (keeping previous version)

Constellation vs Pipeline execution

How skills execute depends on the canvas mode.

Constellation mode

The AI receives the full list of available skills and their descriptions. For each user message, the model selects the most appropriate skill (or combination of skills) based on:

The trigger pattern (explicit triggers like /plan always win)
The skill description and personality (semantic matching)
The conversation context (what was discussed recently)

User: "Can you research the latest trends in AI agents?"
→ AI selects: researcher (best semantic match)

User: "/code a Python function to parse CSV files"
→ AI selects: coder (explicit trigger match)

User: "Plan out a new feature, then write the code"
→ AI selects: planner → then coder (multi-skill chain)

Pipeline mode

Skills execute in the order you wired them on the canvas. The output of one skill becomes the input to the next. Each skill in the pipeline only has access to its own configured tools.

[Channel] → [Researcher] → [Planner] → [Coder] → [Channel]
     web_search      (none)     filesystem,
                                code_execution

Pipeline mode guarantees execution order and tool isolation, making it ideal for workflows that must be repeatable and auditable.

Advanced patterns

Conditional tools

You can make tool access conditional on the trigger:

name: assistant
description: "General-purpose assistant with context-dependent tools"
trigger:
  pattern: "*"
  auto: true
personality: |
  You are a helpful general-purpose assistant.
tools:
  - web_search
rules:
  - Only use web_search when the user explicitly asks for current information
  - For general knowledge questions, rely on your training data

Skill composition

In Constellation mode, you can design skills that explicitly hand off to other skills:

name: project-manager
description: "Coordinates multi-step projects by delegating to other skills"
trigger: "/project *"
personality: |
  You are a project manager. Break requests into phases and
  delegate each phase to the appropriate skill using their triggers.
  For research, use /research. For planning, use /plan.
  For coding, use /code. Coordinate the results.
tools: []
rules:
  - Always start with a research phase for unfamiliar topics
  - Create a plan before any coding
  - Summarize the overall result after all phases complete

Coming soon: Templates. Pre-built skill templates for common setups (research assistant, code reviewer, customer support) are on the way. For now, you can create skills from scratch using YAML — see the Custom Skills guide.

Next steps

Tools & MCP — learn about the tools you can assign to skills
Brain Canvas — see how skills appear and execute on the canvas
Directives — set persistent rules that apply across all skills