Codemm is an open-source app for learning to code by practice. Your own coding agent (Claude Code or Codex, with your own account) writes the lessons and exercises. Codemm checks each exercise against its tests, grades your code in a sandbox, and tracks what you've mastered.
Codemm launches your agent; it never calls a model API, and it never reads, stores or asks for credentials. It ships no languages: your agent sets up each language or framework the first time you need it, and Codemm checks that it works.
Related MCP server: Shared Workspace MCP
Connect your agent and let Codemm check this computer (Docker installed, running, and the sandbox working).
Say what you want to learn. Your agent writes a roadmap of topics. You can approve it, ask for changes, or rename, reorder, add and remove topics yourself.
Agree to setup once. Your agent proposes an environment for the language (a Dockerfile, a track.yaml and small probe programs). Codemm shows you the files and builds exactly those, only after you agree, and installs the track only if its probes pass with the network off.
Read the lesson for each topic, and keep notes beside it.
Do the activity. Your agent writes an exercise: a statement, starter code, a reference solution, 2–4 deliberately broken variants, and visible and hidden tests. Codemm accepts it only if the reference passes, the starter fails, and the tests catch every broken variant. You edit the code, use Try it for the visible tests, then Check.
Ask Codemm when you're stuck. It explains and hints; it doesn't edit your code. Skip means "come back later", never "mastered".
What counts. Try it is never recorded. Check records an attempt, except for a check of the unedited starter or one that failed for a reason outside your code (Docker stopped, for example). Mastery moves only on an exercise's first check, or when you beat your best score on it; re-checking a solved exercise adds nothing. Difficulty goes up (to at most 3) after a first-try pass without assistance, and down (to 1) after repeated failures.
Beta builds are on the Releases page. Download the installer for your computer:
macOS (Apple Silicon or Intel): the .dmg. Beta builds are unsigned: open the app once, then choose System Settings, Privacy & Security, Open Anyway.
Windows (x64): the installer. Beta builds are unsigned: in the SmartScreen prompt, choose More info, then Run anyway.
You also need:
Docker Desktop, running. On Windows, use the WSL 2 backend with Linux containers. No Docker? See below.
Claude Code or Codex, installed and signed in. Cursor is experimental.
The app bundles Codemm, so you don't need Node.js, npm or a terminal. The public 1.0 will be signed.
Installing Docker Desktop needs admin rights, which school and work computers often don't give. Without Docker, the desktop app can still run io practice (programs that read input and print output) in interpreted languages that have a WebAssembly (WASI) build, such as Python. It bundles wasmtime, a sandbox that runs as your own user, with no admin rights. In Check this computer, choose Continue without Docker.
For everything else, such as unit tests, frameworks and compiled languages, ask whoever manages the computer to install Docker Desktop once (Docker's terms list education among free uses), or use a computer that has Docker.
Codemm also works directly from your agent in a terminal. This needs Node.js 22 or newer and Docker (or wasmtime 50 on PATH, for the practice above), and installs from source (Codemm isn't on npm):
git clone https://github.com/iignaite/Codemm.gitcd Codemm && npm ci && npm run build && npm linkCheck that Docker and the sandbox work:
codemm doctorThen, in an empty project folder:
codemm initThis sets up Claude Code, Codex and Cursor; use --host claude (repeatable) to pick specific ones. It adds an MCP server entry for each agent, a Codemm section in AGENTS.md, an author subagent and the Claude Code practice hook. Existing config is merged, never replaced. Open the folder in your agent and say what you want to learn.
The practice hook is Claude Code-only, and a practice aid rather than a lock. In Claude Code it blocks the Edit, Write, MultiEdit and NotebookEdit tools on files under exercises/ unless you run codemm assist on (assisted attempts count for less). Writes through the shell aren't blocked. In Codex and Cursor, the instructions in AGENTS.md ask the agent not to edit your files, but nothing enforces it.
Codex loads.codex/config.toml only for projects you've marked as trusted, and asks before each Codemm tool call. To skip those prompts, add default_tools_approval_mode = "approve" under [mcp_servers.codemm]; that also skips your approval for save_track, which runs a network build.
Command | What it does |
| Set up this project for your agent(s) |
| Check Docker and prove the sandbox has no network |
| Your progress and the next step |
| Run the visible tests (not recorded) |
| Run every test and record the attempt |
| Come back to a concept later |
| Let your agent edit exercise files (counts for less) |
| List installed tracks |
| Install a track from a folder |
| Rebuild a track image and re-verify its exercises |
Your agent uses the MCP tools list_tracks, save_track, save_roadmap, get_roadmap, next_step, save_exercise, get_exercise, check, progress, save_lesson, get_lesson and mark_lesson_read.
Verified | Not yet | |
Desktop app | Unit and packaged smoke tests in CI on macOS and Windows | The full journeys with real agents on a packaged build: macOS (D17) and a whole course on Windows (D18) |
Terminal | Claude Code and Codex end to end on macOS with Docker Desktop (1.0 release evidence); core unit tests on macOS, Linux and Windows, and Docker tests on Linux, in CI | Windows with a real agent; Podman; Cursor |
Models | The cross-model bench recommends a minimum model per agent | The bench measured the terminal flow (tutor plus author subagent). The desktop app runs each job separately, with fewer tools, and isn't benchmarked yet. |
Setup runs code your agent wrote, with network access, like npm install in someone else's project. Agree only to setups you'd run yourself. Checks always run with the network off and with memory, CPU, process and time limits.
Grading is on the honor system. Hidden tests are hidden from your agent's tools, not from your computer, and code in the sandbox could fake its own result. Codemm is built for self-learners, not graded classwork.
Codemm proves an exercise is consistent, not that its statement is right. If something reads wrong, tell Codemm.
Docker Desktop can use a lot of memory, up to half of your computer's by default. On a Mac, you can lower it in Docker Desktop under Settings, Resources, Advanced, Memory limit. On Windows with WSL 2, WSL sets this limit instead, also half by default; Docker's settings page points to where to change it. Too low a limit can make setups and checks fail, even for correct code; raise it again if they do.
Your data (tracks, courses and attempt history) lives in ~/.codemm; set CODEMM_HOME to move it. The app keeps your exercise files in ~/Codemm; from a terminal, your project folder holds codemm.json and exercises/.
Architecture: how the parts connect and how the data is stored, with diagrams
Design: the core spec, formats and gates
Desktop design: the app, the agent bridge and the acceptance criteria
Security: the sandbox, trust boundaries and known limits
Bench results: how models from weak to strong do with Codemm
Contributions are welcome. Read CONTRIBUTING.md and AGENTS.md first; Codemm stays small on purpose.
Grade the learner's current code against all tests and record the attempt. Hidden tests report only pass or fail. A quiz is graded once every question is answered, and only its first check is recorded.
Inputs: slug.
Show an exercise to the learner: statement, the file(s) to edit, visible tests and hint; for a quiz, its questions and choices, never the key.
Inputs: slug.
Read a lesson and the learner's notes on it. Records nothing.
Inputs: id (required).
The course roadmap: title, goal, track, style and concepts with their prerequisites, and the track's contract once it's set up.
Inputs: no named parameters.
List installed tracks (language or framework environments) with their versions and test styles.
Inputs: no named parameters.
Record that the learner has read a lesson. Call it only after the learner says they've read it.
Inputs: id (required).
What to do next: setup (install the track), practice an existing exercise, review a mastered concept on an exercise (a check keeps it mastered), author a new one (concept, difficulty, style, track; review: true when it's for a review), learn (lessons only), stuck, or done. On learn, lesson is null when a lesson needs writing, otherwise the earliest unread lesson id. On practice and author, lesson is null when the concept needs a lesson first, or the id of a lesson the learner hasn't read yet; teach before the activity until it's gone.
Inputs: no named parameters.
Course style, mastery, difficulty and covered per concept, and the next step. Covered means at least one lesson, all read.
Inputs: no named parameters.
Author tool. Save an exercise (exercise.yaml, README.md, starter/, solution/, mutants//, tests/visible/, tests/hidden/; a quiz: exercise.yaml, README.md, quiz.yaml). Codemm runs every gate and stores it only if all pass. Returns only the exercise id; report nothing else to the tutor.
Inputs: files (required).
Save a lesson for one roadmap concept: Markdown (at most 64 KB) the learner reads before the activity, and up to 5 runnable examples. Each example is a file map with exactly the track's learner files (for unit, plus tests/ files); Codemm runs each in the sandbox with no input and it must exit 0. Place example N in the Markdown as a fenced block with info string example whose only line is N. An example that needs input goes in a plain code block. Diagrams and charts go in fenced blocks with info string mermaid (flowchart, sequenceDiagram, stateDiagram-v2, classDiagram, pie, xychart), only when a picture teaches better than words; give each an accTitle and accDescr for screen readers. The id must be new in the course.
Inputs: id (required), title (required), concept (required), markdown (required), +1 more.
Create or update the course roadmap and make it active in this workspace. YAML with title (the course's name in a few plain words, at most 60 characters), goal, track (id@version; none for quiz, optional for none), style (io|unit|quiz|none), concepts [{id, title, requires, practice?, pitfalls?, refs?}] and optional sources [{title, url}]; refs are indexes into sources. Keep concept ids stable when you edit it.
Inputs: course (required), roadmap (required).
Install a track: track.yaml, a Dockerfile (a WASI track has none) and probe/ files. Building the image runs the Dockerfile WITH network access (a WASI track downloads its toolchain instead), so only install tracks the learner agrees to. Codemm then runs the probes with the network off and installs the track only if every gate passes; otherwise it returns what failed.
Inputs: files (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 12 tools
The save/get/list pairs (track, roadmap, exercise, lesson) are cleanly separated by resource and direction, and authoring vs. learner-facing tools are clearly distinguished. The one weak boundary is next_step vs. progress, since progress explicitly also returns 'the next step' and both report state, which could cause an agent to pick the wrong one when asked 'what should I do now?'.
Seven tools follow a strict verb_noun snake_case pattern (save_track, get_roadmap, list_tracks, save_exercise, get_exercise, save_lesson, get_lesson) plus mark_lesson_read. The remaining three (check, progress, next_step) break the pattern with bare verbs/nouns, but they remain readable and domain-obvious rather than chaotic.
Twelve tools is well within a healthy range and splits naturally into track/roadmap setup, authoring (exercise, lesson), and learner interaction (get_exercise, check, get_lesson, mark_lesson_read) plus guidance state. Each tool maps to a distinct step in the course lifecycle, with only slight redundancy between next_step and progress.
The surface covers the full authoring-and-learning loop: install/list tracks, save/get roadmap, author/get/grade exercises, save/get/mark lessons, and track progress. Minor gaps exist — no delete or uninstall operations for exercises, lessons, or tracks, and no way to enumerate existing exercises or lessons (agents must rely on next_step/progress to discover them).
Train, evaluate, red-team and deploy AI agents: prompt tuning, LLM-judged evals, katas.
Remote Linux boxes for coding agents: Docker, a browser, screenshots, logs, human takeover.
Practices for building software with coding agents, each with a test you check on your repo.
Autonomous AI developers on your own infrastructure: assign a task, get a pull request.