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

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

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:

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:

// 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 logic upon message submission

This integration is validated in tests/workbench/composer-skills.test.ts, which covers slash-query parsing and menu rendering.

Key Implementation Files

Path	Purpose
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	Unit tests verifying skill registry behavior and label resolution
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 files that define execution logic
• The useAgentSkills() hook in 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 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 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 or the raw handle name.

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