# What Are the Built-In Skills in OpenMAIC? A Complete Guide to Agent Capabilities

> Explore 23 built-in agent skills in OpenMAIC. This guide details agent capabilities and their functionality accessible via the slash-menu interface.

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

---

**OpenMAIC provides 23 built-in agent-runtime skills** housed in `skills/agent-runtime/` that automatically register on startup and expose functionality through the `/` slash-menu interface.

OpenMAIC (THU-MAIC/OpenMAIC) ships with a comprehensive set of pre-configured agent capabilities available out of the box. Each skill is defined in a standalone [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) file within the `skills/agent-runtime/` directory, enabling automatic discovery and registration when the application initializes.

## Complete Inventory of OpenMAIC Built-In Skills

The runtime discovers capabilities by scanning the `skills/agent-runtime/` directory structure. Each subdirectory represents a unique skill identified by its folder name (handle). Below are all 23 built-in skills organized by functional domain:

### Content Creation and Document Design

- **`slide-craft`** – Automated slide generation and visual layout optimization
- **`slide-dsl`** – Domain-specific language for programmatic slide creation
- **`pptx-import`** – Native PowerPoint file parsing and transformation into editable formats
- **`page-clone`** – Replication and adaptation of existing page layouts and structures
- **`pro-editing`** – Advanced content refinement, style correction, and grammatical optimization

### Pedagogical Styles and Teaching Methods

- **`lecture-style`** – Traditional lecture format content structuring and pacing
- **`workshop-style`** – Interactive workshop and hands-on session design frameworks
- **`teacher-style-clone`** – Analysis and mimicry of specific instructor presentation patterns
- **`style-clone`** – General stylistic adaptation and tone matching across content types
- **`feynman-learning`** – Implementation of the Feynman technique for simplified concept explanation
- **`learning-to-learn`** – Metacognitive strategy embedding and study skill integration

### Curriculum and Instructional Architecture

- **`curriculum-planner`** – Long-term educational pathway mapping and scope sequencing
- **`spiral-curriculum`** – Bruner's spiral curriculum model for recurring topic deepening
- **`understanding-by-design`** – UbD (Understanding by Design) framework template generation
- **`k12-core-literacy-planning`** – Standards-aligned literacy objective and assessment planning
- **`vocational`** – Career and technical education content structuring and pathway design

### Research and Information Verification

- **`deep-research`** – Multi-source academic and web research synthesis with source attribution
- **`deep-interactive`** – Interactive deep-dive exploration modes for complex topic investigation
- **`fact-check`** – Automated claim verification against authoritative sources

### Stage Management and Interaction Design

- **`stage-design`** – Physical or virtual classroom layout optimization and spatial planning
- **`stage-dsl`** – Programmatic stage configuration and scene transition management
- **`social-emotional-learning`** – SEL competency integration and emotional intelligence scaffolding

### Meta and Utility Skills

- **`build-personal-skill`** – Framework for creating user-defined custom capabilities and workflows

## Technical Architecture and Registration

Skills are not statically hardcoded but dynamically discovered. The system identifies built-in capabilities by the **`source: 'builtin'`** flag in the registry metadata.

### Discovery and Loading Mechanism

When the application initializes, the runtime:
1. Scans all `skills/agent-runtime/**/SKILL.md` files
2. Parses front matter metadata (name, title, description, execution steps)
3. Registers each skill with the `builtin` source identifier
4. Exposes the registry via the `/api/agent/skills` endpoint

### Core Registry Interface

The **[`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts)** module provides the primary API for skill interaction:

**`useAgentSkills()`** – React hook that fetches the skill registry from `/api/agent/skills` and returns an object containing:
- `skills`: Array of skill objects with metadata
- `loading`: Boolean indicating fetch state
- `error`: Error message if registry fetch fails
- `reload`: Function to refresh the skill list

**`skillTitle()`** – Resolves locale-specific display names using the translation key pattern **`workbench.skill.title.<handle>`**, falling back to the raw handle name if localization is missing.

**`skillDisplayLabel()`** – Generates human-readable labels formatted as `"Display Name /handle"` (e.g., `"课堂设计 /stage-design"`).

**`skillLabelForId()`** – Utility function that searches the skills array and returns the appropriate label for a given handle.

## Working with Built-In Skills Programmatically

### Listing Skills in React Components

Filter the registry to display only built-in capabilities:

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

export function BuiltinSkillList() {
  const { skills, loading, error } = useAgentSkills();

  if (loading) return <p>Loading skills…</p>;
  if (error) return <p>Error: {error}</p>;

  return (
    <ul>
      {skills
        .filter((s) => s.source === 'builtin')
        .map((skill) => (
          <li key={skill.id}>
            {skill.title ? `${skill.title} ` : ''}/{skill.name}
          </li>
        ))}
    </ul>
  );
}

```

### Resolving Skill Labels

Convert technical handles into human-readable text:

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

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

// Example output: "深度调研 /deep-research"
console.log(getSkillLabel('deep-research'));

```

### Invoking Skills via API

Trigger skill execution programmatically from client code:

```ts
// Load and execute a specific built-in skill
await fetch('/api/agent/skill/load', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ handle: 'deep-research' })
});

```

## The Slash Menu Interface

The primary UX for accessing built-in skills is the **`/`** command menu. When users type `/` in the composer:
1. The UI queries registered skills via `useAgentSkills()`
2. Renders entries using `skillDisplayLabel()` for localization support
3. Inserts the selected handle (e.g., `/curriculum-planner`) into the input field
4. The runtime executes the corresponding [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) logic upon message submission

This integration is validated in **[`tests/workbench/composer-skills.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/workbench/composer-skills.test.ts)**, which covers slash-query parsing and menu rendering.

## Key Implementation Files

| Path | Purpose |
|------|---------|
| [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) | Core registry logic, React hooks (`useAgentSkills`), and display helpers (`skillTitle`, `skillDisplayLabel`, `skillLabelForId`) |
| `skills/agent-runtime/**/SKILL.md` | Markdown definitions containing skill metadata and execution instructions |
| [`tests/workbench/agent-skills.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/workbench/agent-skills.test.ts) | Unit tests verifying skill registry behavior and label resolution |
| [`tests/workbench/composer-skills.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/workbench/composer-skills.test.ts) | Integration tests for slash-menu functionality and query parsing |

## Summary

- **23 built-in skills** ship with OpenMAIC, spanning content creation, pedagogical design, research, and curriculum planning
- Skills reside in `skills/agent-runtime/` with self-documenting [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) files that define execution logic
- The **`useAgentSkills()`** hook in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) provides reactive access to the skill registry
- Built-in skills are identified by **`source: 'builtin'`** and register automatically at application startup
- Users interact with skills via the **`/`** slash menu, which renders localized titles using `skillDisplayLabel()`

## Frequently Asked Questions

### How does OpenMAIC distinguish built-in skills from custom user skills?

The system inspects the `source` property in the skill registry object. Built-in skills carry **`source: 'builtin'`**, while user-created skills typically have `source: 'personal'`. This differentiation controls editing permissions and determines whether the skill definition is read-only in the UI.

### What is the structure of a SKILL.md file?

Each [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) contains YAML front matter specifying `name`, `title`, and `description`, followed by markdown documentation outlining execution steps and parameters. The runtime parses these files at startup to construct the skill registry without requiring TypeScript recompilation.

### Can I override or disable a built-in skill?

While built-in skills are read-only by default, you can create a personal skill with an identical handle in the user skills directory. The resolution logic in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) prioritizes user skills over built-ins when handles collide, effectively allowing overrides.

### How are skill titles internationalized?

The `skillTitle()` function attempts to resolve translation keys using the pattern **`workbench.skill.title.<handle>`** from the current locale files. If the translation key exists, it returns the localized string; otherwise, it falls back to the `title` defined in the skill's [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) or the raw handle name.