Munder Difflin: The Open-Source Multi-Agent Harness With 2,500+ GitHub Stars That Turns Your AI Coding Agents Into a Self-Coordinating Team

If you've ever wished your AI coding assistant could hand off work to another AI, remember context across sessions, and coordinate tasks without your constant supervision — Munder Difflin just made that real.

Built by Chaitanya Giri and released under an open-source license, Munder Difflin takes the terminal-based AI coding tools you already use — Claude Code, OpenAI Codex, Antigravity (Gemini), xAI Grok, Kimi Code, Qwen, OpenCode, GitHub Copilot CLI, and more — and turns them into a hive mind of collaborating agents, each with persistent memory, a mailbox, and an avatar on a shared office floor.

With 2,500+ GitHub stars and nearly 800 stars earned in a single day on GitHub Trending, it's clearly hitting a nerve with developers who are tired of AI agents that forget everything the moment you close the terminal.

The tagline says it all: "The world's best agents. The world's worst paper company." — a loving homage to Dunder Mifflin from The Office.

What Is Munder Difflin?

Munder Difflin is a desktop application built with Electron, React, TypeScript, Pixi.js, and xterm.js. It wraps real terminal-agent CLIs as fully capable agents, wires them into a coordination layer, and puts a supervisor agent called "Michael" (your clone) in charge of routing tasks.

Here's the core idea:

• Every terminal is an agent. Each Claude Code, Codex, Grok, or Copilot session runs as a real process in a pseudo-terminal (node-pty), byte-for-byte authentic.
• Every agent is an avatar. Sessions appear as characters on a Pixi.js 2D 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 semantic recall means agents remember across sessions and recall in milliseconds.

# Clone and run
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, an onboarding wizard walks you through setup, then drops you onto the office floor. The GOD agent ("Michael") seats itself in the corner office automatically.

How the Multi-Agent Architecture Works

Munder Difflin uses a layered architecture where data flows from real terminal processes up to a visual renderer:

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

The architecture has three key data planes:

1. Terminal Plane — Each agent runs in its own node-pty pseudo-terminal, rendered via xterm.js. These are real processes producing real output.
2. Hive Plane — A local git repository of plain files: per-agent memory, atomic-file mailboxes, a shared blackboard, and an append-only event log. Single-committer design prevents git index.lock corruption.
3. Renderer Plane — An Electron renderer (React) displays the office floor via Pixi.js and terminal streams via xterm.js, connected through IPC context bridges.

The GOD Agent (Michael)

Michael is the orchestrator. When you give a task, Michael:

• Reads every incoming request
• Resolves routine ones autonomously
• Escalates critical items (spending, destructive operations, scope changes) to your approvals queue
• Routes sub-tasks to the right specialist agents

You can talk to Michael directly, or press Talk and run the floor by voice.

Memory That Actually Persists

Perhaps the most impactful feature is the memory layer. Every agent in Munder Difflin has:

• Markdown-first storage — Memory is stored as plain markdown files in a git repo, grep-able and openable in Obsidian
• Semantic recall index — An optional vector index mines markdown memory into a searchable "palace" with millisecond recall
• Cross-session continuity — Close a session, reopen it tomorrow, and the agent remembers everything
• Cross-agent sharing — Agent A's discoveries become available to Agent B through the shared hive
• Condensation — Memory doesn't grow forever; periodic condensation keeps it manageable

// Memory is just files — no vector database required
.ai-memory/
├── agents/
│   ├── claude-frontend/
│   │   ├── memory.md          # Agent's long-term memory
│   │   └── handoff.md         # Pending handoff notes
│   └── codex-backend/
│       ├── memory.md
│       └── handoff.md
├── blackboard.md              # Shared context board
└── events.log                 # Append-only event log

The Visual Office Floor

What makes Munder Difflin truly unique is the 2D office floor visualization powered by Pixi.js. Every agent session appears as an avatar character that:

• Walks to a station when it starts working on a task
• Sends flying envelopes when messaging another agent
• Reflects real work state — idle, working, blocked, or messaging

It's not just a gimmick. The visual layer gives you at-a-glance situational awareness of what your entire agent team is doing — something you simply can't get from ten terminal windows side by side.

The floor also includes:

• A built-in Monaco IDE with file tree, editor tabs, and git integration
• CHANGES · HISTORY · COMPARE git rails with commit graph and diffs
• A Command Center with Kanban tasks, scheduled missions, and activity logs
• A Skills catalog of 227+ browsable skills with search, filters, install, and uninstall

Supported AI Agents and Bring-Your-Own-Keys

Munder Difflin supports an impressive roster of AI coding agents:

All agents use bring-your-own-keys (BYOK) — per-provider keys stored in a write-only secret broker. Local LLMs are also supported via Ollama, LM Studio, or vLLM base URLs.

Real-World Example: Building a Full-Stack Feature

Imagine you need to add a payment integration to your SaaS app. Here's how Munder Difflin handles it:

You: "Add Stripe checkout to the pricing page"

Michael (GOD agent):
  → Spawns Agent A (Claude Code) for frontend React component
  → Spawns Agent B (Codex) for backend API route
  → Spawns Agent C (Copilot) for test coverage

Agent A writes the Stripe checkout button component
  → Sends message to Agent B: "Need POST /api/checkout endpoint"

Agent B builds the Stripe session creation endpoint
  → Sends message to Agent C: "New files: routes/checkout.ts, components/Pricing.tsx"

Agent C writes integration tests for both
  → Reports back: "All 12 tests passing"

Michael: "Feature complete. 3 files changed, 12 tests passing.
          Ready for your review."

Throughout this process:

• Each agent remembers the project architecture from previous sessions
• Agents coordinate through the hive without your intervention
• You watch avatars work on the office floor, envelopes fly between desks
• If Agent B encounters a schema conflict, Michael escalates to you with context

Safety and Human Oversight

Munder Difflin takes safety seriously with a layered control system:

• Human gates — Spending, scope changes, and destructive operations escalate to you. You can steer mid-run or stop gracefully.
• Circuit breaker — A steer → constrain → stop ladder for agents that loop, storm errors, or exceed their budget.
• Budgets & telemetry — Per-agent token budgets, real cost tracking from transcripts, a durable ledger, OpenTelemetry spans, and a tool waterfall view.
• Per-agent git worktrees — Optional isolation so parallel agents never collide on branches.

Key Benefits

• True multi-agent coordination — Agents collaborate autonomously through messaging, memory, and a shared blackboard
• Works with your existing subscriptions — Uses the AI coding CLIs you already pay for, within their hourly limits
• Persistent memory across sessions — Markdown-first storage with optional semantic recall; no vector database required
• Visual situational awareness — 2D office floor shows agent activity at a glance
• 10+ supported AI agents — Claude Code, Codex, Gemini, Grok, Kimi, Qwen, OpenCode, Copilot, and more
• Cross-platform — macOS (signed & notarized), Windows, and Linux
• Local-first — Everything runs on your machine; no cloud dependency
• Bring-your-own-keys — Your API keys stay in a write-only secret broker
• Enterprise Knowledge Graph — Your own documents and policies, queryable by any agent
• Slack & webhook integration — Message channels or POST webhooks; agents can spawn ephemeral workers

Getting Started

To try Munder Difflin, you need:

• macOS, Windows, or Linux
• Node.js 18+ and npm
• A C/C++ toolchain (for node-pty's native addon — on macOS: xcode-select --install)
• At least one supported agent CLI on your PATH

# Clone and launch
git clone https://github.com/chaitanyagiri/munder-difflin.git
cd munder-difflin
npm install
npm run dev

# Or download signed builds from the releases page:
# https://github.com/chaitanyagiri/munder-difflin/releases/latest

The onboarding wizard handles the rest, including checking which supporting tools you have and offering to install missing ones.

Frequently Asked Questions

Is Munder Difflin free to use?

Yes, Munder Difflin is completely free and open source. However, you still need to pay for the AI provider subscriptions you already use (Claude Code, Codex, etc.). Munder Difflin itself costs nothing — it orchestrates the tools you already have.

Do I need all 10+ agent CLIs installed?

No. You only need at least one supported agent CLI. The onboarding wizard shows which tools you have and what each is for. Missing CLIs can self-heal — the harness runs the installer in the terminal and continues.

Does Munder Difflin send my code to the cloud?

No. Everything runs locally on your machine. Your API keys are stored in a write-only secret broker, and all agent communication happens through a local git repository. There is no cloud dependency.

How does memory work without a vector database?

Memory is stored as plain markdown files in a git repository — grep-able, openable in Obsidian, and backup-friendly with rsync. An optional semantic recall index provides millisecond search, but it's not required. The system works perfectly with just markdown files.

Can agents from different providers work together?

Absolutely. That's the whole point. You can have Claude Code handling frontend, Codex handling backend, and Copilot writing tests — all coordinating through the hive's messaging and memory system. Michael routes tasks to the most appropriate agent.

What happens if an agent goes off track?

Munder Difflin has a circuit breaker system: a steer → constrain → stop ladder. If an agent loops, generates excessive errors, or exceeds its token budget, the system progressively constrains and eventually stops it. Critical decisions always escalate to you.

Is it compatible with local LLMs like Ollama?

Yes. Munder Difflin supports local LLMs through Ollama, LM Studio, or vLLM base URLs. You can configure these in Settings → AI Engines alongside your cloud provider keys.