How Many Built-In Skills Does OpenMAIC Have? A Complete Guide to the 23-Agent Runtime

OpenMAIC provides 23 built-in skills, each defined by a SKILL.md file in the skills/agent-runtime directory tree. The framework automatically discovers these skills at startup and exposes them through the chat interface's / command palette.

OpenMAIC is the open-source educational AI framework developed by THU-MAIC that powers specialized agents for teaching and professional training scenarios. The built-in skill system forms the core of its extensible agent architecture, allowing users to invoke pre-configured instructional methodologies through simple slash commands.

How OpenMAIC Discovers Built-In Skills

The framework implements an automated discovery mechanism that scans the filesystem for skill definitions. This approach ensures that adding new capabilities requires no manual registration code.

The Agent Runtime Scanner

According to the OpenMAIC source code, skill discovery occurs in src/lib/workbench/agent-skills.ts. This module reads the skills/agent-runtime directory and identifies every subdirectory containing a SKILL.md file.

The discovery process follows these steps:

1. Directory Traversal – The runtime scans skills/agent-runtime for subdirectories
2. Validation – Each folder is checked for the presence of SKILL.md
3. Metadata Parsing – Front-matter data (name, description, user-invocable flag) is extracted from the markdown file
4. Registration – Valid skills are loaded into the agent runtime and made available for tool invocation

Because the system treats every SKILL.md-containing folder as a distinct skill, the total count equates to the number of such directories, which stands at 23 in the current release.

Skill Metadata Structure

Each SKILL.md contains YAML front-matter that defines the skill's behavior. For example, skills/agent-runtime/workshop-style/SKILL.md and skills/agent-runtime/vocational/SKILL.md represent two distinct built-in capabilities following this pattern.

The runtime uses this metadata to populate the user interface and determine execution parameters.

Accessing Built-In Skills in the User Interface

OpenMAIC exposes its 23 built-in skills through multiple interfaces, ensuring developers and end-users can leverage agent capabilities efficiently.

The Command Palette Interface

When users type / in the chat composer, the UI queries the loaded skill registry via src/lib/workbench/composer-skills.ts. This triggers a dropdown menu displaying available skills such as:

• workshop-style
• deep-interactive
• vocational

Selecting a skill inserts the corresponding handle (e.g., /deep-interactive) into the message composition area.

Programmatic Skill Invocation

Behind the scenes, invoking a skill generates a create_skill tool call to the backend. The runtime then loads the specific SKILL.md and executes the defined SOP (Standard Operating Procedure) phases.

// React component displaying available built-in skills
import { useAgentSkills } from '@/lib/workbench/agent-skills';

function SkillMenu() {
  const { skills, loading } = useAgentSkills();

  if (loading) return <Spinner />;
  return (
    <ul>
      {skills.map((s) => (
        <li key={s.name}>
          <button onClick={() => insertSkill(`/` + s.name)}>
            {s.title || s.name}
          </button>
        </li>
      ))}
    </ul>
  );
}

The useAgentSkills hook returns all 23 built-in skills along with their metadata, enabling dynamic UI generation without hardcoding skill names.

Verifying the Built-In Skill Count

Developers can programmatically verify the number of available skills using Node.js filesystem operations:

# List all built-in skills and confirm the count

node -e "
const fs = require('fs');
const path = require('path');
const skillDir = path.resolve('skills/agent-runtime');
const skills = fs.readdirSync(skillDir).filter(d => 
  fs.existsSync(path.join(skillDir, d, 'SKILL.md'))
);
console.log('Total built-in skills:', skills.length);
console.log('Available skills:', skills);
"

This script outputs 23 when run against a standard OpenMAIC installation, confirming the total number of agent capabilities shipped with the framework.

Skill Execution Flow

When a user selects a built-in skill, the system executes the following sequence:

1. Frontend Selection – User clicks a skill in the composer or types the / command
2. Tool Call Generation – The client sends a create_skill request with the skillId parameter
3. Backend Resolution – The server locates the corresponding SKILL.md in skills/agent-runtime/{skill-name}/
4. SOP Execution – The runtime processes the skill's defined phases

// Example tool call generated when invoking a skill
{
  "toolName": "create_skill",
  "toolArgs": {
    "skillId": "deep-interactive",
    "prompt": "generate a lesson plan"
  }
}

This architecture ensures that all 23 built-in skills execute with consistent behavior while maintaining isolation between different agent methodologies.

Summary

• OpenMAIC contains exactly 23 built-in skills located in the skills/agent-runtime directory
• Each skill requires a SKILL.md file for automatic discovery by src/lib/workbench/agent-skills.ts
• Skills are accessed via the / command palette in the chat interface, handled by src/lib/workbench/composer-skills.ts
• The runtime uses metadata from skill definitions to generate tool calls and execute SOP phases
• New skills can be added by creating directories with SKILL.md files; no registry modification is required

Frequently Asked Questions

How do I add a custom skill to OpenMAIC?

Create a new subdirectory in skills/agent-runtime containing a SKILL.md file with proper YAML front-matter. The runtime automatically detects the new folder on the next startup and registers it as the 24th skill. Ensure your skill definition includes the name, description, and user-invocable flag in the front-matter.

What format does a SKILL.md file use?

Each SKILL.md uses standard markdown with YAML front-matter delimited by triple dashes. The front-matter specifies metadata like name, title, and description, while the body defines the SOP (Standard Operating Procedure) phases that guide the agent's behavior. Reference existing files like skills/agent-runtime/workshop-style/SKILL.md for the exact schema.

Can built-in skills be modified without changing the source code?

Yes, since OpenMAIC treats SKILL.md files as configuration rather than compiled code, you can edit the markdown definitions directly. Changes to skill logic in the SOP phases take effect immediately upon the next skill invocation, though you may need to restart the development server if the skill metadata structure itself changes.

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