OpenMAIC: an AI classroom generator that needs a model key before it teaches anything
Open Multi-Agent Interactive Classroom, Get an immersive, multi-agent learning experience in just one click.
At a glance
- What is it?
- OpenMAIC turns a topic, a document or a slide deck into a multi-agent classroom with slides, quizzes and simulations. It is a Next.js app you self-host, and every capability depends on which providers you wire into .env.local.
- Who is it for?
- Adopt OpenMAIC if you can run a Node 22.19+ build and you already hold keys for at least one LLM provider, because the README states that all providers are optional and the app does nothing useful without one. Skip it if you need a managed service with a support contract, or if you want a fixed curriculum that does not vary between runs: the output is model-generated.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 5 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 25, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What OpenMAIC actually produces, and who it is built for
OpenMAIC (Open Multi-Agent Interactive Classroom) is an open-source platform that converts a topic or an uploaded document into a lesson. The README describes the output as slides, quizzes, interactive simulations and project-based learning activities, delivered by AI teachers and AI classmates that speak, draw on a whiteboard and hold discussions with the learner. The repository is TypeScript, licensed MIT, and it is a Next.js application rather than a library you import into an existing app.
The intended user is someone who wants to assemble course material quickly and is willing to run the stack themselves. The README points at two hosted entry points: a live demo at open.maic.chat and a Vercel clone button that asks for at least one LLM provider API key. That clone button is the clearest statement of the target audience. If you can supply an API key and click a deploy button, the project assumes you can get a classroom out of it.
The scope is broader than slide generation. The v1.0.0 release notes describe a Pro workbench where you chat with an agent that plans a curriculum, builds and revises pages, and works from uploaded documents, audio and video or from web search. The same notes list 20 built-in skills covering slides, quizzes, interactives, PBL, images, video, voices and .pptx import. That is a lot of surface area, and it is worth reading the feature list before assuming any single piece is polished.
How the multi-agent generation pipeline is put together
The repository layout separates concerns in a way that tells you where the work happens. The top level holds app/, components/, lib/, configs/, skills/, types/ and middleware.ts for the web application, plus packages/ for the published @openmaic/* modules and render-service/ for video export. The v0.3.0 release notes state that the @openmaic/* SDK family (DSL, renderer, importer) was published to npm, and package.json builds packages/@openmaic/dsl, packages/@openmaic/generation, packages/@openmaic/storage, packages/@openmaic/importer, packages/@openmaic/renderer and packages/@openmaic/editor during postinstall.
So the flow is roughly: a generation package produces a course representation, a DSL describes it, a renderer turns that into what the learner sees, and an importer brings outside material in. Providers are configuration, not code. The .env.example uses a uniform pattern of {PROVIDER}_API_KEY, {PROVIDER}_BASE_URL and {PROVIDER}_MODELS, repeated for OpenAI, Azure OpenAI, Atlas Cloud, Anthropic, Google, DeepSeek, Qwen, Kimi, MiniMax and GLM. The header comment states that all variables are optional and that you configure only the providers you want, and that server-providers.yml is an alternative to environment variables.
Persistence is optional and explicit. The docker-compose.yml passes NEXT_PUBLIC_PERSISTENCE and NEXT_PUBLIC_PERSISTENCE_TOKEN as build arguments, with a comment warning that NEXT_PUBLIC_* values are compiled into the browser bundle and should be left empty unless the feature is enabled. The v0.3.2 notes mention a one-command Postgres stack and incremental saves, and v1.0.0 adds durable sessions that survive restarts. That is a genuine architectural commitment: server-backed runs you can cancel, resume and steer.
Installing OpenMAIC locally and generating a first lesson
The README's Quick Start section is the starting point, and the repository pins the runtime. package.json declares "engines": { "node": ">=22.19.0" }, and there is a .nvmrc at the top level, so check your Node version before anything else. The Dockerfile uses node:22-alpine and activates pnpm 10.28.0 through corepack.
Clone the repository and install dependencies with pnpm. The postinstall script builds the vendored packages, so this step is slower than a typical install and will fail loudly if a sub-package build breaks.
git clone https://github.com/THU-MAIC/OpenMAIC.git
cd OpenMAIC
pnpm installNext, copy the environment template. The .env.example header says to copy it to .env.local and fill in the values you need. At minimum, set one provider key. The template lists OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY, DEEPSEEK_API_KEY, QWEN_API_KEY, KIMI_API_KEY, MINIMAX_API_KEY and GLM_API_KEY among others, each with an optional _BASE_URL and _MODELS companion.
cp .env.example .env.local
# then edit .env.local and set at least one provider key, e.g.
# OPENAI_API_KEY=sk-...Start the development server and open port 3000, which is the port the compose file maps.
pnpm devIf you would rather not install Node tooling, docker-compose.yml defines a single openmaic service built from the local Dockerfile, mapping '3000:3000' and reading .env.local through env_file. The compose file also notes that the render service only starts under the video-export profile, so a plain `docker compose up` gives you the app without MP4 export. What you should see after starting is the classroom interface, where you describe a topic or attach material and let the generator run.
Where OpenMAIC stops being the right tool
The dependency on external providers is the first boundary. The README's Vercel button text says to configure at least one LLM provider API key and that all providers are optional, which is true in the sense that nothing crashes without them, but the generation features have nothing to call. There is no bundled model. If your organisation cannot send course topics and uploaded documents to a third-party API, this project in its default configuration is not usable, and the documentation does not describe an offline generation path. Ollama support is listed among the v0.1.1 changes, so a local model is possible, but the README does not present it as the primary route.
The second boundary is output stability. The product is an agent that plans and writes a course. Two runs on the same topic will not produce identical slides, and the README offers no determinism guarantee. For a compliance training deck that legal has to approve once and freeze, that is the wrong shape of tool. The eval/ directory and the eval:* scripts in package.json (eval:orchestration, eval:whiteboard, eval:pbl-v2-planner, eval:outline-language) suggest the maintainers measure generation quality, but an evaluation harness is not a reproducibility contract.
The third is operational weight. This is a Next.js app with a workspace of six or more built packages, native build dependencies in the Docker image (python3, build-base, cairo-dev, pango-dev, librsvg-dev for sharp and @napi-rs/canvas), and an optional separate render service for video. Deploying it is closer to running a small platform than dropping in a widget.
OpenMAIC against Slidev, Marp and plain Reveal.js
The nearest comparison is not another AI classroom, because the README does not position it against one. It is the markdown-to-slides family: Slidev, Marp and Reveal.js. The difference in approach is total. Those tools take a file you wrote and render it deterministically; you own every word on every slide, and the build is reproducible. OpenMAIC takes a topic or a document and asks a model to author the deck, the quiz and the interactive scenes, then renders the result through its own DSL and renderer packages.
That trade is the whole decision. With Slidev or Marp you spend the time writing and you get exactly what you wrote, in a format that diffs cleanly in git. With OpenMAIC you spend configuration time on providers and get a lesson you did not write, with a chat-based editor (the MAIC Editor, introduced in v0.2.2 and extended in v0.3.1 with drag, resize, rotate and multi-select) to correct it afterwards. If your material already exists as a well-structured document, the markdown route is cheaper. If your bottleneck is that no one has time to write the material at all, the generation route addresses a problem the markdown tools do not touch.
Worth noting for anyone comparing on integration: the README states that built-in OpenClaw integration lets you generate classrooms from messaging apps including Feishu, Slack and Telegram. That is a differentiator the slide frameworks have no equivalent for.
Maintenance, upgrade cost and what the MIT licence changes
The last push to main was on 2026-08-27, the same day v1.0.0 was tagged, and the repository is not archived. The release cadence visible in the README is dense: v0.1.0 in March 2026, then v0.1.1, v0.2.0, v0.2.1, v0.2.2, v0.3.0, v0.3.1, v0.3.2 and v1.0.0 by late August. Each entry in the News section links to a changelog, and package.json carries its own version (1.0.2) alongside the release tags, which is a detail to watch when you report bugs.
Upgrade cost is real. The v0.3.2 notes describe a full document cutover for server-backed persistence and an asset registry; v1.0.0 adds durable sessions and a pluggable persistence stack. Those are storage-layer changes, and storage changes are the ones that hurt on upgrade. The repository also ships check:package-versions and check:node-engine, which implies the maintainers enforce version bumps across the workspace packages, so a partial upgrade of one @openmaic/* package is likely to be flagged.
The licence history matters more than the current one. The v0.3.0 release notes state that the project was relicensed from AGPL-3.0 to MIT. package.json declares "license": "MIT" and there is a LICENSE file at the top level. For anyone evaluating OpenMAIC for a commercial product, that relicensing is the fact to verify against the actual LICENSE text, because AGPL-3.0 and MIT impose very different obligations and the change is recent relative to the project's history. This is not legal advice; read the file and, if the stakes are high, get counsel.
Editorial conclusion
Adopt OpenMAIC if you can run a Node 22.19+ build and you already hold keys for at least one LLM provider, because the README states that all providers are optional and the app does nothing useful without one. Skip it if you need a managed service with a support contract, or if you want a fixed curriculum that does not vary between runs: the output is model-generated. Before committing, check three things in your own environment: that pnpm install completes the postinstall build of packages/mathml2omml, packages/pptxgenjs and the @openmaic/* packages, that your chosen provider appears in .env.example with the exact variable name you intend to use, and whether you need the video-export profile in docker-compose.yml, since that pulls in a separate render service.
Frequently asked questions
What is OpenMAIC?
OpenMAIC (Open Multi-Agent Interactive Classroom) is an open-source platform that turns a topic or document into an interactive classroom with slides, quizzes, simulations and project-based learning activities, presented by AI teachers and AI classmates. It is a TypeScript Next.js application licensed under MIT.
How do you use OpenMAIC?
Clone the repository, run pnpm install, copy .env.example to .env.local with at least one LLM provider key, then run pnpm dev and open port 3000. The README also offers a Vercel clone button and a docker-compose.yml that maps port 3000 and reads .env.local.
What is OpenMAIC?
It is a multi-agent classroom generator: the README describes AI teachers and AI classmates who lecture, discuss and interact in real time, with scene types covering slides, quizzes, interactive HTML simulations and project-based learning. Generation runs from a topic or from uploaded materials.
Is OpenMAIC free?
The source is MIT-licensed and free to use, but the generation features call external providers, so you pay those providers for whatever models, search, media and TTS or ASR services you configure. The README states that all provider variables are optional and that you only configure the ones you want.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/thu-maic-openmaic)
Community notes