Skills

What are Skills?

Skills are modular, composable capabilities that agents can use to perform specific tasks. Each skill encapsulates domain knowledge, tool bindings, and prompt instructions into a reusable package that can be attached to any agent.

Skills follow a declarative model: you define what the skill can do and the agent runtime handles how it gets executed. This separation allows skills to be shared across agents and teams without modification.

Skill Registry

The Skill Registry is a centralized catalog that manages skill discovery, versioning, and distribution. When you publish a skill, it becomes available to all agents in your organization.

The registry supports semantic versioning, so agents can pin to specific skill versions or follow a release channel. Skills are stored alongside their metadata, including required tools, permissions, and configuration schema.

# List available skills
riven skills list
 
# Install a skill from the registry
riven skills install code-review@latest
 
# Publish a custom skill
riven skills publish ./my-skill --version 1.0.0

Registry Listing

The following skills are currently available in the Riven skill registry:

Creating a Skill

Creating a custom skill involves defining a skill manifest and implementing the skill logic in TypeScript. The manifest declares the skill's metadata, required tools, and configuration options.

import { defineSkill } from "@riven/agent-sdk";
 
export default defineSkill({
  name: "lint-checker",
  description: "Runs linting checks on staged files and reports issues.",
  version: "1.0.0",
 
  tools: ["mcp://filesystem", "mcp://git"],
 
  async execute(context) {
    const files = await context.tools.git.getStagedFiles();
    const results = [];
 
    for (const file of files) {
      const content = await context.tools.fs.readFile(file.path);
      const issues = await context.analyze(content, {
        prompt: "Check this file for linting issues and style violations.",
      });
      results.push({ file: file.path, issues });
    }
 
    return context.report(results);
  },
});

Skill File Structure

A complete skill package follows this layout:

skills/lint-checker/
├── index.ts           # Skill entry point
├── manifest.yaml      # Metadata, tools, config schema
├── prompts/           # Prompt templates (optional)
│   └── review.md
├── tests/
│   └── lint-checker.test.ts
└── README.md

Skill Configuration

Each skill can define a configuration schema that agents use to customize behavior. Configuration is specified in the skill manifest using a YAML schema.

name: lint-checker
version: 1.0.0
description: Runs linting checks on staged files
 
tools:
  - mcp://filesystem
  - mcp://git
 
config:
  severity:
    type: string
    enum: [error, warning, info]
    default: warning
    description: Minimum severity level to report
  ignore_patterns:
    type: array
    items:
      type: string
    default: ["*.generated.*", "*.min.*"]
    description: File patterns to skip

Agents reference the configuration when attaching a skill:

skills:
  - name: lint-checker
    version: "1.0.0"
    config:
      severity: error
      ignore_patterns:
        - "*.generated.*"
        - "*.min.*"
        - "src/__generated__/**"

Built-in Skills

Riven ships with a set of production-ready built-in skills that cover common engineering workflows:

• code-review — Analyzes pull request diffs for bugs, security issues, and style violations. Leaves inline review comments.
• deploy — Manages Helm-based deployments to Kubernetes clusters with rollback support and health checks.
• monitor — Watches Prometheus metrics and Loki logs, detects anomalies, and generates incident summaries.
• test-runner — Executes test suites, identifies flaky tests, and reports coverage changes between commits.

Next Steps

• Memory — Learn how agents persist context across sessions.
• Tool Use — Connect agents to external systems via MCP.
• Agents Overview — Architecture and lifecycle of Riven Agents.