Munder Difflin

Agent harness to run an office of your clones

Free, open source and performant — a multi-agent harness that works with the subscriptions you already pay for, on their hourly limits. It turns the terminal coding CLI you already run into a clone of you, one that keeps working while you're away and coordinates a whole office of agents on your own machine.

Wraps Claude Code, Antigravity (Gemini), OpenAI Codex, xAI Grok, Kimi Code, Qwen, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — with bring-your-own keys and local LLMs. Agents that message, route, and remember, coordinated by your clone (Michael) and visualized as avatars at work on a shared office floor.

Electron · React · TypeScript · Pixi.js · xterm.js · node-pty

• What it is
• How it works
• Features
• Getting started
• Architecture
• Project structure
• Design system
• Roadmap
• Contributing
• Telemetry
• License
• Acknowledgements

Munder Difflin is a desktop app that wraps real terminal-agent CLIs as fully-capable agents, wires them into a hive mind, and puts your clone in charge — Michael, the one agent you talk to in order to get things done. Under the hood it runs the fastest memory layer in the world so every agent remembers what it learns and recalls it instantly.

• Every terminal is an agent. Each claude, agy, codex, grok, kimi, qwen, opencode, crush, pi, copilot, or custom session runs as a real process in a pseudo-terminal (node-pty), byte-for-byte authentic, rendered with xterm.js.
• Every agent is an avatar. Sessions appear as characters on a Pixi.js office floor — they walk to stations as they work, and envelopes fly desk-to-desk when they message each other.
• The hive coordinates them. Agents read their memory and drain a mailbox; the router moves messages between inboxes; the GOD agent adjudicates, assigns, and escalates only when it needs you.
• Memory that's instant. A markdown-first memory layer with a semantic recall index means agents remember across sessions and recall in milliseconds.

            you ── talk to ──►  ┌─────────────┐
                                │  GOD agent  │  orchestrator / supervisor
                                │ (Michael's  │  roster · routing · adjudication
                                │   office)   │  blackboard · task ledger
                                └──────┬──────┘
                                       │ assigns · routes · escalates
              ┌────────────────────────┼────────────────────────┐
              ▼                         ▼                         ▼
        ┌───────────┐            ┌───────────┐            ┌───────────┐
        │  agent A  │  message   │  agent B  │  message   │  agent C  │
        │ provider  │ ─────────► │ provider  │ ─────────► │ provider  │
        │  + memory │            │  + memory │            │  + memory │
        └───────────┘            └───────────┘            └───────────┘
              └──────── shared hive: memory · mailbox · blackboard · log ───────┘

1. You spawn agents — each is a normal terminal process (claude, agy, codex, or custom) with its own working directory, identity, and provider-specific lifecycle.
2. Agents collaborate through the hive — a local git repo of plain files. They write to their own outbox/; the harness's router delivers into recipients' inbox/. No agent ever touches git (single-committer design avoids index.lock corruption).
3. The GOD agent runs the floor — it reads every request, resolves routine ones itself (keeping the system fully autonomous), and only escalates critical items (spend, destructive ops, scope changes) into an approvals queue you act on.
4. Everything is visible — you watch avatars move, envelopes fly, and the live terminal stream; you can type back into any session, browse its files, and read its git history.

See HIVE.md for the full multi-agent design, SPEC.md for the terminal/event plane, and DESIGN.md for the visual system.

The floor

• Every terminal is a real agent. Claude Code, Antigravity (Gemini), OpenAI Codex, xAI Grok, Kimi Code, Qwen, OpenCode, Crush, pi.dev, GitHub Copilot CLI, or a custom command — each in its own node-pty PTY, rendered with xterm.js.
• Every agent is an avatar. A Pixi.js office floor where agents walk to stations, envelopes fly desk to desk, and avatar state reflects real work.
• A GOD orchestrator you talk to. It routes tasks, adjudicates traffic, and escalates only what needs a human. Or press Talk and run the floor by voice.
• Per-agent git worktrees. Optional isolation so parallel agents never collide on branches.

Memory & coordination

• The hive — per-agent memory, atomic-file mailboxes, a shared blackboard, an append-only event log, single-committer git.
• Semantic recall — markdown memory mined into a shared palace, searchable from the UI, with condensation so it doesn't grow forever.
• Enterprise Knowledge Graph — your own documents and policies, queryable by any agent.

Control & safety

• Human gates — spend, scope, and destructive ops escalate to you. Steer mid-run or stop gracefully.
• Circuit breaker — a steer → constrain → stop ladder for agents that loop, storm errors, or blow their budget.
• Budgets & telemetry — per-agent token budgets, real cost from transcripts, a durable ledger, OTel spans, and a tool waterfall.

Command Center

• Kanban tasks with dependencies, scheduled missions + heartbeat, live fleet monitoring, memory search, activity log, and a CI watcher.
• Skills — what every agent can already do across Claude Code, OpenCode and Codex, plus a browsable catalog of 227 more with search, filters, install and uninstall.
• Built-in Monaco IDE — file tree, editor tabs, save, plus CHANGES · HISTORY · COMPARE git rails with commit graph, diffs, branch compare, and guarded checkout. All fs/git access brokered through main.

Getting work in and out

• Slack & webhooks — message a channel or POST a webhook; Michael can spawn an ephemeral worker, reply in-thread, and tear it down.
• Shareable hires + Agent Gallery — import a role from a munderdifflin://hire link; import only pre-fills the form, a human still spawns it. Browse roles at the Agent Gallery.
• BYOK keys + local LLMs — per-provider keys in a write-only secret broker, plus Ollama / LM Studio / vLLM base URLs. Guides: open models · Mac Mini.
• Auto-update — new releases download in the background; you click restart, and the notes arrive as a designed page rather than a version number.
• Prerequisites — one Settings page showing which supporting tools (uv, git, Node, MemPalace, each agent CLI) you have, what each is for, and a button that asks Michael to install what is missing.

• macOS, Windows, or Linux.
• Node.js 18+ and npm.
• A C/C++ toolchain for node-pty's native addon — on macOS, install Xcode Command Line Tools:

  xcode-select --install

• At least one supported agent CLI on your PATH — Claude Code (claude, the default), Antigravity (agy), OpenAI Codex (codex), xAI Grok (grok), Kimi Code (kimi), Qwen (qwen), OpenCode (opencode), Crush (crush), pi.dev (pi), or GitHub Copilot (copilot). Most missing CLIs self-heal: the harness runs the installer in the terminal and continues into the new binary.
• Optional: your own API keys and local LLMs in Settings → AI Engines (Ollama / LM Studio / vLLM).
• Optional: the semantic memory index for instant cross-session recall — markdown memory works without it.

git clone https://github.com/chaitanyagiri/munder-difflin.git
cd munder-difflin
npm install        # postinstall rebuilds node-pty against Electron's ABI
npm run dev        # launches the Electron app with hot reload

On first launch you'll go through the onboarding wizard, then land on the floor. Use Add agent to spawn your first session — the GOD agent seats itself in Michael's office automatically.

npm run build      # production build via electron-vite
npm run preview    # preview the production build
npm run typecheck  # type-check the node (main/preload) and web (renderer) projects

If node-pty fails to load after an Electron upgrade, re-run npm install (the postinstall hook runs electron-rebuild against the current Electron ABI).

Two data planes feed one renderer:

┌───────────────────────────────────────────────────────────────┐
│                     Electron Renderer (React)                  │
│   ┌──────────────────┐    ┌──────────────────────────────┐    │
│   │ Office Floor      │    │ Terminal + Command Bar       │    │
│   │ (Pixi.js)        │    │ Files + Git tabs (xterm.js)  │    │
│   └─────────▲────────┘    └────────────▲─────────────────┘    │
│             │ avatar state             │ pty bytes / fs / git  │
└─────────────┼──────────────────────────┼───────────────────────┘
              │ IPC (contextBridge: window.cth)
       ┌──────┴──────────┐        ┌──────┴─────────────┐
       │  Event Plane    │        │  Terminal Plane    │
       │  hooks / hive   │        │  node-pty PTYs     │
       │  router + GOD   │        │  + fs + git        │
       └────────▲────────┘        └──────▲─────────────┘
                │ hook payloads          │ stdin / stdout
                └─────────┬──────────────┘
                   ┌──────┴──────────────┐
                   │ claude / agy / codex│
                   └─────────────────────┘

• Terminal plane. The main process owns a PtyManager that spawns each agent as a node-pty process and streams output over per-id IPC (pty:data:<id>). The renderer talks only through a typed window.cth bridge (src/preload/index.ts), which also exposes sandboxed filesystem and git helpers.
• Hive / event plane. hive.ts is the on-disk multi-agent layer; hooks.ts runs the hook server that provider bridges POST lifecycle payloads to (cth-hook for Claude Code, agy-hook for Antigravity). memory.ts wraps the semantic memory CLI. The router delivers messages, drains provider outboxes, the GOD agent adjudicates, and idle/inbox wakeups keep workers draining mail.

src/
  main/                      Electron main process (Node)
    index.ts                 window, IPC handlers, quit guard
    pty.ts                   node-pty manager (spawn/write/resize/kill/stream)
    hive.ts                  on-disk multi-agent layer (memory, mailboxes, router)
    hooks.ts                 hook server + provider hook shims (`cth-hook`, `agy-hook`)
    memory.ts                semantic memory layer (CLI wrapper, degrade-to-noop)
    config.ts                harness config persistence + home setup
    transcript.ts            reads ~/.claude/projects/ JSONL transcripts for real token/cost telemetry
    telemetry.ts             live OTel collector + usage/cost feed for observability
    usage.ts / pricing.ts    UsageProvider seam + per-model cost attribution
    breaker.ts / control.ts  cost/runaway circuit breaker (steer/constrain/stop) + HITL gate / steer / stop
    reflect.ts               MemoryReflector — memory condensation
    db.ts                    SQLite durable store (window bounds + history) + durable cost ledger
    github.ts                GitHub issue + CI run ingestion via the gh CLI
    shellEnv.ts              resolve PATH and shell env for child processes
    fs.ts / git.ts           sandboxed filesystem + git bridges
  preload/                   contextBridge → typed window.cth API
  renderer/src/
    App.tsx                  top-level layout + wiring
    design/                  tokens.css / tokens.ts / global.css (design source of truth)
    components/              PixelPanel, AgentDetailPanel, CommandBar, ApprovalsPanel, MemoryPanel, …
    CommandCenterPanel,      Michael's control surface (Terminal/Floor/Memory/Activity/Tasks/Triggers/Handbook tabs)
    ToolWaterfall,           per-agent tool-span waterfall for the observability view
    TasksKanban,             dependency-aware kanban board (Tasks tab)
    ThreadsPanel,            hive message conversation viewer (Messages tab)
    MessageQueueComposer,    park messages for a busy agent
    scene/office/            Pixi office floor: OfficeFloor, Character, Camera, cast, pathfinding, …
    store/ · hooks/          zustand store, event loop, PTY parser, typewriter
    assets/                  tilesets, maps, character sheets (see ATTRIBUTION.md)
docs/                        `logo.png`, `banner.png`, landing page (GitHub Pages → munderdiffl.in)
docs/media/                  `og.png` (social previews) + rendered Remotion clips
landing-remotion/            Remotion project that renders the landing page's "how it works" clips
HIVE.md · SPEC.md · DESIGN.md   multi-agent · terminal/event · visual design
docs/message-queue.md        who may type into an agent's terminal, and when

The aesthetic is Animal Crossing × Earthbound × SNES menu UI — pixel-snapped, chunky, friendly. DESIGN.md is canonical; every component derives from its tokens. The Munder Difflin brand layers a Dunder-Mifflin maroon (#6E1423) and gold (#F4D35E) on top for logo and chrome. The 15 avatars are the cast of The Office, differentiated by hair/skin/shirt recipes.

Shipped through v0.4.3 — ten agent engines with BYOK keys and local LLMs, voice orchestration, the hive (memory · mailboxes · blackboard · event log), Command Center with kanban and schedules, a built-in Monaco IDE with git rails, integrations registry + secret broker, Slack-spawned workers, shareable hires and the Agent Gallery, observability and the circuit breaker, durable persistence, session resume, multi-window floors, and working auto-update. Full history in CHANGELOG.md.

Next up:

• More chat integrations — Telegram and richer chat bridges that pipe a channel into Michael's queue and route replies back out.
• More engines & integration templates — keep growing the engine roster and the integrations registry.
• Fuller avatar coverage — drive the remaining station visits and tool-bubbles entirely from real hook events.
• Durable layout & command history — extend persistence to agent layout and per-session history.

Contributions are welcome — this is an early prototype with a lot of surface area. Start with CONTRIBUTING.md. The short version: fork, npm install && npm run dev, keep npm run typecheck green, and derive any new UI from DESIGN.md tokens. Good first areas: wiring real hook events, the add-agent flow, the config drawer, and cross-platform work.

Questions, bugs, or want to show off your office? Join the Discord: https://discord.gg/SEDzP5ZPk5. Add your Discord handle to a PR and you'll get the employee of the month role when it merges.

Official builds send a small set of anonymous usage events (app opened, agent spawned, feature used) — never prompts, code, file paths, or agent output. The complete event list, the anonymity guarantees, and the three ways to opt out (Settings toggle, DO_NOT_TRACK, or building from source — forks compile with no key and send nothing) are documented in TELEMETRY.md.

The source code is licensed under the MIT License — see LICENSE. The MIT grant covers the code only; the non-commercial asset restriction above is carved out in the LICENSE scope note. Munder Difflin is an affectionate parody and is not affiliated with NBC's The Office or Dunder Mifflin.

• LimeZu — pixel-art tilesets and character base sheets.
• shahar061/the-office — office tileset/map vendoring.
• Pixi.js · xterm.js · node-pty · electron-vite · CodeMirror — the libraries this is built on.
• Remotion — the landing page's animated "how it works" clips (landing-remotion/).
• The Office (US) — for Munder Difflin, Inc.