# OpenMAIC Research Paper Title and Academic Citation Guide

> Discover the research paper behind OpenMAIC, titled "From MOOC to MAIC: Reimagine Online Teaching and Learning through LLM-driven Agents." Learn how LLM agents are transforming online education.

- Repository: [MAIC/OpenMAIC](https://github.com/THU-MAIC/OpenMAIC)
- Tags: academic-paper
- Published: 2026-09-04

---

**OpenMAIC is formally documented in the peer-reviewed article "From MOOC to MAIC: Reimagine Online Teaching and Learning through LLM-driven Agents," published in the Journal of Computer Science and Technology (2026) with DOI 10.1007/s11390-025-6000-0.**

The **OpenMAIC** framework bridges traditional MOOCs and AI-driven intelligent classrooms through a multi-agent architecture powered by large language models. The **OpenMAIC research paper** establishes the theoretical foundation for this paradigm shift, while the THU-MAIC/OpenMAIC repository delivers the production-ready implementation of LLM-driven teaching agents, curriculum generation pipelines, and persistent storage systems.

## OpenMAIC Research Paper Publication Details

The academic work formalizing the Multi-Agent Intelligent Classroom (MAIC) concept appears in the *Journal of Computer Science and Technology*. The complete citation provides the definitive reference for researchers implementing or extending the platform.

The paper **"From MOOC to MAIC: Reimagine Online Teaching and Learning through LLM-driven Agents"** establishes the pedagogical framework and technical architecture that the OpenMAIC codebase realizes. Published in 2026, the article is accessible via DOI [10.1007/s11390-025-6000-0](https://doi.org/10.1007/s11390-025-6000-0). According to the repository source code, this citation appears in the main [`README.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/README.md) file at the repository root.

## Mapping the Research Paper to the Codebase

The OpenMAIC implementation directly mirrors the agent-based architecture described in the publication. Specific directories in the THU-MAIC/OpenMAIC repository correspond to key components discussed in the research.

### Documentation and Citation Entry Point

The primary location for academic references is [`README.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/README.md) in the repository root. This file contains the formal citation for the **OpenMAIC research paper**, including the DOI link and bibliographic information required for attribution.

### Multi-Agent Orchestration

The `lib/orchestration/` directory contains the LangGraph-based coordination logic that manages interactions between multiple LLM agents. This implements the "multi-agent" aspect of the MAIC architecture described in the paper, where specialized agents handle curriculum planning, content generation, and student interaction.

### Agent Runtime and Session Management

Core agent execution occurs in `lib/server/agent-runtime/`. This directory houses the durable session runner, skill execution engine, and material handling systems that constitute the "agent workbench" referenced in the research. The runtime manages the lifecycle of teaching agents during active classroom sessions.

### Pluggable Storage Layer

The `packages/@openmaic/storage/` directory provides the abstraction layer for persisting generated educational content. Supporting browser storage, PostgreSQL, and Amazon S3 backends, this package implements the persistent state management required for longitudinal studies discussed in the paper.

### OpenClaw Skill Integration

Agent capabilities are exposed through the OpenClaw protocol defined in [`skills/openmaic/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/openmaic/SKILL.md). This skill definition enables one-click classroom generation from chat applications, realizing the paper's vision of conversational interfaces for educational content creation.

## Implementing the MAIC Architecture: Code Examples

The OpenMAIC SDK translates the theoretical framework into practical TypeScript APIs. The following examples demonstrate the three-stage workflow validated in the research: curriculum outlining, scene generation, and persistent storage.

### Installing the OpenMAIC SDK

Begin by installing the generation and storage packages distributed with the repository.

```bash
npm i @openmaic/generation @openmaic/storage

```

### Generating Course Outlines

The `GenerationClient` class connects to the local OpenMAIC server and creates structured curricula from text prompts. Configure the client with your base URL and preferred LLM provider.

```typescript
import { GenerationClient } from '@openmaic/generation';

const gen = new GenerationClient({
  baseUrl: 'http://localhost:3000/api',
  defaultModel: 'openai:gpt-5.5',
});

async function generateOutline(topic: string) {
  const { outline } = await gen.createOutline({
    material: { type: 'text', content: topic },
    language: 'en',
  });
  console.log('Outline:', outline);
}

generateOutline('Quantum Computing basics');

```

### Creating Interactive Scenes

Transform abstract outlines into concrete educational assets using the `createScenes` method. This generates slides, quizzes, interactive simulations, and PBL activities as specified in the research.

```typescript
async function generateScenes(outline: any) {
  const { scenes } = await gen.createScenes({
    outline,
  });
  console.log('Generated scenes:', scenes);
}

```

### Persisting Educational Content

The `RuntimeStore` class handles long-term storage of generated courses through the pluggable storage layer.

```typescript
import { RuntimeStore } from '@openmaic/storage';

async function saveCourse(scenes: any) {
  const store = new RuntimeStore({ baseUrl: 'http://localhost:3000/api' });
  const courseId = await store.saveCourse({ scenes });
  console.log('Course saved with ID:', courseId);
}

```

This three-step sequence—**createOutline**, **createScenes**, **saveCourse**—embodies the complete agent-driven content generation pipeline evaluated in the research.

## Summary

- **OpenMAIC research paper** title: "From MOOC to MAIC: Reimagine Online Teaching and Learning through LLM-driven Agents"
- **Publication venue**: Journal of Computer Science and Technology (2026), DOI 10.1007/s11390-025-6000-0
- **Citation location**: Root [`README.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/README.md) in the THU-MAIC/OpenMAIC repository
- **Core architecture**: Multi-agent orchestration in `lib/orchestration/`, runtime in `lib/server/agent-runtime/`, and storage in `packages/@openmaic/storage/`
- **SDK workflow**: Generate outlines with `GenerationClient`, create scenes with `createScenes`, and persist via `RuntimeStore`
- **Skill integration**: OpenClaw protocol defined in [`skills/openmaic/SKILL.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/skills/openmaic/SKILL.md) enables chat-based classroom generation

## Frequently Asked Questions

### What is the exact title of the OpenMAIC research paper?

The paper is titled **"From MOOC to MAIC: Reimagine Online Teaching and Learning through LLM-driven Agents."** This peer-reviewed article appears in the *Journal of Computer Science and Technology* and was published in 2026.

### Where can I find the official citation for OpenMAIC?

The official citation including the DOI (10.1007/s11390-025-6000-0) is located in the root [`README.md`](https://github.com/THU-MAIC/OpenMAIC/blob/main/README.md) file of the THU-MAIC/OpenMAIC repository as implemented in the source code.

### How does the OpenMAIC codebase implement the research paper's architecture?

The implementation maps directly to the paper's specifications: `lib/orchestration/` handles multi-agent coordination via LangGraph, `lib/server/agent-runtime/` manages the durable agent sessions described as the "agent workbench," and `packages/@openmaic/storage/` realizes the persistent data layer necessary for longitudinal educational studies.

### What is the core workflow for generating educational content in OpenMAIC?

The SDK implements a three-stage pipeline matching the research methodology: first, `createOutline()` extracts curriculum structure from text prompts; second, `createScenes()` generates rich interactive assets including slides, quizzes, and PBL activities; third, `RuntimeStore.saveCourse()` persists the content to PostgreSQL, S3, or browser storage.