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

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 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 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.
• 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 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:

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():

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:

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 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, which maps skill handles (/skill) to their metadata representations. Lifecycle management and loading states are handled by 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, 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.
• 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.

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. This asynchronous method returns an array of skill metadata objects parsed from each 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.

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, it implements validation pipelines that can be triggered during or after content generation to ensure instructional accuracy.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}