One Open Source Project a Day (No. 176): OpenMAIC — Tsinghua's Multi-Agent Interactive Classroom

Introduction

"From MOOC to MAIC — from passive consumption to active exploration."

This is the 176th article in the "One Open Source Project a Day" series. Today's project is OpenMAIC.

Online learning has a fundamental constraint: you watch the video, the video plays, you pause or speed up, but the course itself is fixed. No matter where you get stuck, the content doesn't change for you — you search elsewhere, figure it out, and come back.

OpenMAIC wants to break that paradigm. Type one sentence — "teach me Python basics in 30 minutes" — and it generates a full interactive classroom: an AI teacher explaining concepts, drawing on a whiteboard, posing quiz questions, letting you run code directly in the browser. Multiple AI agents each play a role; the classroom evolves through real-time interaction.

29.6k Stars, MIT license, built by Tsinghua University's THU-MAIC team, published in the Journal of Computer Science and Technology in 2026.

What You Will Learn

• OpenMAIC's two-stage generation pipeline (outline → scene content)
• How LangGraph state machines coordinate multi-agent turns and discussions
• The design logic behind four scene types (Slides/Quiz/Interactive HTML/PBL)
• Five Deep Interactive UI modes
• Multi-agent discussion mechanics (classroom discussion, roundtable, Q&A, whiteboard)
• Pluggable storage architecture (browser/PostgreSQL/S3)
• Local AI support (Ollama/FunASR/Lemonade)

Prerequisites

• Familiarity with AI agents and tool use basics
• Familiarity with Next.js/TypeScript development (for reading the source)
• Optional: basic understanding of LangGraph state machines

Project Background

What It Is

OpenMAIC (Open Multi-Agent Interactive Classroom) is an open-source AI education platform, positioned as: using multi-agent collaboration to transform any topic or document into an interactive classroom experience.

The official research framing is "From MOOC to MAIC":

MOOC (Massive Open Online Course):
  Fixed content → passive watching → predetermined path

MAIC (Multi-Agent Interactive Classroom):
  Dynamically generated content → active participation → personalized evolution
  ↑ AI teachers and peer agents sense learner state in real time,
    adjusting the classroom pace accordingly

This is not "AI generates slides" — every classroom scene is interactive. AI teachers can manipulate objects in 3D visualizations, draw on the whiteboard in real time, demonstrate logic in a code editor, and proactively call on learners during discussions.

The research has been published in the Journal of Computer Science and Technology (2026).

Author / Team

• Team: Tsinghua University THU-MAIC Research Group
• Contact: [email protected]
• License: MIT
• Language: TypeScript (Next.js)

Project Stats

• ⭐ GitHub Stars: 29,600+
• 🍴 Forks: 5,000+
• 📄 License: MIT
• 💻 Primary Language: TypeScript (Next.js)
• 🌐 Team: Tsinghua University THU-MAIC
• 📦 Quick start: pnpm install && pnpm dev
• 🐳 Docker: docker compose up --build

Core Features

What Problem It Solves

OpenMAIC connects content generation and classroom interaction through a multi-agent architecture:

Input (one sentence or uploaded document)
       ↓
  Two-stage generation pipeline
  ├── Stage 1: Outline generation (AI analyzes topic → structured course framework)
  └── Stage 2: Scene generation (each outline item → Slides/Quiz/Interactive/PBL)
       ↓
  LangGraph state machine (multi-agent coordination layer)
  ├── Teacher agent: explains, demonstrates, asks questions
  ├── Peer agents: discuss, debate, supplement
  └── Director Graph: coordinates turns and interactions
       ↓
  Playback Engine
  State machine: idle → playing → live
  Executes 28+ action types (speech/whiteboard draw/spotlight/laser pointer/...)
       ↓
  Learner (participates in real time: answers, asks questions, triggers discussions)

Usage Scenarios

1. Learning a new technology from scratch

   • "Teach me Python basics in 30 minutes" → generates a complete classroom with interactive exercises; AI teacher explains + in-browser coding experiments + quiz validation

2. Breaking down research papers

   • Upload a PDF, generate an interactive paper walkthrough; AI teacher covers core contributions, roundtable agents discuss implications and limitations from different angles

3. Corporate training content creation

   • Upload internal documents, generate standardized training material with .pptx export, offline ZIP distribution

4. Helping instructional designers

   • Rapidly generate a course draft, export to editable format for human refinement — drastically shortens the cycle from "idea" to "finished material"

5. Private local deployment

   • Run entirely offline with Ollama; suitable for data-sensitive enterprise training environments

Quick Start

# Clone
git clone https://github.com/THU-MAIC/OpenMAIC.git
cd OpenMAIC

# Install dependencies
pnpm install

# Configure environment
cp .env.example .env.local
# Add at least one LLM API key to .env.local

# Start dev server
pnpm dev
# Open http://localhost:3000

# Or use Docker
docker compose up --build

Recommended models:

• Gemini 3 Flash: best speed/quality balance
• Gemini 3.1 Pro: highest quality output

Running locally (no API key):

# Configure Ollama
OLLAMA_BASE_URL=http://localhost:11434/api/v1
OLLAMA_MODEL=llama3.2

# Configure local ASR (FunASR)
ASR_FUNASR_BASE_URL=http://localhost:8000/v1

Core Features

1. Four Scene Types

Every scene type supports active AI teacher manipulation — not just displaying static content.

2. Deep Interactive Mode: 5 UI Types

Deep Interactive Mode is OpenMAIC's core differentiator:

┌──────────────────────────────────────────────────────┐
│              Deep Interactive UI Types                │
│                                                      │
│  3D Visualization  │ Spatial rendering of abstract   │
│                    │ structures; AI teacher can       │
│                    │ rotate, zoom, annotate objects   │
│                    │                                  │
│  Simulation        │ Dynamic process/experiment       │
│                    │ environments; physics laws,      │
│                    │ chemistry, algorithm steps       │
│                    │                                  │
│  Game              │ Knowledge-reinforcement mini-    │
│                    │ games; learning through play     │
│                    │                                  │
│  Mind Map          │ Visual organization of concept   │
│                    │ frameworks; built in real time   │
│                    │                                  │
│  Online Coding     │ In-browser editor + instant      │
│                    │ execution; AI teacher demos,     │
│                    │ learner modifies and runs        │
└──────────────────────────────────────────────────────┘

Key point: AI teachers can actively operate these UIs to guide learners — not leaving them to figure it out alone, but "teacher right next to you, walking you through it."

3. Multi-Agent Discussion Mechanics

4. Playback Engine and Action System

Classroom playback is not video playback — it's a real-time execution engine driven by a state machine:

State machine: idle → playing → live

28+ action types including:
  Speech:   speech (read text aloud), pause
  Visual:   spotlight (highlight area), laser_pointer
  Whiteboard: draw_line, draw_text, draw_shape, draw_chart
  Interactive: ask_question, show_quiz
  3D:        rotate_object, zoom_to, annotate_3d
  ...

5. Supported LLM Providers

OpenMAIC is explicitly designed to be model-neutral:

Cloud:
  OpenAI (GPT series)
  Anthropic (Claude series)
  Google (Gemini 3 Flash/Pro)
  Azure OpenAI, Amazon Bedrock
  DeepSeek, Qwen, Kimi, MiniMax
  Grok (xAI), OpenRouter
  Doubao (ByteDance), Tencent Hunyuan
  Xiaomi MiMo, GLM (Zhipu AI)

Local:
  Ollama (any compatible model)
  Lemonade (LLM + image generation + TTS + ASR)
  FunASR (SenseVoiceSmall, Paraformer, Fun-ASR-Nano)
  Any OpenAI-compatible endpoint

6. Export Formats

7. Pluggable Storage Architecture

// @openmaic/storage supports multiple backends
const storage = createStorage({
  documents: 'browser',      // default: browser local storage
  assets: 's3',              // media: S3-compatible object storage
  sessions: 'postgresql',    // agent sessions: PostgreSQL (with lease/heartbeat/resume)
  kv: 'browser',             // key-value cache
})

The PostgreSQL Agent Runtime supports: leases, heartbeats, crash resume, cancellation, and follow-up steering.

Deep Dive

Why Two Stages?

Why split into outline generation and scene generation instead of generating the complete course directly?

Single-stage generation (direct output) problems:
  → Structural consistency is hard to guarantee
  → Scene-type-specific formats are hard to control precisely
  → Overall course length/difficulty is hard to calibrate

Two-stage pipeline advantages:
  Stage 1: Outline generation
    Input: topic / document / learning objective
    Output: structured outline (section → scene type → expected duration)
    → User can review and modify the outline here before proceeding

  Stage 2: Scene content generation (parallel)
    Each outline item independently calls its scene generator
    → Slides generator, Quiz generator, Interactive HTML generator, PBL generator
    → Each scene type has dedicated generation specs and prompt assets

The @openmaic/generation package owns generation contracts, pipeline logic, and prompt assets — the beating heart of the entire system.

LangGraph State Machine for Multi-Agent Coordination

A classroom isn't linear — multiple agents need to take turns, wait for learner responses, and decide what comes next. LangGraph is the key to making this coordination work:

Director Graph pattern:

  Director agent (coordinator)
       ↓
  ┌────────────────────────────────────┐
  │           Classroom state graph    │
  │  Lecture → Ask → Wait for response │
  │    ↑              ↓               │
  │  Discuss ← Handle response         │
  │            → Next scene            │
  └────────────────────────────────────┘
       ↓
  Teacher agent         Peer agents
  (main lecture,        (discussion,
   demonstration)        supplementation)

20 built-in skills cover curriculum planning, research, lecture, workshop, and editing roles — agents combine skills to simulate different teaching styles.

The "Neutral Design" Philosophy

OpenMAIC positions itself as neutral by design:

Bring your own:
  Models (OpenAI / Anthropic / Ollama / any compatible endpoint)
  Media (image, video, audio providers)
  Search providers (for course content enrichment)
  Storage backends (browser / PostgreSQL / S3)

OpenMAIC provides:
  Generation pipeline logic
  Multi-agent coordination framework
  Playback engine
  Classroom interaction UI
  Export tooling

This design lets OpenMAIC run fully locally (Ollama + browser storage) or integrate the strongest cloud models (Gemini 3.1 Pro + S3 + PostgreSQL) — the same codebase, driven by configuration.

Positioning vs. Existing Online Education Platforms

The most critical differentiator is "AI teacher actively operates UI" — not generating a static document for learners to read, but having the AI walk you through steps, views, exercises, and discussions.

Project Links & Resources

Official Resources

• 🌟 GitHub: https://github.com/THU-MAIC/OpenMAIC
• 📧 Team contact: [email protected]
• 📄 License: MIT

Related Projects

• LangGraph — the state machine framework powering OpenMAIC's multi-agent coordination
• Ollama — the local AI backend for offline OpenMAIC deployment
• FunASR — local speech recognition, supporting SenseVoiceSmall and Paraformer

Summary

Key Takeaways

1. Two-stage pipeline = generation quality: outline first ensures structural consistency; parallel scene generation with type-specific specs ensures format fidelity
2. LangGraph state machine = multi-agent coordination: Director Graph pattern coordinates teacher/peer agent turns and discussion pacing
3. 28+ action types = classroom expressiveness: AI teachers don't just display content — they operate whiteboards, highlight key points, ask questions
4. 5 Deep Interactive UI types = genuine immersion: 3D, simulation, games, mind maps, online coding — AI teacher guides you through, not leaving you to figure it out alone
5. Neutral design = any model, any storage: local Ollama or cloud Gemini Pro, same codebase, configuration-driven

Who This Is For

• Online education content creators: dramatically shortens "idea → interactive courseware" cycle; export to .pptx for further refinement
• Corporate training teams: internal documents → standardized training classrooms, supports private deployment, data stays on-prem
• AI researchers and students: explore multi-agent coordination for educational scenarios; a real-world LangGraph state machine implementation
• Individual learners: one sentence in, a full custom classroom out — more efficient than "search YouTube then find tutorials" by an order of magnitude
• Developers and edtech enthusiasts: a complete Next.js + LangGraph multi-agent open-source project — an excellent reference for learning how real multi-agent systems are designed

One-Line Verdict

OpenMAIC asks: when AI can both understand content and actively teach it, what can a classroom be — not a video, not a chat, but a living classroom that speaks, draws, and asks questions?

Check out PrimeSkills — a curated marketplace of AI agents and skills that have been validated in real-world, enterprise-grade workflows. No fluff, just what actually works.

Find more useful knowledge and interesting products on my Homepage