Wake me when it’s done.
Then tell me what it did.
A calm panel appears when your coding agent finishes a turn, saying what it achieved, what it changed and what it would do next. So you can walk away.
It tells youwhat your agent did, not merely that itstopped.
Two agents finishing together do not stack two windows. They queue, with a count you can page through. A pile of windows is the exact anxiety this removes.
1window
500ms
Zero dependencies, and a watchdog that exits whatever happens. Your agent never pauses for Muninn.
0
The payload holds your working directory and your agent’s full output. It stays on the Mac.
2
One sentence for the glance, several paragraphs for the read. The agent writes both; the panel shows the first and the Details window holds the second.
You either watch the terminal scroll, which defeats the point, or you get a ping that tells you nothing, so you open the terminal anyway.
Agents got good enough to work unattended for ten or twenty minutes. The tooling didn’t keep up. Muninn is the thing that tells you what happened — not a usage tracker, not a session monitor, not a chat client. Run it alongside those; it answers a different question.
Three questions, no clicks.
The status word and the agent’s own headline sentence. Readable in three seconds, from across the room.
If the agent is blocked, that takes the headline slot — and the one accent colour lights. Finishing successfully earns no colour at all: colour means you’re needed, nothing else.
The agent’s own next step, so you decide whether to let it run or step in.
Needs a Twilio production key — the sandbox only sends to verified numbers.
Added phone-number verification and got the suite green.
Wire the rate limiter once the key lands.
It doesn’t guess. It asks.
At the end of each turn the agent writes a structured block, and Muninn shows exactly that. Only done is required — an empty field is worse than no field. No block at all? The closing message renders as markdown, flagged “as written”. A missing summary says finished, no summary — never a fabricated one.
```muninn
done: Token refresh now retries once before
failing the session.
changed:
- src/auth/session.ts — token refresh now
retries once
verified: cargo test — 34 passed
next: wire the refresh into the middleware
explain: |
A few paragraphs, for someone who wants
to understand the work rather than only
hear that it finished.
```The panel is that block, rendered.
A Stop hook hands Muninn the agent’s closing message. No polling, no log parsing, no screen scraping. The shim has zero dependencies and exits within 500 ms no matter what — your agent never waits for it. If Muninn isn’t running, the payload spools to disk and is never lost.
One for the glance. One for the read.
done is one sentence on the panel. explain is prose in the Details window — what the problem was, why this approach and not another, what was decided against. Come back from making coffee and actually understand the change, not just be told it landed.
Make session refresh survive one transient failure without logging the user out.
The refresh path treated any failure as terminal, so a single dropped connection logged the user out. The fix retries once with a short backoff before giving up.
I considered queueing refreshes behind a mutex instead, but that holds requests during an outage; a single retry keeps the failure mode simple and the latency bounded.
src/auth/session.ts
cargo test — 34 passed
Verified — reported
tests pass, said by your agent, is a quotation — not a fact.
Muninn quotes your agent. It never vouches for it.
Claims are quoted by the stylesheet itself, so they can never lose their quotation marks. There’s a third register — unquoted, for something Muninn verified first-hand — deliberately reserved and unused, because Muninn checks nothing today.
Too short to leave, too long to watch.
A five-minute turn is too long to watch a log and too short to start anything real. For people who’d rather stay put than context-switch, Muninn can open something to do that asks nothing of you. When the turn ends, the game pauses and banks your score — the summary takes over.
A 5×5×5 volume, not a board.
Every cell has up to 26 neighbours, so a number means something quite different. Drag to orbit, scroll to zoom; a disperse slider pulls the lattice apart to reach the twenty-seven cells a packed cube hides. Openings unfold outward from your click. The first cell is always safe.
125 cells · 20 mines · 26 neighbours
The raven, drifting. Something to watch with your hands still.
A side-scrolling endless runner in Muninn’s palette. No streaks, no leaderboards — something to do, not an achievement system.
Your agent’s output stays yours.
No account, no cloud, no telemetry. The payload — your working directory, your agent’s output — never leaves the Mac.
The receiver binds to 127.0.0.1, requires a token from a 0600-mode file, and rejects anything with an Origin header — a web page can’t post a fake panel.
The hook shim has zero dependencies and exits within 500 ms, whatever happens. Your agent never pauses for Muninn.
Not running? The payload spools to disk and the panel appears at next launch. Built on Tauri; idle CPU indistinguishable from zero.
Two steps, then walk away.
Download Muninn and open it. It lives in the menu bar — no Dock icon.
Click Install hook. Muninn registers Claude Code’s Stop hook for you — everything stays local. That’s it; the next turn that finishes will knock.