Teach with a room full of agents.
OpenMAIC turns a topic or source material into an interactive classroom: lessons, quizzes, simulations, project work, voices, whiteboards and AI classmates — with a path from one-click generation to a steerable course-building workbench.
Deep dive • evidence • architecture • implementation guide
Prepared 19 September 2026
It is a classroom generator that can keep teaching after the first draft.
Give OpenMAIC a topic, slides or other materials. It can build a structured course, populate it with different AI roles, and let a learner interrupt, ask, explore, practise and export the result.
Build faster
Move from a prompt or source pack to a usable lesson rather than starting with a blank page.
Make learning social
Use teacher, assistant, manager and classmate roles to create a more alive learning loop.
Keep steering
In Pro mode, sessions can be resumed, redirected and revised instead of regenerated from scratch.
The tension is simple: reach many people without teaching everyone the same way.
One course, many learners
- Pre-recorded content is efficient to distribute.
- Everyone gets roughly the same pace and explanation.
- Personal support is expensive and often missing.
One learner, many agents
- Course material becomes structured, searchable and actionable.
- Agents can explain, question, manage, encourage and analyse.
- The learner can interrupt and steer the classroom.
The paper frames this as a design goal, not a solved problem: balancing scalability with adaptivity through LLM-driven multi-agent systems.
Useful when the learning experience needs more than a document and a chatbot.
Course authoring
Turn slides, documents, audio or video into a structured course with scenes, scripts and activities.
Hands-on learning
Use simulations, games, mind maps, coding and project-based learning to make concepts observable.
Agentic facilitation
Give different roles distinct jobs: explain, challenge, summarise, keep order, or decide what happens next.
Shareable outputs
Export editable PowerPoint, interactive HTML or a classroom archive for backup and sharing.
AI onboarding
Teach a new team how an internal system works through guided scenes and Q&A.
Research reading
Turn a paper into a debate, quiz, visual explanation and implementation exercise.
Technical training
Build a Python, data or agent-harness course with runnable activities.
Community learning
Create a reusable classroom for workshops, meetups or a distributed cohort.
Deep dive
under the classroom
The interesting part is not “many agents” by itself. It is the combination of structured course material, explicit actions, role design and a controller that keeps the room moving.
The preparation workflow has two passes: understand the material, then make it teachable.
Capture textual and visual content from each page.
Generate a usable description for the slide or source unit.
Build a knowledge-aware tree across the material.
Let educators proofread and refine the machine output.
Attach actions, scripts and agent roles to the course.
Why structure matters
A slide deck is not yet a learning system. OpenMAIC converts pages into descriptions, knowledge units and action-ready material that agents can retrieve and use.
Human checkpoint
The paper keeps educators in the loop for proofreading and refinement. That is a crucial product choice: generation is accelerated, not made unquestionable.
Roles give the room a division of labour.
Explains, asks, advances the lesson.
Supports, clarifies and helps manage.
Challenge, react, summarise or energise.
speaks next?
Reads the current state, available actions, class roles and learner input, then advances the classroom.
Maintains flow, timing and classroom order.
Reads signals from behaviour and outcomes.
Interrupts, asks, steers and chooses depth.
The classroom is a sequence of explicit actions, not just a stream of chat.
You can see what the system is trying to do instead of debugging a blob of prose.
New teaching behaviours can be added as actions and attached to course context.
The playback engine can pause, wait for input, execute effects and resume.
OpenMAIC has evolved from a concept into a fairly complete product surface.
Generation
Two-stage outline → scene generation, with multimodal materials, scripts, media and classroom scenes.
Orchestration
LangGraph-based multi-agent discussions, playback state, action execution and interactive classroom control.
Persistence
Browser-first by default, with optional PostgreSQL-backed documents, assets, materials, sessions and skills.
Editor + renderer
Versioned DSL, slide editor, scene renderers, PPTX importer and HTML/PPTX export packages.
Media surface
Pluggable providers for LLMs, search, images, video, TTS and ASR, including local options.
Agent workbench
Chat-first Pro mode with durable sessions, follow-up steering, materials and reusable course skills.
Read this as a system boundary: OpenMAIC is not one prompt wrapper. It is an authoring, runtime, playback, storage and export stack.
Rich learning does not have to mean one fixed model or one fixed modality.
Visualise structures.
Change variables.
Practise recall.
Write and run.
Bring your own model, media, search provider and storage backend. The repo documents support for hosted and local providers, including OpenAI-compatible endpoints, Ollama, Lemonade and FunASR paths.
✓ Good for experimentation and regional/provider choice
! The server-side configuration is yours to secure and operate
The evidence is encouraging, but the paper itself calls it preliminary.
MAIC-FuncGen scored highest overall in the paper’s script-generation comparison. Visual input and prior context mattered.
of observed student activity involved asking questions or seeking knowledge.
involved managing progress or agent roles.
The study covered more than 500 students and 100,000 learning records across two courses. These are observations and associations, not a randomised proof of causation.
What seems to work
Structured visual context, role descriptions, immediate Q&A and explicit classroom actions.
What remains weak
Controller accuracy, deep discussion, personal adaptation and the risk of mechanical teaching.
What to measure next
Direct assessments of critical thinking, problem solving, retention and transfer, not only perceptions.
The strongest idea is not “replace teachers”. It is “make learning stateful, inspectable and steerable”.
Make the state explicit
Track current scene, learner signals, role availability, pending actions and course context.
Give agents boundaries
Use role descriptions, tools and routing rules so each agent has a job it can perform well.
Design for interruption
Let people pause, ask for a simpler explanation, change pace or revisit a previous step.
How to implement
without overbuilding
Start with one classroom, one provider and one measurable learning outcome. Add the multi-agent and persistence layers only when they solve a real bottleneck.
Choose the smallest setup that matches your goal.
| Path | Use it when | What you do | Trade-off |
|---|---|---|---|
| Hosted demo | Explore the experience quickly. | Get an access code and use the live deployment. | Fastest start; less control. |
| Local dev | Build a course or prototype locally. | Clone, install, configure one LLM provider, run pnpm dev. | More setup; easiest to debug. |
| Extend / deploy | Own the product surface or run shared sessions. | Use the SDK/packages, agent runtime, PostgreSQL and a production deployment. | More control; security and operations become your job. |
My recommendation
Use local dev for a first serious prototype. Keep the hosted demo for experience testing. Add server-backed persistence only once sessions or assets need to survive devices and restarts.
Do not skip
Decide who owns learner data, which providers receive source materials, and whether generated classrooms are public, private or access-code protected.
Get a first classroom running in four moves.
Use Node.js ≥ 22.19 and pnpm ≥ 10, then install the workspace dependencies.
Copy .env.example to .env.local and set a provider key plus an explicit DEFAULT_MODEL.
Run pnpm dev, then open the local app and create a small test course.
Check outline quality, scene transitions, questions, exports and what source data is retained.
Use a narrow learning outcome, then let the system earn more complexity.
“Learner can explain X and use it in Y.”
Slides, notes, links, examples or a short paper.
Lecture → check → interaction → practice.
Teacher, challenger, summariser, manager.
Task, rubric, retention and transfer.
Example: paper club
Input: one paper. Output: visual summary, “find the assumption” quiz, debate and reproduce-the-method exercise.
Example: AI onboarding
Input: product docs. Output: role-based walkthrough, scenario questions, troubleshooting simulation and short assessment.
Example: maker workshop
Input: project brief. Output: milestones, assistant feedback, peer critique and a final demo rubric.
For shared or long-running classrooms, persistence and security change the design.
- PostgreSQL-backed course documents and runtime state.
- Durable agent sessions with leases, heartbeats, resume and cancellation.
- Asset registry and storage, with retention and quota decisions.
- Access code or real user authentication for shared deployments.
- Render service for MP4 export when required.
Do not send private course or learner material to an unapproved provider.
Keep consequential operations explicit, logged and reversible where possible.
Measure actual skill transfer, not only pleasant interaction or message volume.
Where this gets interesting for an AI product and research practice.
Internal capability classroom
Turn platform decisions, evaluation patterns and governance playbooks into scenario-based learning for product, design and engineering teams.
Measure: decision quality, time-to-first-prototype, and safe use of internal tools.
Research methods tutor
Use a paper or methods corpus to create a provenance-aware seminar: explain, challenge assumptions, compare methods and test replication risk.
Measure: methods extraction accuracy, source traceability and transfer to a new case.
Agent-workflow dojo
Teach a team how to use memory, tools, evals and handoffs through an interactive workshop with a manager agent and adversarial classmate.
Design-systems playground
Let learners prototype branching narrative, nemesis logic or game economy rules in a simulation rather than only read design docs.
The next product frontier is not just generating more lessons. It is making the learning loop observable, steerable and genuinely useful.
Source notes
THU-MAIC / OpenMAIC
Current README, project structure, quick start, features, agent workbench, persistence and deployment notes.
From MOOC to MAIC
Yu et al. Journal of Computer Science and Technology, 41(1), 394–414, 2026. DOI: 10.1007/s11390-025-6000-0.
Technical detail
The deck uses the openly accessible preprint for the Read → Plan workflow, agent roles, controller, evaluation and limitations.
What this deck is
An evidence-grounded explainer and implementation guide. It is not a reproduction of the paper’s experiments or a security review of a live deployment.
OpenMAIC deep dive · responsive self-contained HTML · Australian English
Keep the classroom human.
Make the system useful.
Questions, ideas or a better way to build this?
Reach out to Vivid / Lilly via Slack.