# Built-In Skills Available in OpenMAIC: Complete Inventory and Usage Guide

> Explore OpenMAIC's ten built-in skills for classroom design, content creation, and more. This guide details their inventory and usage. Learn how to leverage these powerful tools.

- Repository: [MAIC/OpenMAIC](https://github.com/THU-MAIC/OpenMAIC)
- Tags: api-reference
- Published: 2026-09-12

---

**OpenMAIC ships with ten production-ready built-in skills located in `skills/agent-runtime` that handle classroom design, interactive content creation, PowerPoint import, and educational methodology, each defined by a declarative [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) manifest.**

OpenMAIC is an open-source educational AI framework that generates dynamic classroom experiences through a modular skills system. The built-in skills available in OpenMAIC are housed under the `skills/agent-runtime` directory, where each capability is declared in a machine-readable [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) manifest containing the skill's **name**, **title**, and **description**.

## Core Built-In Skills for Classroom Generation

The agent runtime includes specialized skills for distinct pedagogical and technical tasks. Below is the complete inventory of built-in skills available in the current OpenMAIC release:

### Classroom Architecture and Import

- **stage-design**: Provides the baseline workflow for building a single classroom stage, encompassing planning, roster creation, scene generation, and finalization as defined in [`skills/agent-runtime/stage-design/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/agent-runtime/stage-design/SKILL.md).
- **pro-editing**: Enables modification of already-persisted stages rather than constructing new classrooms from scratch.
- **pptx-import**: Imports existing Microsoft PowerPoint decks into an OpenMAIC stage, converting each slide into an individual scene.

### Content Authoring and Interaction

- **slide-dsl**: Supplies a domain-specific language for authoring slide-type pages, optimized for static presentation-style content.
- **slide-craft**: Focuses on generating slide-type pages enriched with visual assets and dynamic elements.
- **deep-interactive**: Drives courses where learners manipulate simulations, diagrams, code, or games on most pages, reserving slides for framing and consolidation.

### Pedagogical and Research Methodologies

- **k12-core-literacy-planning**: Implements Chinese K-12 core-literacy course design, covering diverse subjects and grade levels with curriculum-aligned structures.
- **learning-to-learn**: Guides meta-learning activities that prompt students to reflect on their own learning processes and strategies.
- **deep-research**: Facilitates the creation of research-oriented courses requiring extensive background material synthesis and citation handling.
- **fact-check**: Supplies a verification workflow for validating factual claims within AI-generated educational content.

## Accessing Built-In Skills Programmatically

The runtime exposes built-in skills through the [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts) module, which provides strongly-typed helpers for enumeration and instantiation.

### Listing All Available Skills

Use `listBuiltinSkills()` to retrieve the complete catalog of skills with their metadata:

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

async function showBuiltinSkills() {
  const skills = await listBuiltinSkills();   // → [{ name: 'stage-design', title: '课堂设计', … }, …]
  console.table(skills.map(s => ({ name: s.name, title: s.title })));
}
showBuiltinSkills();

```

### Loading a Specific Skill

Retrieve a single skill definition by specifying the `source: 'builtin'` parameter to `loadSkill()`:

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

async function useDeepInteractive() {
  const skill = await loadSkill({ name: 'deep-interactive', source: 'builtin' });
  // `skill` now contains the parsed SKILL.md content and can be passed to the runtime.
  console.log('Loaded skill:', skill.title);
}
useDeepInteractive();

```

### Executing Skill Workflows

Trigger end-to-end classroom generation by combining skills with the agent runtime API:

```typescript
import { createStage, generateScene } from '@/api/agent-runtime';

async function buildStageWithStageDesign() {
  const stageId = await createStage({ title: 'My New Classroom' });
  await setRoster(stageId, { teacher: 'Ms. Lee', agents: ['Student A', 'Student B'] });
  // Assume we have a pre-planned page plan:
  const pages = [
    { title: 'Introduction', type: 'slide', brief: 'Introduce the topic' },
    { title: 'Exploration', type: 'interactive', brief: 'Let students manipulate …' },
  ];
  for (const [i, p] of pages.entries()) {
    await generateScene(stageId, { order: i + 1, ...p });
  }
}
buildStageWithStageDesign();

```

## Skill System Architecture

### Manifest Declaration

Each skill is self-describing through a [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) file located in its respective subdirectory under `skills/agent-runtime/`. These manifests follow a standardized schema that the runtime parses to determine skill **name**, **title**, and **description**, enabling dynamic discovery without hard-coding skill logic.

### UI Integration Points

The composer interface integrates skills through [`lib/workbench/composer-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/composer-skills.ts), which maps skill handles (`/skill`) to their metadata representations. Lifecycle management and loading states are handled by [`lib/workbench/skill-load.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/skill-load.ts), ensuring seamless UI transitions when instantiating complex skills like `deep-research` or `pptx-import`.

### Validation and Testing

The integrity of the built-in skill registry is enforced by [`tests/workbench/agent-skills.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/workbench/agent-skills.test.ts), which asserts that all skills listed in `skills/agent-runtime/` are correctly labeled, parseable, and expose the expected public API surface.

## Summary

- OpenMAIC provides **ten built-in skills** covering classroom design, content authoring, and pedagogical methodologies.
- Skills are declared in **SKILL.md manifests** under `skills/agent-runtime/` and accessed via `listBuiltinSkills()` and `loadSkill()` in [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts).
- **stage-design** serves as the foundational skill for classroom creation, while specialized skills like **fact-check** and **deep-research** handle specific educational workflows.
- The skills system is fully typed and tested, with UI integration managed through [`lib/workbench/composer-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/composer-skills.ts).

## Frequently Asked Questions

### How do I list all built-in skills available in OpenMAIC?

Use the `listBuiltinSkills()` function exported from [`lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/workbench/agent-skills.ts). This asynchronous method returns an array of skill metadata objects parsed from each [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) manifest in the `skills/agent-runtime/` directory, enabling dynamic enumeration without manual catalog maintenance.

### What is the difference between the slide-dsl and slide-craft skills?

**slide-dsl** provides a domain-specific language for authoring static presentation-style slides, while **slide-craft** focuses on generating visually rich slide pages with dynamic assets and enhanced formatting. The former optimizes for semantic markup, whereas the latter emphasizes visual composition and asset integration.

### Where are skill manifests stored in the OpenMAIC repository?

Each built-in skill manifest resides in a dedicated subdirectory under `skills/agent-runtime/` following the pattern `skills/agent-runtime/{skill-name}/SKILL.md`. For example, the `stage-design` skill manifest 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).

### How does the fact-check skill validate generated content?

The **fact-check** skill supplies a dedicated workflow for verifying factual claims within AI-generated educational material. According to the source code in [`skills/agent-runtime/fact-check/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/agent-runtime/fact-check/SKILL.md), it implements validation pipelines that can be triggered during or after content generation to ensure instructional accuracy.