Start building with Muse Ember, our smallest, most efficient model

Copy the starter kit from the cookbook and clone the Python reference:

shell
git clone --depth 1 https://github.com/meta-models/meta-model-cookbook.git
cp -r meta-model-cookbook/08_muse_ember/01_python_to_rust/starter-kit pygments-port
cd pygments-port
git clone https://github.com/pygments/pygments.git && git -C pygments checkout --detach a43b45dc
git init -q && git add -A && git commit -q -m "Starter kit"
(cd pygments-rs && cargo test --release)

Start Muse Code with Muse Wonder as the main model:

shell
muse --model muse-wonder-1.0 \
  --reasoning-effort high \
  --agents "$(cat ../meta-model-cookbook/08_muse_ember/01_python_to_rust/agents/agents.json)" \
  -c agents.execution_capacity=17 \
  --parallel-tool-calls \
  --sandbox-network restricted \
  --trust-workspace \
  --approval-mode never

The --agents flag loads the worker definition from the cookbook's agents/agents.json:

none
{
  "port-worker": {
    "description": "Does one well-scoped coding task given in full in its input. Edits only the files the input names, runs the checks the input gives, and commits.",
    "model": "muse-ember-1.0",
    "effort": "max",
    "prompt": "Your input is a complete task brief from the planner. It names the files you own, what to do, and the commands that check your work, each with one exact expected last line. Do the task editing only your owned files. Search and read only inside your workspace or worktree and the pinned pygments/ clone; never search the filesystem root, your home directory or other checkouts. Never run find, locate, grep -r, du or any other recursive scan outside this checkout and its worktrees: scans outside the checkout can hang. Up to 16 workers build on this machine at once: keep build parallelism modest and never override CARGO_BUILD_JOBS from the environment. Run each check once after your last edit. When every check's last line matches its expected line, commit only your owned files in your worktree with a message that starts with the step id, then delete your own worktree's target/ directory (never the main checkout's) and report; never re-run a passing check. If an edit fails with \"no exact match\", re-read that exact file before editing it again. If the same edit, command or failure repeats 3 times, stop, commit what you have with the prefix \"wip:\", and report BLOCKED with the last failing line. Never edit a file the brief does not give you; if the task needs one, stop and report the exact change and why. Before your final answer, stop every command and background process you started. The first line of your final answer is always STATUS: COMMITTED <hash> or STATUS: BLOCKED <reason>; never end without it. Then at most 10 lines: the step id, files changed and the last output line of each check. Never claim a result you did not run.",
    "maxTurns": 120
  }
}

The file also defines general-purpose with the same settings, so any agent Muse Wonder starts without naming a type still runs on Muse Ember.

Then paste the three prompts in order:

• Prompt 1: A worker builds the checker, another worker reviews it, and Muse Wonder runs the checks.
• Prompt 2: Muse Wonder plans the handoffs and supervises the 16 parallel ports.
• Prompt 3: The agents score 62 held-out files they never saw.

Prompts 1 and 3 are in the cookbook. Prompt 2 is where Muse Wonder plans, hands off and supervises. Here are its key lines (the full prompt is in the cookbook):

none
Port these 16 lexers: java, c, cpp, csharp, go, rust, javascript, lua, swift,
kotlin, scala, perl, css, haskell, sql, r. Use Muse Ember port-workers for the
coding work; you own the plan, shared engine readiness, handoffs and supervision.
​
… Workers do every source read, diff, merge and long check; you never open source
files or diffs.
​
Before deciding the plan, have one worker read the Python reference
implementations, the Rust engine and its tests, and the checker, and return a map
of at most 60 lines: how each lexer maps onto the engine, what shared capabilities
are missing, the gotchas, and what context each worker needs. Write the plan from
it and include concrete source paths, ownership, relevant engine interfaces and
validation commands in each handoff, so workers don't rediscover the gotchas.
​
Have a worker port Python as the example, and start the input writers at the same
time. … Brief a worker for each shared engine gap while the example runs. …
​
… Each porter works in its own git worktree, one per language, and owns only its
lexer file. … It commits only when Rust is no slower than Python and otherwise
reports BLOCKED. …
​
While the porters run, act on STATUS lines. When a worker reports a blocker
outside its files, start the shared fix before waiting on anyone else. … Never
weaken the checker, drop test inputs, or treat partial results as success.
​
One merge worker owns all merging … After the merge you run each benchmark once on
the merged tree. …
​
… Once provided, score heldout/<alias> for each language without code changes in
response. … Stop with the report: no extra languages, PRs or pushes.

When the run finishes, check any language yourself:

shell
python3 pygments-rs/tools/diff.py --lexer go    # SCORE line should show fail=0
python3 pygments-rs/tools/bench.py --lexer go   # checks the tokens match, then times Python and Rust