• What it is
• How it works
• Features
• Getting started
• Architecture
• Project structure
• Design system
• Roadmap
• Contributing
• 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 a GOD orchestration agent in charge — 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, opencode, crush, pi, 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.

• 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 terminal-agent CLI on your PATH: Claude Code (claude, the default command), Antigravity (agy, Gemini), OpenAI Codex (codex), OpenCode (opencode), Crush (crush), or pi.dev (pi). Claude uses native hooks, Antigravity uses the agy-hook bridge, Codex participates through initial-prompt protocol injection plus inbox/outbox routing, and OpenCode / Crush / pi.dev wire in via a native-plugin / proxy / hooks bridge respectively. A missing engine CLI self-heals — the harness runs the installer in the terminal, then auto restart-and-continues into the freshly-installed binary.
• Optional: bring-your-own API keys + local LLMs. For the CLI engines, set per-provider keys and local base-URLs (Ollama / LM Studio / vLLM) in Settings → AI Engines; see the guides on running on open models and running on a Mac Mini.
• Optional: the semantic memory index for instant cross-session recall (the app works without it — markdown memory still functions).

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/Schedules/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

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 in v0.2.0–v0.3.2:

• Talk to Michael — Realtime Michael (v0.3.2) — a low-latency voice channel to the GOD orchestrator (OpenAI Realtime API over WebRTC) next to the async terminal. Michael listens, answers, and acts in real time — reading the hive and, behind spoken echo-back confirmation for destructive verbs, creating/assigning tasks, dispatching, spawning/killing workers, and steering the floor as a distinct michael-voice actor. Greets you on connect, speaks completions the moment they land ("respond when done"), and runs under a live cost meter + spend cap + idle auto-disconnect. BYOK OpenAI key — decrypted main-only, minted into short-lived ephemeral tokens, never read back to the renderer (requires Realtime API access; human-verified end-to-end). Plus Slack hardening (proactive posting off by default, no sends without an explicit thread), a dedicated auto-compact maintenance schedule, and per-agent environment metadata.

• Three more engines — OpenCode · Crush · pi.dev (v0.3.1) — each selectable as a worker and as Michael, via a native-plugin / proxy / hooks bridge, with BYOK keys + local LLMs in Settings → AI Engines, OSS-model quick-picks in Add-Agent, a self-healing engine installer, and a provider-agnostic idle backstop. Two local-setup guides: run on open models · run on a Mac Mini. (Live runtime verification with real model calls is an on-device check pending BYOK keys / a local LLM.)

• Selectable agent engines + per-hire capabilities — a pluggable engine per hire (Claude Code / Antigravity / Codex / local provider) and a swappable Michael engine, each with its own consented skills + MCP catalog.

• Integrations registry + loopback secret broker — write-only secrets, a registry-driven Settings UI, and a first wave of declarative templates.

• Slack-spawned ephemeral workers — Michael spawns an isolated worker from a Slack request, replies in-thread, then tears it down safely (worktree GC + per-worker token caps), surfaced in a Workers tab.

• Temporal date-range skills + worker capability catalog — named windows resolve to concrete ISO dates, and each worker can read exactly what tools/integrations it has.

• Agent Gallery + six off-the-shelf hires — The Hiring Fair rebranded, with a visual Provider/Hive picker in onboarding and add-agent and feature-aware onboarding.

• Wake-reliability hardening — auto-revive wedged terminals, catch up missed schedules, and re-arm the hive message router (draining any mail that piled up) when the machine wakes.

• Shareable hires — import a role-configured agent from a munderdifflin://hire deep link or a local manifest; import pre-fills the Add-Agent modal (the human spawns), and the manifest is validated as untrusted input. Ready-made roles live in the Agent Gallery.

• Heartbeat — scheduler heartbeat that re-engages the floor when it goes quiet, with last/next-fired times surfaced in the Schedules tab.

• Memory reflection — the MemoryReflector summarizes and bounds per-agent memory over time to prevent unbounded growth.

• Persistence — SQLite-backed durable store for window bounds + history across restarts, plus a durable cost ledger and persisted session IDs.

• Hook-driven avatars — broadened hook→station coverage and caged the synthetic demo loop, with new compacting and looping avatar states.

• Multi-provider floor — Claude Code, Antigravity (agy / Gemini), and OpenAI Codex can participate in the same hive (Codex reaches full hive parity via a native lifecycle-hook bridge).

• Dedicated Schedules tab — recurring missions and the adaptive heartbeat have their own Command Center tab.

• Tunnelmole ingress — Slack and generic webhook public URLs use tunnelmole instead of localtunnel.

• Voice dictation (Free Flow) — hold Option to talk; Groq Whisper transcribes speech straight into the message composer (gated on a Groq key, encrypted at rest).

• Enterprise Knowledge Graph — a multimodal store of your own documents/policies/context, with a CLI agents query for ranked passages and full documents.

• Multi-window "floors" — isolated office windows, each with its own set of agents and per-PTY routing.

• Rich message composer — file & image attachments (files button or paste-to-attach) as removable chips above a taller, resizable input.

• Session resume — agents reattach their prior conversation across an app restart, with a per-agent Restart & Continue button; restored workers re-enter their existing worktree.

• Terminal file-drop — drag a file onto an agent's terminal to inject its absolute, shell-escaped path into the session.

Next up:

• More chat integrations — Telegram and richer chat bridges that pipe a channel straight into Michael's queue (and route his replies back out), so you can run the floor from your phone.
• More engines & providers — the engine abstraction is in (Claude Code, Antigravity, Codex, local providers), and v0.3.1 shipped OpenCode, Crush, and pi.dev as worker+god engines with BYOK keys + local LLMs (live runtime verification pending on-device keys). Keep adding engines and broadening the per-hire capability catalog on top of it.
• More integration templates — grow the integrations registry beyond the first-wave templates.
• Fuller avatar coverage — push the remaining station visits and tool-bubbles to be driven 100% by real Claude Code hook events.
• Durable layout & command history — extend persistence to agent layout and per-session command 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.

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.