v0.3.7Fewer approval prompts, fewer wasted tokens, fewer runs that stop halfway · mu-agent 0.3.7
mu

Most of what your agent decides isn't code

Does this output matter? Is this command safe? Is the work really done? mu hands these yes/no calls to a small model at 40 decision points, so fewer tokens go to waste, fewer approvals get clicked through unread, and fewer runs stop halfway. The main model keeps its attention on the code.

Terminal-Bench 2.1, same model, same tasks: mu passed 68.2% of attempts, pi 58.7% (+9.5 points, 95% interval +3.8 to +15.2). How it was measured

$ npm i -g mu-agent

Needs Node.js 22.19 or newer. Run mu setup once to connect a model, then mu in a project folder.

The mu desktop app after a bug fix: the conversation in the middle, the Judge tab on the right listing each of the judge's verdicts with its decision point and time, and the kernel bar along the bottom The mu desktop app after a bug fix: the conversation in the middle, the Judge tab on the right listing each of the judge's verdicts with its decision point and time, and the kernel bar along the bottom
Watch a turn

Judge first, then act

~/code/relay — mu
 Running the tests again.


 $ npm test

 ... (19 earlier lines, ctrl+o to expand)
 ℹ fail 0
 ℹ cancelled 0
 ℹ skipped 0
 ℹ todo 0
 ℹ duration_ms 78.95525

 Took 0.3s


 Fixed. A minute was defined as 1,000 ms, so 1h30m was read as one hour and 30
 seconds, and the worker aborted the job then.

 - src/config/duration.js: the m unit is now 60_000.
 - npm test: all 13 tests pass.

 Backoffs in minutes were read the same way: the exports queue (backoff: "2m")
 retried after 2 seconds, and now waits 2 minutes.

────────────────────────────────────────────────────────────────────────────────────
 
────────────────────────────────────────────────────────────────────────────────────
~/code/relay (main)
↑27k ↓318 0.6%/1.0M (auto)                                      mimo-v2.6-pro • high
Jev 1.13 (free): multi-step task · full effort · 262 ms Permissions: Judge mode
In this recording, the coding model's replies are scripted; the judge's answers are live.
The Hive tab in the desktop app: three bees investigate one bug at once; the arrows are findings delivered from one bee to another
The plain-language board: what's being done, how far it got and the running account below

When you send a message

The judge reads it first

Is this a new task, a follow-up or a correction? Should a message that arrives mid-run interrupt now? Does it need skills and tools, or will a one-line answer do?

◆ Jev multi-step task · full effort · 262 ms

In this turn, the user writes "Jobs with `timeout: "1h30m"` in relay.config.json get killed after about an hour. Find out why, fix it and make sure the tests pass.", and in under a second the judge answers: a multi-step task, full effort. Skills and MCP servers the task doesn't need stay out of the context until it does.

When a tool returns

Output goes through the judge first

A test run or a search can easily return hundreds of lines. The judge decides, chunk by chunk, what matters now; only that enters the context, and the rest is archived behind a pointer, ready when it's needed.

In web pages and MCP results, instructions aimed at the model are withheld before it reads them.

Before acting

Block what's risky, ask only when it matters

Before a command runs, rules flag anything risky, and the judge checks that you asked for it and that it doesn't cross a constraint you stated. There are three permission modes (Full access, Judge mode and Ask first), and you can switch at any time. In Judge mode, the judge lets through what the task clearly needs and asks you about the rest.

When the turn ends

Done means verified

When the model says it's done, mu checks whether anything verified that, whether the turn drifted and whether to go back to a checkpoint.

/goal <condition> keeps the agent working until the condition holds. The main model checks whether it does, with the judge as the fallback; when the same error comes back again and again, the judge decides whether the approach is a dead end.

The hive

Several bees at work, the judge in the middle

When several agents work on one hard problem, splitting up the work is easy; communication is hard. Say nothing, and each walks into the same dead end. Say everything, and every context fills with the others' chatter.

In mu's hive, the judge weighs every finding: is it worth sharing, and could it matter to a given bee? Unless the judge is sure it doesn't, the finding reaches that bee as context, marked as a finding, not an instruction. When a later finding overturns an earlier one, the correction goes to every bee that heard it.

The plain-language board

Working and reporting are different jobs

Models get stronger, and their reports read more and more like notes for a machine. In mu the working model keeps working its own way. Every few tool calls, the judge checks what happened, picks what's really news and hands it to a model chosen for writing plainly, which tells you where things stand.

When a run ends, you see not just "done" but what was actually done.

What mu doesn't do

01

Fewer interruptions

In Judge mode, the judge lets through what the task clearly needs and asks you about the rest.

02

No toolbox in every prompt

Each message is judged: small talk, a follow-up or work to do. Skills and MCP servers that aren't needed stay out of the context.

03

Fewer summaries

When the context grows, stale tool results are dropped instead of summarized, and summary-free compaction is an option. Before the cache expires, mu judges whether a refresh is worth it.

04

No locked-in judge

40 decision points, each with its own switch and its own judge: the free Jev, mude 1.0 on your Mac or any LLM.

05

No judge key needed to start

Without a judge key, the free Jev on OpenCode Zen answers, and mu says so once a day.

06

No new foundation

The command line is built on pi, with its models, extensions, skills and session tree. The desktop app runs the same sessions.

What each of the 40 decision points asks and changes

One set of accounts, settings and lessons for the command line and the app

Import conversationsBring in your Claude Code, Codex and ZCode conversations and carry on in mu.
Subscription sign-inSign in with ChatGPT inside the app; no keys to copy around.
LessonsYour corrections and the traps the agent found a way around are kept; a lesson that is recalled and never followed retires itself.
Built-in browserThe judge drives it step by step: look at the page, decide once, act; it stops to ask before submitting or paying.
A ledger of verdictsEvery verdict and how long it took: /status, mu ledger and the app's Judge tab.
13 interface languagesThe desktop app speaks English, 简体中文, 繁體中文, 日本語, 한국어 and 8 more.

Help make mu better

Image

If mu is useful to you, star it on GitHub

Star on GitHub573