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

> Discover the 23 built-in skills in OpenMAIC's agent runtime. This guide details each skill and how the framework automatically discovers and exposes them for enhanced chatbot capabilities.

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

---

**OpenMAIC provides 23 built-in skills**, each defined by a [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/src/lib/workbench/agent-skills.ts). This module reads the `skills/agent-runtime` directory and identifies every subdirectory containing a [`SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) contains YAML front-matter that defines the skill's behavior. For example, [`skills/agent-runtime/workshop-style/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/agent-runtime/workshop-style/SKILL.md) and [`skills/agent-runtime/vocational/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) and executes the defined SOP (Standard Operating Procedure) phases.

```tsx
// 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:

```bash

# 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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) in `skills/agent-runtime/{skill-name}/`
4. **SOP Execution** – The runtime processes the skill's defined phases

```json
// 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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/SKILL.md) file for automatic discovery by [`src/lib/workbench/agent-skills.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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`](https://github.com/THU-MAIC/OpenMAIC/blob/main/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.