Sources: Ethan Mollick's LinkedIn post (2026-11-12); the Primer project page from Wharton Generative AI Labs; the wharton-generative-ai-labs/primer README (MIT). Authors named in the post: Lilach Mollick, Ben Przystanski, LJ Ciccarelli, Natalie Bach and Laura Zarrow.
The claim
Simulations are among the best teaching tools, because they make students retrieve what they know, act, and revise based on consequences. They are rarely used because they are expensive to design and build. Primer is an open-source system where an educator describes a lesson in conversation and gets back a playable, AI-run simulation. The pedagogy is written into each agent's instructions, and nothing is built until the educator approves a design document. The release includes the paper, the prompts and the code, plus a final prompt that tells a coding agent to rebuild Primer from the paper: a paper you can run.
Architecture
Two phases, each a pipeline of narrow agents that pass inspectable artifacts rather than sharing one model's memory.
Authoring (educator-facing)
| Agent | Input | Output |
|---|---|---|
| Intake Agent | One-question-at-a-time interview; optional syllabi, lesson plans, rubrics | Goals, student level, prior knowledge, misconceptions, teaching approach, assessment criteria |
| Design Agent | Interview record | Design document: objectives, scenario flow, characters, stakes, adaptation logic |
| Approval gate | Design document | Educator reads it as a lesson plan, revises, approves. Nothing downstream runs before this. |
| Casting Director | Approved design | Role prompts for the mentor, practice and feedback characters |
| Image Generation Agent | Design | Scene visuals |
| Experience Builder | Prompts, images, config | A playable experience assignable to one student or a class |
Runtime (student-facing): three agents in sequence. A mentor activates prior knowledge and surfaces misconceptions. A practice agent plays a counterpart in one of two modes: Roleplay (pursue a goal against a character with its own motives) or Teachback (explain a concept to someone who doesn't get it and revise under questioning). A feedback agent coaches from the transcript, citing specific moments. Each runtime agent has two layers: the in-world character, and an instructional layer that tracks goals, calibrates difficulty and gathers evidence. Educators get per-student and aggregate reports afterwards.
Code: a runtime for config-defined "experiences" (agents with personas and voices, scenes, sound, agent-to-agent flow, tools such as notes, image generation and web search), installable as modules from a registry.
Why the design is right
Backward design as a pipeline. Objectives and evidence of competency are fixed before any scenario exists. That is the standard instructional-design sequence, enforced by stage order rather than by prompting.
Human gate on a readable artifact. The educator approves a document they can read as a lesson plan, not a prompt. This is the general pattern for putting domain experts in control of agent pipelines: make the intermediate artifact native to the expert.
Pedagogy in the instructions, not the model. Default chat models help too fast, drift from the objective and produce roleplay without structure. Writing scaffolding, retrieval and feedback rules into each agent's instructions makes them testable and swappable.
Character and instructor split. Separating what the student sees from what tracks learning lets the simulation stay immersive while still collecting evidence.
Failure modes and caveats
Not evaluated. The project itself says it has not been tested as a learning intervention in classrooms, and not reviewed for FERPA, COPPA or state student-privacy law. Institutions carry that review.
"Model-agnostic" has setup costs. The page says it runs with local or open models. The default deployment requires a funded OpenAI account for the Realtime voice API plus Google OAuth, and Claude is optional. Gemini and local Ollama are documented as extensions. Plan for that work before promising a private, local deployment.
Roleplay risks. Persona agents can still give in to students, leak answers or drift. The instructional layer reduces this but doesn't remove it, and the post publishes no transcripts or failure rates.
The "runnable paper" is expensive. The rebuild prompt can take hours of agent time and paid model usage, and two rebuilds will differ in implementation by design.
Feedback grounded in a transcript is still model judgment. Reports are only as reliable as the feedback agent's reading of the transcript. Spot-check against the educator's own rubric.
Review checklist for adopting it
Read the design document the way you would a colleague's lesson plan: objectives, misconceptions targeted, what counts as evidence.
Red-team the practice agent: try to get the answer handed to you, go off-topic, and push the character to break.
Compare feedback reports with your own grading on a handful of transcripts before trusting the aggregate.
Decide where the student data goes (provider, retention, logs) and get the privacy review done first.
Pin the models per experience, and re-test after any model change.
Bottom line
A careful, open reference design for expert-in-the-loop agent pipelines that happens to be about teaching: interview, readable design document, approval gate, then narrow agents working from artifacts. It is worth studying for the pattern even if you never build a simulation. Treat its learning claims as unproven until there is classroom data.