# OpenMAIC Agent Workbench Built-in Skills: Complete Catalog and Developer Guide

> Explore the OpenMAIC Agent Workbench's 22 built-in skills for workshop training and vocational development. Discover how to use and extend these skills with our comprehensive guide.

- Repository: [MAIC/OpenMAIC](https://github.com/THU-MAIC/OpenMAIC)
- Tags: developer-guide
- Published: 2026-08-31

---

**The OpenMAIC Agent Workbench provides 22 built-in skills—including workshop-style, vocational training, and stage-design—that are defined in `skills/agent-runtime/*/SKILL.md` files and registered at runtime via the Agent Skills Registry in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts).**

The **Agent Workbench** in the [THU-MAIC/OpenMAIC](https://github.com/THU-MAIC/OpenMAIC) repository ships with a comprehensive set of built-in skills designed to execute high-level teaching strategies. These skills range from interactive workshop methods to curriculum planning tools, each declared through markdown metadata and loaded dynamically into the workbench's skill registry.

## What Are Agent Workbench Built-in Skills?

Built-in skills are declarative teaching strategies that users invoke via the **"/" slash command** or the skill menu in the OpenMAIC interface. Each skill is defined by a [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) file located in the `skills/agent-runtime` directory, containing frontmatter with `name`, `title`, and `description` fields. At runtime, the workbench scans this directory, parses every [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) file, and registers the skill in the **Agent Skills Registry** with a `source` flag set to `'builtin'`. This architecture allows the system to distinguish between core platform capabilities and user-generated extensions while providing consistent UI labeling across locales.

## Built-in Skill Architecture

Understanding how OpenMAIC loads and renders skills requires examining three core components: the metadata files, the registry manager, and the UI helpers.

### Skill Metadata Files

Each built-in skill originates from a markdown file following the path `skills/agent-runtime/{skill-handle}/SKILL.md`. These files contain YAML frontmatter that declaratively describes the skill's purpose. For example, the `stage-design` skill is defined in [`skills/agent-runtime/stage-design/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/agent-runtime/stage-design/SKILL.md) with a human-readable title of "课堂设计" (Classroom Design).

### Agent Skills Registry

The registry logic resides in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts). When the workbench initializes, the `useAgentSkills()` hook triggers `loadAgentSkills()`, which executes a `fetch('/api/agent/skills')` request. The API aggregates all [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) files from the `skills/agent-runtime` folder and populates the internal `skillsCache`. The registry manages loading states, error handling, and owner-scoped invalidation through the `invalidateAgentSkills()` function.

### UI Rendering and Localization

Three helper functions in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) transform raw metadata into user-facing strings:

- **`skillTitle(skill)`**: Extracts the localized title from metadata.
- **`skillDisplayLabel(skill)`**: Formats the display as `title /handle`.
- **`skillLabelForId(id, skills)`**: Resolves a skill ID to its display label, used when parsing slash commands like `/stage-design`.

The Composer integration in [`lib/workbench/composer-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/composer-skills.ts) parses slash queries and maps them to registry entries, enabling real-time skill invocation during content creation.

## Complete Catalog of Built-in Skills

The OpenMAIC repository currently maintains **22 built-in skills**, each accessible via a unique handle. The following catalog reflects all [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) files present in the `skills/agent-runtime` directory:

### Pedagogical Strategy Skills

- **workshop-style** – 互动ワークショップ (Interactive Workshop): Hands-on sessions where learners act rather than watch.
- **vocational** – 职业实训 (Vocational Training): Technical training focused on real-world occupational tasks.
- **understanding-by-design** – 理解本位设计 (UbD): Backward-design framework prioritizing conceptual understanding.
- **teacher-style-clone** – 名师风格 (Master Teacher Style): Uses teacher video/lecture material to guide session flow.
- **lecture-style**: Systematic explanatory course delivery method.
- **feynman-learning**: Implements the Feynman technique for deep comprehension.
- **learning-to-learn**: Meta-learning skill set focused on learning methodologies.
- **social-emotional-learning**: SEL-focused instructional strategies.

### Content Creation and Design Skills

- **stage-design** – 课堂设计 (Classroom Design): Baseline method for building single classroom stages.
- **stage-dsl**: Domain-specific language for defining stage-level metadata.
- **slide-craft**: Generates slide content from structured prompts.
- **slide-dsl**: DSL for slide-type page definitions.
- **pptx-import**: Imports PowerPoint decks directly into a stage.
- **page-clone**: Clones existing page templates.
- **style-clone**: Clones visual/style templates from existing material.
- **pro-editing**: Advanced editing capabilities for already-persisted stages.

### Curriculum and Research Skills

- **curriculum-planner**: High-level curriculum planning and structuring.
- **spiral-curriculum**: Enables spiral curriculum planning methodologies.
- **k12-core-literacy-planning**: Specialized K-12 core literacy planning skill.
- **deep-research**: Conducts extensive research for content generation.
- **deep-interactive**: Interactive deep-dive skill for exploratory learning.
- **fact-check**: Validates factual claims within generated content.
- **build-personal-skill**: Generates personalized skills for individual users.

## How to Access and Use Built-in Skills in Code

Developers interact with built-in skills through the React hooks and utilities exported from the workbench library. The following patterns demonstrate filtering for built-in skills, resolving labels, and invalidating the registry cache.

### Listing Built-in Skills in a Component

```tsx
import { useAgentSkills, skillLabelForId } from '@/lib/workbench/agent-skills';

function SkillList() {
  const { skills, loading, error } = useAgentSkills();
  
  if (loading) return <div>Loading skills…</div>;
  if (error) return <div>{error}</div>;

  return (
    <ul>
      {skills
        .filter(s => s.source === 'builtin')
        .map(s => (
          <li key={s.id}>{skillLabelForId(s.id, skills)}</li>
        ))}
    </ul>
  );
}

```

### Resolving Slash Commands to UI Labels

```tsx
function labelForSlash(handle: string) {
  const { skills } = useAgentSkills();
  return skillLabelForId(handle, skills);
}

// Usage: labelForSlash('stage-design') returns "课堂设计 /stage-design"

```

### Invalidating the Skills Cache

When user authentication state changes or when new skills are deployed, force a registry refresh:

```typescript
import { invalidateAgentSkills } from '@/lib/workbench/agent-skills';

// Forces a refetch from '/api/agent/skills' and updates skillsCache
await invalidateAgentSkills();

```

## Summary

- **OpenMAIC Agent Workbench** includes 22 built-in skills stored as [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) files under `skills/agent-runtime`.
- The **Agent Skills Registry** ([`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts)) loads these at runtime via `useAgentSkills()` and flags them with `source: 'builtin'`.
- **UI helpers** like `skillLabelForId()` and `skillDisplayLabel()` format skill metadata for display, supporting localization.
- **Slash command parsing** in [`lib/workbench/composer-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/composer-skills.ts) maps user inputs like `/workshop-style` to registered skill metadata.
- Skills cover pedagogical strategies (workshop-style, UbD, vocational), content tools (stage-design, PPTX import), and curriculum planning (spiral-curriculum, deep-research).

## Frequently Asked Questions

### Where are built-in skill definitions stored in the OpenMAIC repository?

Built-in skill definitions reside in the `skills/agent-runtime` directory, with each skill occupying its own subdirectory containing a [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) file. For example, the stage-design skill is located at [`skills/agent-runtime/stage-design/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/agent-runtime/stage-design/SKILL.md). These markdown files contain YAML frontmatter specifying the skill's `name`, `title`, and `description`.

### How does the Agent Workbench distinguish built-in skills from custom skills?

The registry in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) assigns a `source` property to every loaded skill. Built-in skills receive `source: 'builtin'`, while user-created or dynamically generated skills receive different source flags (such as `'personal'`). This allows UI components to filter skill lists using `skills.filter(s => s.source === 'builtin')` to display only core platform capabilities.

### What function converts skill IDs to human-readable labels?

The `skillLabelForId(id, skills)` function in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) resolves a skill's unique handle (such as `vocational` or `slide-craft`) into a formatted display string. This utility respects locale-specific copy keys and combines the skill's title with its handle (e.g., "职业实训 /vocational") for clear UI presentation.

### How are slash commands like `/stage-design` parsed into skill invocations?

The Composer skills logic in [`lib/workbench/composer-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/composer-skills.ts) intercepts slash queries, extracts the skill handle (the text following `/`), and queries the Agent Skills Registry for a matching entry. Once found, the system maps the query parameters to the skill's execution context, enabling users to trigger complex teaching strategies directly from the chat input or command palette.