an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
feat(blog): add 15 non-technical posts (#28-37,42-44,48,52)
Chaitanya Giri2fc7d3302bc3
diff --git a/blog/src/posts/ai-agent-glossary.md b/blog/src/posts/ai-agent-glossary.mdnew file mode 100644index 00000000..e124669a--- /dev/null+++ b/blog/src/posts/ai-agent-glossary.md@@ -0,0 +1,110 @@+---+title: "The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent"+description: "Plain-English definitions of the AI coding agent terms everyone trips over — harness, orchestrator, hive, subagent, agent memory — each in one line."+date: 2026-06-02+category: concepts+categoryLabel: Concepts+type: Non-technical+primaryKeyword: "multi-agent ai framework"+secondaryKeywords: ["ai agent glossary", "orchestrator vs harness", "agentic terms"]+tags: ["Concepts", "Multi-Agent", "Glossary", "Getting Started"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What's the difference between an agent harness and an agent framework?"+ a: "A framework (LangGraph, CrewAI) is a library you build an agent application with from scratch. A harness wraps agents you already run — like Claude Code sessions — and adds coordination on top, without rebuilding the agent."+ - q: "What's the difference between an orchestrator and a harness?"+ a: "A harness is the whole coordination layer — memory, messaging, visibility, and routing. An orchestrator is one part of it: the coordinator that decomposes intent and routes work to the right agents."+ - q: "What is a hive of agents?"+ a: "A hive is a coordinated group of agents that share memory and message each other, behaving as one team rather than isolated sessions. It's the running 'team' a harness manages."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>The agent world is thick with jargon —+<strong>harness</strong>, <strong>orchestrator</strong>, <strong>hive</strong>,+<strong>subagent</strong>, <strong>agent memory</strong>. Here's each term in one quotable line, so+you can read (and write) about [multi-agent AI](/blog/what-is-a-multi-agent-harness/) without+tripping. Bookmark it.</p></div>++Every fast-moving field grows its own vocabulary, and AI coding agents have grown a lot of it fast.+This is a snackable reference: each term defined in a sentence you could quote, with a link out when+there's more to say.++## Core building blocks++### Agent+**An agent is a running AI session with a goal and tools — it reads, acts, and repeats in a loop until+the task is done.** In practice, each [Claude Code session](/blog/what-are-claude-code-agents/) is an+agent.++### Subagent+**A subagent is a short-lived helper an agent spawns inside its own run to fan out a piece of work.**+Great for parallelism within one task; it doesn't persist or share memory across your whole workflow.++### Tool+**A tool is a capability an agent can call — read a file, run a command, search the web.** Tools are+what let an agent *do* things instead of just talk.++## The coordination layer++### Harness+**A harness is the software that wraps the agents you already run and coordinates them — roles,+messaging, memory, orchestration, and visibility.** It's the layer that turns several sessions into a+team. More: [what is a multi-agent harness](/blog/what-is-a-multi-agent-harness/).++### Framework+**A framework is a library you build an agent application *with*, from scratch (LangGraph, CrewAI,+AutoGen).** A harness wraps agents you have; a framework is how you'd build one.++### Orchestrator+**An orchestrator is the coordinator that decomposes your intent and routes work to the right+agents,** escalating only the critical decisions. In Munder Difflin it's the [GOD agent](/#how) you+talk to in plain language.++### Hive+**A hive is a coordinated group of agents that share memory and message each other, acting as one+team.** It's the running "office" a harness manages.++## Memory & messaging++### Agent (long-term) memory+**Long-term memory is durable storage an agent reads on startup and writes to as it learns, so+knowledge survives between sessions.** Without it, agents start cold every run — see [how to give+Claude Code long-term memory](/blog/give-claude-code-long-term-memory/).++### Semantic memory+**Semantic memory lets an agent recall notes by *meaning* rather than filename — embed the notes,+fetch the few most relevant.** It's what keeps recall instant as the knowledge base grows.++### Mailbox / inter-agent messaging+**A mailbox lets one agent hand a message or result to another directly, instead of routing through+you.** It's how a hive coordinates without a human courier.++## Workflow patterns++### Git worktree+**A git worktree is a separate working copy of one repo, so parallel agents edit isolated checkouts+and don't clobber each other.** A common foundation for [running agents in+parallel](/blog/how-to-run-multiple-claude-code-agents/).++### Human-in-the-loop+**Human-in-the-loop means the system pauses for your approval on the decisions that matter — spend,+destructive actions, scope — and runs autonomously otherwise.**++### Local-first+**Local-first means the harness, agents, and memory run on your own machine,** for privacy,+predictable cost, and offline capability — [why that matters](/blog/why-local-first-matters-for-ai-agents/).++## Putting it together++In one sentence using all of it: *a **harness** runs a **hive** of **agents** (each its own loop with+**tools**), gives them shared **semantic memory** and **mailboxes**, and lets an **orchestrator** route+work — **local-first**, with a **human in the loop** for the critical calls.*++If any term sparked a "wait, which tool does that?", the [roundup of multi-agent Claude Code+tools](/blog/best-claude-code-multi-agent-tools/) maps the vocabulary onto real software.++---++Munder Difflin is a harness, a hive, an orchestrator, and shared memory in one local app. [Download+Munder Difflin](/#install) to see the glossary come to life — free and open source.diff --git a/blog/src/posts/best-claude-code-multi-agent-tools.md b/blog/src/posts/best-claude-code-multi-agent-tools.mdnew file mode 100644index 00000000..2538ea5e--- /dev/null+++ b/blog/src/posts/best-claude-code-multi-agent-tools.md@@ -0,0 +1,166 @@+---+title: "The Best Tools to Run Multiple Claude Code Agents (2026)"+description: "An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared."+date: 2026-06-04+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "best claude code multi-agent tools"+secondaryKeywords: ["claude code multi-agent tool", "agentic coding tools", "best tools to run multiple claude code agents"]+tags: ["Comparisons", "Multi-Agent", "Claude Code", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is the best tool to run multiple Claude Code agents?"+ a: "There's no single best — it depends on what you want. Claude Squad is the leanest terminal option; Conductor is the most polished on macOS; Crystal is a good open-source desktop GUI; vibe-kanban gives you a task board; and Munder Difflin adds shared memory, inter-agent messaging, and a GOD orchestrator so the agents act as one coordinated team."+ - q: "Are these Claude Code multi-agent tools free?"+ a: "Most are free and several are open source (Claude Squad, Crystal, vibe-kanban, and Munder Difflin are open source; Munder Difflin is MIT-licensed). Conductor is a free, native macOS app. Always check each project's current license and pricing before you commit."+ - q: "Do I need a multi-agent tool to use Claude Code?"+ a: "No. One Claude Code session handles most tasks. You start wanting a multi-agent tool once you're running three or more sessions at once and the coordination overhead — who's doing what, who knows what, who edits which file — starts costing you time."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>The tools for running+<strong>multiple Claude Code agents</strong> fall into three camps: <strong>terminal session+managers</strong> (Claude Squad), <strong>parallel-worktree desktop apps</strong> (Conductor,+Crystal), <strong>task boards</strong> (vibe-kanban), and <strong>coordinated hives</strong> (Munder+Difflin). The first three help you run agents <em>side by side</em>; a hive adds shared memory,+messaging, and an orchestrator so they run <em>as a team</em>. Pick by how much coordination you+actually need.</p></div>++If you've outgrown a single Claude Code window, the next question is *which tool* helps you run+several at once without the chaos. The landscape moved fast in 2025–2026, so here's an honest,+plain-English roundup of the main options — what each does well, where it stops, and who it's for.++> **A note on fairness:** this space changes quickly. Features, platforms, and licenses below are+> accurate to the best of our knowledge at the time of writing — always check each project's repo or+> site for current details. Munder Difflin is our own tool; we've tried to describe the others on+> their own terms, not as straw men.++## The four shapes of "multi-agent Claude Code"++Before the tools, the categories — because they answer different questions:++- **Terminal session managers** run each agent in its own shell and let you switch between them from+ one keyboard-driven interface. Minimal, fast, SSH-friendly.+- **Parallel-worktree desktop apps** give each agent an isolated [git+ worktree](/blog/how-to-run-multiple-claude-code-agents/) and a GUI to launch tasks and review+ diffs. Great for "try five approaches in parallel."+- **Task boards** model the work as cards you assign to agents and move through columns — a+ project-management view over agentic coding.+- **Coordinated hives** add the layer the others leave to you: shared long-term memory, direct+ agent-to-agent messaging, and an orchestrator that routes work. That's the [multi-agent+ harness](/#what) idea.++Most tools live cleanly in one camp. Knowing which camp you need is most of the decision.++## The tools, at a glance++| Tool | What it is | How it parallelizes | Shared memory | Orchestrator | License |+|---|---|---|---|---|---|+| Claude Squad | Terminal (TUI) session manager | tmux + git worktrees | No | No (you assign) | Open source |+| Conductor | Native macOS desktop app | Parallel git worktrees | No | No (you assign) | Free, macOS-only |+| Crystal | Open-source desktop app | Parallel sessions + worktrees | No | No (you assign) | Open source |+| vibe-kanban | Kanban board for agents | Task cards across agents | No | Board, not auto-routing | Open source |+| Munder Difflin | Local coordinated hive | Roles + mailboxes + orchestrator | Yes (MemPalace) | Yes (GOD agent) | Open source (MIT) |++The single row that most separates the field is **shared memory + orchestrator**: that's the jump+from "running agents in parallel" to "running a team."++## Claude Squad — the lean terminal option++[Claude Squad](https://github.com/smtg-ai/claude-squad) is a terminal UI that manages multiple AI+coding agents — Claude Code among them — each in its own tmux session, with git worktrees keeping+their changes isolated. You launch, switch, background, and review agents without leaving the+terminal.++- **Strengths:** featherweight, keyboard-driven, works great over SSH, no GUI overhead. If you live+ in the terminal and want parallel agents *now*, it's hard to beat for speed of setup.+- **Where it stops:** agents don't share memory or message each other, and there's no orchestrator —+ you decide who does what. It's a superb *session manager*, not a coordination layer.++Best for: terminal purists running a handful of independent tasks. If you want a deeper look at why+isolation alone isn't coordination, see [Claude Squad alternative](/blog/claude-squad-alternative/).++## Conductor — the polished macOS experience++[Conductor](https://conductor.build) is a native macOS app for running Claude Code agents in+parallel, each in its own isolated git worktree, with a clean Mac-native interface for kicking off+tasks and reviewing their diffs.++- **Strengths:** genuinely nice UX, fast diff review, and a low-friction way to run several+ worktree-isolated agents at once on a Mac.+- **Where it stops:** it's macOS-only, and it's built around *parallel isolated workspaces* rather+ than a coordinated team — no shared cross-agent memory, no agent-to-agent messaging, no+ plain-language orchestrator. Closed-source, so you can't read or extend the internals.++Best for: Mac users who want a refined parallel-worktree workflow. If you're cross-platform or want a+coordination layer, see [a Conductor alternative](/blog/conductor-claude-code-alternative/).++## Crystal — the open-source desktop GUI++[Crystal](https://github.com/stravu/crystal) is an open-source desktop app that runs multiple Claude+Code sessions in parallel, each in its own git worktree. You spin up sessions from prompts, run them+concurrently, and review diffs and test results across worktrees in one window.++- **Strengths:** open source, a real GUI, and a tidy model for running several experiments in+ parallel and comparing the results.+- **Where it stops:** like the others in this camp, it's parallel isolated sessions — agents don't+ pool memory or talk to each other, and there's no orchestrator routing work between them.++Best for: developers who want an open, visual, worktree-based parallel workflow without the terminal.+More on the trade-offs in [a Crystal alternative](/blog/crystal-claude-code-alternative/).++## vibe-kanban — the task board for agents++[vibe-kanban](https://github.com/BloopAI/vibe-kanban) takes a different angle: a kanban board where+you create tasks as cards, assign them to coding agents (it's agent-agnostic — Claude Code, Gemini,+Codex, and more), and move work through columns from to-do to review.++- **Strengths:** the board is a familiar, legible mental model; it's agent-agnostic; and it's great+ for managing a *queue* of work and reviewing each agent's output before it lands.+- **Where it stops:** a board is something *you* drive. Cards don't carry shared long-term memory+ between agents, agents don't message each other, and nothing auto-routes work — the orchestration+ is you, moving cards.++Best for: people who think in tasks and want a board over their agents. When you'd rather the routing+happen for you, see [a vibe-kanban alternative](/blog/vibe-kanban-alternative/).++## Munder Difflin — the coordinated hive++[Munder Difflin](/#what) is our own take, and it's deliberately in a different camp. It turns the+Claude Code terminals you already run into a *self-coordinating hive*: each agent gets a role and a+mailbox, agents message each other directly, they share long-term **semantic memory** (MemPalace),+and a [GOD orchestrator](/#how) you talk to in plain language decomposes your intent and routes work+across the team. The whole floor is visualized as avatars at their desks, so you can actually watch+it run.++- **Strengths:** it adds the coordination the other tools leave to you — [shared+ memory](/blog/give-claude-code-long-term-memory/), inter-agent messaging, an orchestrator, and+ visibility. Local-first and MIT-licensed, on macOS, Windows, and Linux.+- **Where it stops (honestly):** it's a younger project, and the office-floor visualization is+ heavier than a TUI. For one or two quick parallel tasks, a lean session manager is less to think+ about — a hive earns its keep once coordination is the real cost.++Best for: people running enough agents that *coordination* — not just parallelism — is the problem.++## How to choose++Match the tool to the bottleneck:++- **"I just want parallel agents, fast."** → Claude Squad (terminal) or Crystal (GUI).+- **"I'm on a Mac and want it to feel native."** → Conductor.+- **"I want to manage work as tasks."** → vibe-kanban.+- **"My agents need to share what they learn and stop colliding."** → Munder Difflin.++If you want a structured way to weigh these, we wrote a [buyer's+checklist](/blog/how-to-choose-a-multi-agent-tool/) and a criteria-based [orchestration tools+comparison](/blog/claude-code-orchestration-tools-compared/). And if you've decided coordination is+your real problem, the fastest way to feel the difference is to+[download Munder Difflin](/#install) — it's free and open source.++---++The honest summary: there's no universal "best." The best tool is the one that solves *your*+bottleneck — and the bottleneck shifts from parallelism to coordination the moment you're running a+real team of agents.diff --git a/blog/src/posts/claude-code-orchestration-tools-compared.md b/blog/src/posts/claude-code-orchestration-tools-compared.mdnew file mode 100644index 00000000..622de204--- /dev/null+++ b/blog/src/posts/claude-code-orchestration-tools-compared.md@@ -0,0 +1,103 @@+---+title: "Claude Code Orchestration Tools, Compared"+description: "Claude Code orchestration tools compared on memory, messaging, visibility, control, and local-first — across Claude Squad, Conductor, Crystal, and more."+date: 2026-06-04+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "claude code orchestration tools compared"+secondaryKeywords: ["claude code orchestration tools compared", "best claude code multi-agent tools", "claude code orchestration"]+tags: ["Comparisons", "Orchestration", "Claude Code", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Compare <strong>Claude Code orchestration+tools</strong> on five criteria that actually change your day: <strong>shared memory</strong>,+<strong>inter-agent messaging</strong>, <strong>visibility</strong>, <strong>control</strong>, and+<strong>local-first</strong>. Session managers and worktree apps score high on control and simplicity;+a coordinated hive scores high on memory, messaging, and visibility. Score the tools against <em>your</em>+priorities, not a generic "best."</p></div>++"Orchestration" gets used loosely. To compare tools meaningfully, you need criteria that map to real+outcomes — not feature checklists. Here are the five that matter for [orchestrating Claude Code+agents](/#how), and how the main tools stack up against each.++## The five criteria that matter++1. **Shared memory** — do agents pool what they learn into a durable, cross-session+ [long-term memory](/blog/give-claude-code-long-term-memory/), or does each start cold?+2. **Inter-agent messaging** — can agents hand work and findings to each other directly, or do you+ relay everything?+3. **Visibility** — can you *see* what the team is doing, or is it a black box of terminal tabs?+4. **Control** — how much do you steer vs. delegate? Manual assignment is more control; an+ orchestrator is more leverage.+5. **Local-first** — does everything run on your machine (privacy, cost, offline), or in the cloud?++A sixth practical factor — **footprint** — decides whether a tool is overkill for your workload.+We'll fold it into the verdict.++## The comparison++Scored as ●●● strong · ●●○ partial · ●○○ minimal, to the best of our knowledge at the time of writing.+Tools evolve — verify against each project's current docs.++| Criterion | Claude Squad | Conductor | Crystal | vibe-kanban | Munder Difflin |+|---|---|---|---|---|---|+| Shared memory | ●○○ | ●○○ | ●○○ | ●○○ | ●●● |+| Inter-agent messaging | ●○○ | ●○○ | ●○○ | ●●○ | ●●● |+| Visibility | ●●○ | ●●● | ●●○ | ●●● | ●●● |+| Control (manual ↔ delegated) | manual | manual | manual | board | delegated + escalation |+| Local-first | ●●● | ●●● | ●●● | ●●○ | ●●● |+| Footprint | tiny | medium | medium | medium | larger |++Read the table as a fit, not a scoreboard. The tools clustered on the left optimize for **control and+simplicity**; Munder Difflin optimizes for **coordination** (memory + messaging + a routing+orchestrator). Both are legitimate.++## How to read each criterion++### Shared memory is the real divider+This is where the field genuinely splits. Session managers and worktree apps (Claude Squad, Conductor,+Crystal) keep each agent's context isolated — great for clean parallel attempts, but the team forgets+between runs. vibe-kanban's cards hold task state, not a shared brain. A hive with a [semantic memory+layer](/#how) is the outlier: every agent reads and writes MemPalace, so knowledge compounds.++### Messaging vs. you-as-the-bus+Most tools route coordination through you. vibe-kanban gives the board a coordinating role; a hive+goes further with agent-to-agent mailboxes so findings flow without a human courier.++### Visibility takes different forms+A TUI list (Claude Squad), a diff-review GUI (Conductor, Crystal), a board (vibe-kanban), or a live+office floor (Munder Difflin) — all "visible," but they answer different questions. A floor answers+"what's everyone doing *right now*?"; a board answers "what's the state of the backlog?"++### Control is a preference, not a ranking+More manual control (assign every task) suits small, deliberate workloads. More delegation (an+orchestrator that routes, escalating only the critical) suits larger, fluid ones. Neither is "better"+— it's about how much you want to drive.++### Local-first is increasingly a deciding factor+Running the harness, agents, and memory [on your own machine](/blog/why-local-first-matters-for-ai-agents/)+buys privacy, predictable cost, and offline capability. Most of these tools are local; confirm where+each one runs before you assume.++## Matching tools to priorities++- **Prioritize simplicity + control** → Claude Squad.+- **Prioritize Mac-native parallel review** → Conductor.+- **Prioritize open-source parallel experiments** → Crystal.+- **Prioritize a task-board workflow** → vibe-kanban.+- **Prioritize memory + messaging + delegated routing** → Munder Difflin.++If you want a structured way to apply this to your own situation, the [buyer's+checklist](/blog/how-to-choose-a-multi-agent-tool/) turns these criteria into a scoring rubric, and a+[Conductor alternative](/blog/conductor-claude-code-alternative/) digs into what "orchestration"+should mean.++---++If memory, messaging, and delegated orchestration top your list, the fastest way to judge is to run+one: [download Munder Difflin](/#install) — free, open source, and local-first on macOS, Windows, and+Linux.diff --git a/blog/src/posts/claude-squad-alternative.md b/blog/src/posts/claude-squad-alternative.mdnew file mode 100644index 00000000..eea4cbb5--- /dev/null+++ b/blog/src/posts/claude-squad-alternative.md@@ -0,0 +1,94 @@+---+title: "Looking for a Claude Squad Alternative?"+description: "What Claude Squad does well, where it stops, and why a memory-backed, orchestrated hive may be the Claude Squad alternative you're after."+date: 2026-06-03+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "claude squad alternative"+secondaryKeywords: ["claude code multi-agent tool", "claude squad vs munder difflin", "claude squad alternative"]+tags: ["Comparisons", "Multi-Agent", "Claude Code", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Claude Squad</strong> is an+excellent lean, terminal-based way to run several Claude Code agents in parallel using tmux and git+worktrees. If you're looking for a <strong>Claude Squad alternative</strong>, it's usually because+you want what a session manager doesn't do: agents that <strong>share memory</strong>, <strong>message+each other</strong>, and are <strong>routed by an orchestrator</strong> — plus a way to actually see+the work. That's the gap a coordinated hive fills.</p></div>++[Claude Squad](https://github.com/smtg-ai/claude-squad) is a genuinely good tool. Before we talk+alternatives, let's be fair about what it gets right — because the reason to switch is specific.++## What Claude Squad does well++Claude Squad is a terminal UI that manages multiple AI coding agents — Claude Code included — each in+its own tmux session, with git worktrees isolating their changes. From one keyboard-driven interface+you launch agents, switch between them, background long-running ones, and review their work.++- **It's featherweight.** No GUI, no Electron, minimal setup. It starts fast and stays out of the way.+- **It's terminal-native and SSH-friendly.** Run it on a remote box and drive a fleet of agents over+ a single connection.+- **Worktree isolation is built in.** Each agent works in its own [git+ worktree](/blog/how-to-run-multiple-claude-code-agents/), so parallel agents don't clobber each+ other's files.++If your need is "run a few independent Claude Code tasks in parallel from the terminal," Claude Squad+may be all you ever want. Switching costs you simplicity — so switch only for a real reason.++## Where a session manager stops++A session manager parallelizes agents; it doesn't *coordinate* them. Three things stay your job:++### 1. Agents don't share what they learn+Each session has its own context. What agent A discovered, agent B can't use — unless you copy it+across yourself. There's no shared, durable [long-term+memory](/blog/give-claude-code-long-term-memory/), so the team forgets between (and across) runs.++### 2. Agents can't talk to each other+Coordination flows through *you*. There's no mailbox for agent A to hand a result to agent B; you're+the message bus, relaying findings between sessions.++### 3. Nothing routes the work+You assign every task by hand. For three agents that's fine; for a dozen, deciding who does what+becomes the bottleneck — and there's no orchestrator to take it off your plate.++None of these are bugs — they're simply outside a session manager's scope. They're also exactly the+things people go looking for an alternative to solve.++## What a coordinated hive adds++The alternative isn't "a fancier terminal." It's a different *shape*: a [multi-agent harness](/#what)+that wraps the agents you already run and adds the coordination layer on top.++- **Shared memory.** A semantic memory store (MemPalace) every agent reads and writes, so knowledge+ compounds instead of evaporating at the end of each session.+- **Inter-agent messaging.** Each agent has a mailbox; a router delivers messages between them, so+ agent A hands work to agent B directly — no human courier.+- **An orchestrator.** A [GOD agent](/#how) you talk to in plain language decomposes your intent and+ routes work across the team, so you stop hand-assigning everything.+- **Visibility.** The whole floor is rendered as avatars at their desks, so "what's everyone doing?"+ has an answer at a glance.++That's [Munder Difflin](/#what): a local, open-source alternative built around coordination rather+than just parallelism. It's the same Claude Code you already run — just wired into a team.++## Which should you pick?++- **Stay with Claude Squad** if you value minimalism, live in the terminal, and your tasks are+ genuinely independent. It's the right tool for that job.+- **Move to a hive** if your agents need to share context, hand work to each other, or be routed for+ you — and if seeing the work matters.++For a head-to-head on exactly this, read [Claude Squad vs Munder+Difflin](/blog/claude-squad-vs-munder-difflin/), and for the wider field see [the best tools to run+multiple Claude Code agents](/blog/best-claude-code-multi-agent-tools/).++---++If "agents that remember and coordinate" is the alternative you're after, the quickest way to feel+the difference is to try it: [download Munder Difflin](/#install) — free, open source, and local-first+on macOS, Windows, and Linux.diff --git a/blog/src/posts/claude-squad-vs-munder-difflin.md b/blog/src/posts/claude-squad-vs-munder-difflin.mdnew file mode 100644index 00000000..8685cb1b--- /dev/null+++ b/blog/src/posts/claude-squad-vs-munder-difflin.md@@ -0,0 +1,102 @@+---+title: "Claude Squad vs Munder Difflin: Which Should You Use?"+description: "Claude Squad vs Munder Difflin: a lean terminal session manager against a memory-backed, orchestrated, visual hive. Feature table and an honest verdict."+date: 2026-06-04+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "claude squad vs munder difflin"+secondaryKeywords: ["claude squad vs munder difflin", "claude code multi-agent tool", "claude squad alternative"]+tags: ["Comparisons", "Multi-Agent", "Claude Code", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What's the main difference between Claude Squad and Munder Difflin?"+ a: "Claude Squad is a lightweight terminal session manager that runs agents in parallel using tmux and git worktrees. Munder Difflin is a coordinated hive that adds shared long-term memory, inter-agent messaging, a GOD orchestrator, and a visual office floor — so the agents act as one team, not just parallel sessions."+ - q: "Is Munder Difflin heavier than Claude Squad?"+ a: "Yes. Claude Squad is a minimal terminal tool; Munder Difflin is a desktop app with a visual floor and a coordination layer. For one or two quick parallel tasks, Claude Squad is less to think about. For a real team of agents that need to coordinate, Munder Difflin's extra weight earns its keep."+ - q: "Are both free and open source?"+ a: "Yes — both are open source. Munder Difflin is MIT-licensed and runs on macOS, Windows, and Linux. Always check each project's current license before you rely on it."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Claude Squad</strong> wins on+minimalism — a fast, terminal-native way to run parallel Claude Code agents. <strong>Munder+Difflin</strong> wins on coordination — shared memory, inter-agent messaging, an orchestrator, and a+visual floor. Choose Claude Squad for a few independent tasks in the terminal; choose Munder Difflin+when coordination, not just parallelism, is the problem.</p></div>++These two tools are often compared, but they're solving different problems. This is the honest+head-to-head: where each is genuinely better, and how to decide.++## The one-line difference++- **Claude Squad** runs agents *in parallel*. It's a terminal session manager.+- **Munder Difflin** runs agents *as a team*. It's a [multi-agent harness](/#what).++Everything below is detail on that distinction.++## Feature comparison++| | Claude Squad | Munder Difflin |+|---|---|---|+| Form factor | Terminal UI (TUI) | Desktop app (Electron) |+| Parallelism | tmux sessions + git worktrees | Roles + mailboxes + orchestrator |+| Shared long-term memory | No | Yes — semantic MemPalace |+| Inter-agent messaging | No | Yes — mailboxes + router |+| Orchestrator | No (you assign) | Yes — GOD agent you talk to |+| Visibility | TUI session list | Live office floor (avatars) |+| Footprint | Featherweight | Heavier (GUI + viz) |+| SSH / remote | Excellent | Local desktop app |+| Platforms | Terminal (cross-platform) | macOS, Windows, Linux |+| License | Open source | Open source (MIT) |++No row makes one "win" outright — they reflect two philosophies. Claude Squad optimizes for *less*;+Munder Difflin optimizes for *coordination*.++## Where Claude Squad is the better pick++- **You live in the terminal.** No GUI, no Electron — it's fast and it stays out of the way.+- **You work over SSH.** Driving a fleet of agents on a remote box from one connection is Claude+ Squad's home turf.+- **Your tasks are independent.** Three unrelated jobs in three worktrees don't need a memory layer+ or an orchestrator — they need isolation, which Claude Squad gives you cleanly.+- **You want minimal moving parts.** Fewer features can be a feature.++If that's you, Claude Squad is the right tool and the visual floor would just be overhead. Be honest+about your workload before you reach for more.++## Where Munder Difflin is the better pick++- **Your agents need to share what they learn.** [Long-term+ memory](/blog/give-claude-code-long-term-memory/) (MemPalace) means knowledge compounds instead of+ resetting every session.+- **Agents need to hand work to each other.** Mailboxes + a router let agent A pass a result to agent+ B without you relaying it.+- **You don't want to assign every task.** A [GOD orchestrator](/#how) you talk to in plain language+ decomposes intent and routes work for you.+- **Seeing the work matters.** A live office floor turns "what's everyone doing?" into a glance —+ useful for trust and for catching problems early.++In short: when *coordination* is the cost, the coordination layer pays for itself.++## The verdict++There's no universal winner — there's a right tool for your workload:++- **A few independent tasks, terminal-first, minimal:** Claude Squad.+- **A coordinated team that remembers, messages, and routes:** Munder Difflin.++Many people start on Claude Squad and move to a hive exactly when they hit the coordination wall —+the same arc as [going from one terminal to a team](/blog/from-one-terminal-to-a-team/). If you're+still scoping the field, read [the best tools to run multiple Claude Code+agents](/blog/best-claude-code-multi-agent-tools/), or if you've already outgrown a session manager,+[looking for a Claude Squad alternative](/blog/claude-squad-alternative/) goes deeper on the gap.++---++> Both tools evolve quickly — check each project's repo for current details. Munder Difflin is our own+> tool; we've tried to give Claude Squad a fair shake.++Curious how a coordinated hive feels? [Download Munder Difflin](/#install) — free, open source, and+local-first.diff --git a/blog/src/posts/conductor-claude-code-alternative.md b/blog/src/posts/conductor-claude-code-alternative.mdnew file mode 100644index 00000000..4ea91b54--- /dev/null+++ b/blog/src/posts/conductor-claude-code-alternative.md@@ -0,0 +1,92 @@+---+title: "A Conductor Alternative for Orchestrating Claude Code"+description: "Conductor is a polished macOS app for parallel Claude Code worktrees. When to pick a cross-platform, orchestrated hive as your Conductor alternative."+date: 2026-06-03+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "conductor claude code alternative"+secondaryKeywords: ["conductor claude code alternative", "claude code orchestration tools", "claude code multi-agent tool"]+tags: ["Comparisons", "Orchestration", "Claude Code", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Conductor</strong> is a polished,+native macOS app for running Claude Code agents in parallel git worktrees with clean diff review. You+might want a <strong>Conductor alternative</strong> if you're not on a Mac, want open source, or need+real <strong>orchestration</strong> — agents that share memory, message each other, and are routed by+a coordinator — rather than parallel isolated workspaces.</p></div>++[Conductor](https://conductor.build) earned its reputation honestly: it's one of the nicest ways to+run parallel Claude Code on a Mac. So this isn't a takedown — it's a map of when its model fits and+when you'd reach for something else.++## What Conductor does well++Conductor is a native macOS app that runs Claude Code agents in parallel, each in its own isolated+git worktree, with a refined GUI for launching tasks and reviewing the diffs they produce.++- **The UX is genuinely good.** It feels like a Mac app, not a wrapped web page.+- **Parallel worktrees are first-class.** Kick off several agents on the same repo without them+ stepping on each other's files.+- **Diff review is fast.** Seeing what each agent changed, side by side, is the core loop and it's+ smooth.++If you're a Mac user whose workflow is "spin up N parallel attempts and review the diffs," Conductor+is a strong fit. The reasons to look elsewhere are specific.++## Where you'd want an alternative++### It's macOS-only+If you're on Windows or Linux — or you bounce between machines — a Mac-only app is a hard stop. A+[local-first](/blog/why-local-first-matters-for-ai-agents/) cross-platform tool keeps your workflow+consistent everywhere.++### It's parallelism, not orchestration+Conductor runs agents *beside* each other in isolated worktrees. What it doesn't do is *coordinate*+them: there's no shared long-term memory between agents, no agent-to-agent messaging, and no+orchestrator that decomposes your intent and routes work. You're still the one assigning tasks and+ferrying context between worktrees.++### It's closed-source+You can't read the internals, self-host changes, or extend it. For some teams that's fine; for others+— especially open-source-minded ones — it's a dealbreaker.++## What "orchestration" actually means++The word *conductor* implies coordination, so it's worth being precise about what full+[orchestration](/#how) looks like for coding agents:++- **A coordinator that routes.** You describe intent once; an orchestrator decomposes it and assigns+ the pieces — instead of you hand-launching each agent.+- **A shared brain.** A [long-term memory](/blog/give-claude-code-long-term-memory/) layer every+ agent reads and writes, so the team's knowledge compounds.+- **Direct messaging.** Agents hand work and findings to each other through mailboxes, not through+ you.+- **Adjudication + escalation.** The coordinator resolves the routine and escalates only the+ genuinely critical (spend, destructive ops, scope) for your sign-off.++That's the model behind [Munder Difflin](/#what): a [GOD orchestrator](/#how) you talk to in plain+language, shared MemPalace memory, inter-agent messaging, and a watchable office floor — open source+(MIT) and running on macOS, Windows, and Linux.++## Conductor vs an orchestrated hive++- **Conductor** is the better choice if you're on a Mac and your loop is parallel worktrees + diff+ review, and you don't need agents to coordinate.+- **An orchestrated hive** is the better choice if you want cross-platform, open source, shared+ memory, messaging, and a coordinator that routes work for you.++For the broader field, see [the best tools to run multiple Claude Code+agents](/blog/best-claude-code-multi-agent-tools/) and a criteria-based [orchestration tools+comparison](/blog/claude-code-orchestration-tools-compared/).++---++> Features and platforms change — check Conductor's site for current details. Munder Difflin is our+> own tool; we've described Conductor on its own terms.++If real orchestration is what you're missing, [download Munder Difflin](/#install) and run a+coordinated team locally — it's free and open source.diff --git a/blog/src/posts/crystal-claude-code-alternative.md b/blog/src/posts/crystal-claude-code-alternative.mdnew file mode 100644index 00000000..e214a3ac--- /dev/null+++ b/blog/src/posts/crystal-claude-code-alternative.md@@ -0,0 +1,90 @@+---+title: "A Crystal Alternative: Multi-Agent Claude Code with Memory"+description: "Crystal runs parallel Claude Code worktrees well. Where a memory-backed, orchestrated hive changes the workflow — and when to stick with Crystal."+date: 2026-06-03+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "crystal claude code alternative"+secondaryKeywords: ["crystal claude code alternative", "claude code multi-agent tool", "multi-agent claude code with memory"]+tags: ["Comparisons", "Memory", "Claude Code", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Crystal</strong> is a tidy,+open-source desktop app for running multiple Claude Code sessions in parallel, each in its own git+worktree, with diff and test review. A <strong>Crystal alternative</strong> makes sense when you want+the agents to do more than run side by side — to <strong>share long-term memory</strong>, message+each other, and be routed by an orchestrator. That's the difference between parallel sessions and a+coordinated team.</p></div>++[Crystal](https://github.com/stravu/crystal) is a likeable tool: open source, a real GUI, and a clean+model for running parallel Claude Code experiments. If you're weighing an alternative, start by being+clear about what Crystal already nails.++## What Crystal does well++Crystal is an open-source desktop app that spins up multiple Claude Code sessions from prompts, runs+them concurrently in isolated git worktrees, and lets you review diffs and test results across them in+one window.++- **It's open source.** You can read it, file issues, and contribute.+- **Parallel experimentation is the sweet spot.** Try several approaches to the same problem at once,+ then compare outcomes.+- **Worktree isolation + diff review** keep parallel work safe and reviewable without terminal+ juggling.++For "run a few variations in parallel and pick the best diff," Crystal is a good answer. The reason to+look further is usually one word: *memory*.++## Where parallel sessions hit a ceiling++Crystal, like other parallel-worktree apps, runs agents *beside* each other. What it doesn't add is a+coordination layer:++### Sessions don't share knowledge+Each session is its own island of context. When one agent figures out a convention or a gotcha, the+others don't inherit it. Without [shared long-term+memory](/blog/give-claude-code-long-term-memory/), the team re-learns the same things and you re-explain+the same context.++### Agents don't message each other+There's no mailbox for one agent to hand a result to another. Coordination routes through you.++### There's no orchestrator+You launch and assign each session. Nothing decomposes a goal and routes the pieces across the team+for you.++## What memory changes, day to day++Adding a shared brain to a team of agents is a bigger shift than it sounds:++- **Context stops resetting.** Decisions, conventions, and gotchas live in a [semantic memory+ layer](/#how) (MemPalace) every agent reads on startup and writes to as it learns.+- **Briefs get shorter.** You stop re-explaining the project because the team already remembers it.+- **Work compounds.** Agent B builds on what agent A learned an hour — or a week — ago.++Layer messaging and an orchestrator on top of that memory and you've crossed from "parallel sessions"+to a [multi-agent harness](/#what): agents with roles and mailboxes, a [GOD orchestrator](/#how) that+routes work, and a visual office floor. That's [Munder Difflin](/#what) — open source (MIT), local-first,+on macOS, Windows, and Linux.++## Crystal vs a memory-backed hive++- **Stay with Crystal** if your loop is parallel experiments + diff review and you don't need agents+ to coordinate or remember across sessions.+- **Move to a hive** if you want shared memory, inter-agent messaging, and an orchestrator — agents+ that act as one team instead of parallel strangers.++See also: a head-to-head [Claude Squad vs Munder Difflin](/blog/claude-squad-vs-munder-difflin/) and+the full [roundup of multi-agent Claude Code tools](/blog/best-claude-code-multi-agent-tools/).++---++> The tooling landscape moves fast — check Crystal's repo for current features. We've described it on+> its own terms; Munder Difflin is our own project.++If shared memory is the missing piece, [download Munder Difflin](/#install) and let your agents+actually remember — free and open source.diff --git a/blog/src/posts/from-one-terminal-to-a-team.md b/blog/src/posts/from-one-terminal-to-a-team.mdnew file mode 100644index 00000000..6355cc2f--- /dev/null+++ b/blog/src/posts/from-one-terminal-to-a-team.md@@ -0,0 +1,98 @@+---+title: "From One Terminal to a Team: Scaling Your Claude Code Workflow"+description: "The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after."+date: 2026-06-02+category: use-cases+categoryLabel: Use Cases+type: Non-technical+primaryKeyword: "run multiple claude code agents"+secondaryKeywords: ["claude code workflow", "scaling ai agents", "ai coding agent teams"]+tags: ["Use Cases", "Multi-Agent", "Claude Code", "Workflow"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Scaling your Claude Code workflow goes+through three stages: <strong>one session</strong> → <strong>a few manual terminals</strong> →+<strong>a coordinated team</strong>. Each stage solves the previous one's pain and introduces a new+one. The jump that actually changes your day is the last: giving agents <strong>shared memory,+messaging, and an orchestrator</strong> so they stop colliding and forgetting.</p></div>++Most people don't decide to "run a team of agents" — they back into it, one terminal at a time, until+the workflow strains. Here's the arc, what breaks at each step, and the concrete before-and-after of+crossing to a real team.++## Stage 1: One terminal++You run a single `claude` session. It's focused, it's easy to follow, and for most tasks it's all you+need. The only ceiling is *throughput* — one agent does one thing at a time, and you're the only+parallelism in the room.++**The pain that pushes you forward:** you're waiting on the agent while three other things you could+parallelize sit idle.++## Stage 2: A few manual terminals++So you open more terminals — a [classic move](/blog/how-to-run-multiple-claude-code-agents/). One+writes tests, one refactors, one updates docs. Throughput jumps. For two or three *independent* tasks,+this genuinely works.++Then they start to overlap, and three problems show up:++- **Collisions.** Two agents edit the same file and race each other; in git you get `index.lock`+ errors and half-applied changes.+- **Amnesia.** Each session has its own context. What agent A learned, agent B can't use — so *you*+ become the courier, copy-pasting findings between windows.+- **Lost track.** With six tabs open, "what is everyone doing right now?" has no answer.++**The pain that pushes you forward:** you've become the message bus, the conflict resolver, and the+project's only memory. The agents got faster; *you* became the bottleneck.++## Stage 3: A coordinated team++The fix isn't more tabs — it's a coordination layer. Three additions turn parallel sessions into a+team:++- **Roles** so each agent stays in its lane and "who does this?" is obvious.+- **Shared memory** so the team reads from one [long-term+ memory](/blog/give-claude-code-long-term-memory/) and stops re-learning the project.+- **Messaging + an orchestrator** so agents hand work to each other and a coordinator routes it —+ instead of routing through you.++That's the leap from juggling [Claude Code agents](/blog/what-are-claude-code-agents/) to running a+[multi-agent harness](/#what). It's the stage where adding agents stops adding *overhead*.++## The before-and-after++The same morning, two ways:++| | Manual terminals | Coordinated team |+|---|---|---|+| Assigning work | You, tab by tab | Describe intent; orchestrator routes |+| Context sharing | You copy-paste between windows | Shared memory; agents read it |+| Handing off | You relay results | Agents message each other |+| File conflicts | `index.lock`, manual cleanup | Coordination rules prevent it |+| "What's happening?" | Alt-tab and guess | A glance at the floor |+| Your role | Message bus | Manager |++Nothing about the *agents* changed — they're the same Claude Code sessions. What changed is the layer+around them, and that's what moves you from operator to manager.++## Knowing when to make the jump++You don't need a team to use Claude Code. You want one when:++- you're running **three or more** sessions and losing the thread,+- you keep **re-explaining context** because each session forgets, or+- agents **collide** on the same files.++If that's you, the next step is the coordination layer — and you can keep the whole thing+[local](/blog/why-local-first-matters-for-ai-agents/). The natural destination is [an office of agents+that keeps shipping](/blog/run-an-office-of-ai-agents/) even after you log off.++---++Munder Difflin is the coordination layer for the Claude Code agents you already run — roles, shared+memory, messaging, and an orchestrator, all local. [Download Munder Difflin](/#install) to make the+jump; it's free and open source.diff --git a/blog/src/posts/how-to-choose-a-multi-agent-tool.md b/blog/src/posts/how-to-choose-a-multi-agent-tool.mdnew file mode 100644index 00000000..bfbb4464--- /dev/null+++ b/blog/src/posts/how-to-choose-a-multi-agent-tool.md@@ -0,0 +1,118 @@+---+title: "How to Choose a Multi-Agent Coding Tool: A Buyer's Checklist"+description: "A decision framework for choosing a multi-agent coding tool — memory, control, visibility, cost, local-first — with a simple scoring rubric you can run."+date: 2026-06-02+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "agentic coding tools"+secondaryKeywords: ["agentic coding tools", "ai coding agent teams", "choosing ai tools"]+tags: ["Comparisons", "Multi-Agent", "Tools", "Getting Started"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Choose a <strong>multi-agent coding+tool</strong> by scoring it on six things that actually change your workflow: <strong>memory</strong>,+<strong>messaging</strong>, <strong>orchestration</strong>, <strong>visibility</strong>,+<strong>control</strong>, and <strong>cost & local-first</strong>. Weight each by how much it+matters to <em>you</em>, score each tool 0–3, and the highest total wins — for your situation, not in+the abstract.</p></div>++There's no single best [agentic coding tool](/blog/best-claude-code-multi-agent-tools/) — there's the+best one for your workload. The way to find it isn't reading ten reviews; it's running the same+checklist across the contenders. Here's a framework you can use in fifteen minutes.++## Start with the question behind the question++Before scoring anything, name your actual bottleneck. Most people are solving one of two problems:++- **"I need to run agents in parallel without them colliding."** A session manager or+ worktree-isolating app solves this directly.+- **"I'm drowning in coordination — re-explaining context, relaying messages, assigning every+ task."** That's a [coordination](/#how) problem, and it needs memory, messaging, and an+ orchestrator.++If you're in the first camp, optimize for simplicity. If you're in the second, the checklist below+will steer you toward heavier, more coordinated tools — and that's correct.++## The six criteria++### 1. Memory+Does the tool give agents a shared, durable [long-term+memory](/blog/give-claude-code-long-term-memory/) they read on startup and write to as they learn — or+does each agent start cold every session? Memory is the single biggest multiplier on a team's output+over time, because it stops you re-explaining the project.++### 2. Messaging+Can agents hand work and findings to each other directly (mailboxes, a router), or are *you* the+message bus relaying between windows? Direct messaging is what lets a team self-coordinate.++### 3. Orchestration+Is there a coordinator that decomposes your intent and routes work — escalating only the critical+decisions — or do you assign every task by hand? More orchestration means more leverage; less means+more control.++### 4. Visibility+Can you *see* what the team is doing — a live view, not a wall of terminal tabs? Visibility builds+trust and catches problems early. Forms vary: a session list, a diff view, a board, a+[visual office floor](/#how).++### 5. Control+How much do you steer vs. delegate? Some workloads want a human approving each step; others want to+describe a goal and walk away. Decide where you sit on that spectrum before you judge a tool's+autonomy as a pro or a con.++### 6. Cost & local-first+Is it free or paid? Open source or closed? Does it run [locally on your+machine](/blog/why-local-first-matters-for-ai-agents/) (privacy, predictable cost, offline) or in the+cloud? For many developers, local-first and open source are non-negotiable.++## The scoring rubric++For each criterion, give the tool a 0–3:++- **0** — absent+- **1** — minimal / workaround+- **2** — present, partial+- **3** — first-class++Then weight by importance to *you* (×1 for "nice to have", ×2 for "matters", ×3 for "dealbreaker").+Multiply, sum, compare. A worked example for a team whose bottleneck is coordination:++| Criterion | Weight | Tool A (session manager) | Tool B (coordinated hive) |+|---|---|---|---|+| Memory | ×3 | 0 → 0 | 3 → 9 |+| Messaging | ×3 | 0 → 0 | 3 → 9 |+| Orchestration | ×2 | 0 → 0 | 3 → 6 |+| Visibility | ×2 | 1 → 2 | 3 → 6 |+| Control | ×1 | 3 → 3 | 2 → 2 |+| Cost & local-first | ×2 | 3 → 6 | 3 → 6 |+| **Total** | | **11** | **38** |++Flip the weights for a team whose bottleneck is "just run three parallel tasks," and the session+manager wins handily — that's the point. The rubric encodes *your* priorities, so it gives *your*+answer. For a ready-made criteria breakdown across the real tools, see [Claude Code orchestration+tools, compared](/blog/claude-code-orchestration-tools-compared/).++## Three traps to avoid++- **Buying for a workload you don't have.** A coordinated hive is overkill for two independent tasks;+ a session manager is underpowered for a ten-agent project. Score for *your* reality.+- **Treating "more autonomy" as automatically better.** Delegation is leverage *if* you trust the+ guardrails. Check how a tool escalates the critical stuff before you hand it the wheel.+- **Ignoring lock-in.** Open source and local-first cost nothing to leave. Weight that if you're+ risk-averse.++## Run the checklist++Pick your two or three finalists from [the roundup](/blog/best-claude-code-multi-agent-tools/), score+each on the six criteria with your weights, and trust the total. The exercise is fast and it kills+analysis paralysis.++---++If your scores point at memory + messaging + orchestration, Munder Difflin is built squarely for that+profile — and it's free to test the thesis. [Download Munder Difflin](/#install); it's open source and+local-first.diff --git a/blog/src/posts/munder-difflin-faq.md b/blog/src/posts/munder-difflin-faq.mdnew file mode 100644index 00000000..d859bccb--- /dev/null+++ b/blog/src/posts/munder-difflin-faq.md@@ -0,0 +1,70 @@+---+title: "Munder Difflin FAQ: Everything People Ask"+description: "Answers to the top Munder Difflin questions — what it is, is it free, does it run locally, which platforms, and how it differs from many terminals."+date: 2026-06-02+category: concepts+categoryLabel: Concepts+type: Non-technical+primaryKeyword: "munder difflin app"+secondaryKeywords: ["munder difflin download", "munder difflin claude code", "is munder difflin free"]+tags: ["Concepts", "FAQ", "Claude Code", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is Munder Difflin?"+ a: "Munder Difflin is a local, open-source desktop app that turns the Claude Code terminals you already run into a self-coordinating hive of agents — with shared long-term memory, inter-agent messaging, and a GOD orchestrator you talk to."+ - q: "Is Munder Difflin free?"+ a: "Yes. Munder Difflin is free and open source under the MIT license. You can download a build or run it from source — there's no paid tier to unlock the core."+ - q: "Does it run my data or code in the cloud?"+ a: "No. Munder Difflin is local-first — the harness, agents, and memory all live on your own machine. Your Claude Code sessions talk to Anthropic the same way they already do; Munder Difflin itself doesn't ship your code anywhere."+ - q: "What platforms does Munder Difflin support?"+ a: "macOS, Windows, and Linux. You can download a build or build it from source in a couple of commands."+ - q: "How is this different from running several Claude Code terminals myself?"+ a: "Munder Difflin adds the coordination that loose terminals lack: shared long-term memory (MemPalace), inter-agent messaging, a GOD orchestrator that routes work, and a visual office floor — so the sessions act as one team instead of isolated windows that collide and forget."+ - q: "Do I need to know how to code to use it?"+ a: "You should be comfortable with Claude Code and a terminal, since Munder Difflin coordinates Claude Code agents. But you steer the team in plain language by talking to the GOD orchestrator — you don't script the coordination yourself."+ - q: "What is MemPalace?"+ a: "MemPalace is Munder Difflin's shared memory layer — a semantic store the whole hive reads and writes, mined automatically from each agent's plain-markdown notes, so agents recall relevant knowledge across sessions."+ - q: "What is the GOD orchestrator?"+ a: "The GOD orchestrator is a coordinating agent you talk to in plain language. It decomposes your intent, routes work to the right agents, adjudicates routine decisions, and escalates only the genuinely critical ones to you."+ - q: "Can the agents talk to each other?"+ a: "Yes. Each agent has a mailbox and a router delivers messages between them, so one agent can hand work or findings to another directly — without you relaying it."+ - q: "Does Munder Difflin work with my existing Claude Code setup, MCP servers, and skills?"+ a: "Yes. It coordinates the Claude Code you already run, including your tools, MCP servers, and skills — it adds a coordination layer rather than replacing your setup."+ - q: "Is Munder Difflin affiliated with Dunder Mifflin or The Office?"+ a: "No. The name is an affectionate parody — 'the world's best agents, the world's worst paper company.' It's an independent open-source project, not affiliated with NBC or The Office."+ - q: "Where do I download Munder Difflin?"+ a: "From the install section on munderdiffl.in, which links to the latest release. It's free, open source, and available for macOS, Windows, and Linux."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin</strong> is a free,+open-source (MIT), local-first desktop app that turns the Claude Code terminals you already run into a+coordinated hive — shared memory, messaging, and a [GOD orchestrator](/#how) you talk to — on macOS,+Windows, and Linux. The full answers to the questions people ask most are below.</p></div>++This page answers the questions we hear most about Munder Difflin, kept short and direct. If your+question isn't here, the [GitHub repo](https://github.com/chaitanyagiri/munder-difflin) and the rest+of [the blog](/blog/) go deeper.++## The one-sentence version++Munder Difflin is a [multi-agent harness](/blog/what-is-a-multi-agent-harness/) for Claude Code: it+takes the agents you already run and makes them act like one team — they message each other, share+long-term memory, and are routed by a coordinator you talk to in plain language, all visualized as a+live office floor on your own machine.++## Still deciding?++If you're comparing options, these go deeper than an FAQ can:++- [The best tools to run multiple Claude Code agents](/blog/best-claude-code-multi-agent-tools/) — the+ honest field roundup.+- [Why we built Munder Difflin](/blog/why-we-built-munder-difflin/) — the origin story and the problem+ it solves.+- [What are Claude Code agents?](/blog/what-are-claude-code-agents/) — the basics, if you're new.++---++The fastest way to answer "is this for me?" is to run it. [Download Munder Difflin](/#install) — it's+free, open source, and local-first.diff --git a/blog/src/posts/run-an-office-of-ai-agents.md b/blog/src/posts/run-an-office-of-ai-agents.mdnew file mode 100644index 00000000..af41ba88--- /dev/null+++ b/blog/src/posts/run-an-office-of-ai-agents.md@@ -0,0 +1,88 @@+---+title: "Run an Office of AI Agents While You Sleep"+description: "What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane."+date: 2026-06-02+category: use-cases+categoryLabel: Use Cases+type: Non-technical+primaryKeyword: "autonomous software team ai"+secondaryKeywords: ["ai pair programming team", "ai coding agent teams", "run agents while you sleep"]+tags: ["Use Cases", "Multi-Agent", "Automation", "Story"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Imagine an <strong>office of AI+agents</strong> — each with a role, a shared memory, and a coordinator — that keeps working a backlog+after you close the laptop. It's not magic and it's not hands-off forever: it works because of+<strong>roles, shared memory, messaging, an orchestrator, and guardrails</strong> that escalate the+risky calls to you. Here's the realistic version of the dream.</p></div>++There's a specific fantasy that pulls people toward multi-agent tools: log off at night, and a team of+agents keeps shipping. It's a good fantasy — and a more achievable one than it sounds, *if* you build+it on the right foundations. Here's what that office actually looks like.++## The picture++Picture a floor of agents, each at a desk with a job. One's writing tests. One's chewing through a+refactor. One's updating docs to match. A coordinator — you talk to it like a manager — has the+backlog and routes the next task to whoever's free. They message each other when work hands off. They+share a memory of the project so nobody re-learns what's already known. You can watch it happen, or+close the laptop and check the morning's progress over coffee.++That's not a metaphor for Munder Difflin — it's literally [the office floor](/#how). But the picture+only works because of what's underneath it.++## What makes it actually work++A self-running office isn't "point agents at a repo and hope." Four pieces carry the weight:++### Roles+Each agent has a scoped job, so it doesn't wander into another's work or duplicate effort. Roles make+"who does this?" obvious and keep parallel agents out of each other's lanes.++### Shared memory+The team reads from and writes to a [shared long-term+memory](/blog/give-claude-code-long-term-memory/). When the test-writer learns a convention, the+refactorer inherits it. Knowledge compounds overnight instead of resetting each session.++### Messaging + an orchestrator+Agents hand work to each other through mailboxes, and an [orchestrator](/#how) decomposes your intent+and routes the pieces. That's the difference between a *team* and a pile of parallel sessions — and+it's what lets work flow while you're away.++### Guardrails+This is the part the fantasy skips. Unattended agents need a [human-in-the-loop](/#why) line: routine+work proceeds, but the risky stuff — spending real money, destructive operations, big scope changes —+queues for your approval. You wake up to *progress*, not surprises.++## What's realistic (and what isn't)++Honesty matters here, because over-promising is how people get burned:++- **Realistic:** a team grinding through a well-scoped backlog of bounded tasks overnight — tests,+ refactors, docs, migrations, investigations — with a clear record of what each agent did.+- **Realistic:** waking up to mostly-done work that you review and finish, having saved hours of+ context-switching.+- **Not realistic:** handing over an ambiguous, open-ended goal and expecting a finished product with+ zero review. Agents are leveraged labor, not oracles.++The skill is in the scoping and the guardrails, not in trusting blindly. Done right, the leverage is+real.++## How to get there++You don't start with an overnight office — you grow into one. The arc is always the same: one session,+then a few manual terminals, then a coordinated team. We map that progression in [from one terminal to+a team](/blog/from-one-terminal-to-a-team/), and the foundational habits in [how to run multiple+Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/).++Keeping the whole office [local-first](/blog/why-local-first-matters-for-ai-agents/) is what makes it+sane to leave running: it's your machine, your files, your rules.++---++Munder Difflin is exactly this office — roles, shared memory, messaging, a GOD orchestrator, and a+floor you can watch, all local. [Download Munder Difflin](/#install) and staff your own; it's free and+open source.diff --git a/blog/src/posts/vibe-kanban-alternative.md b/blog/src/posts/vibe-kanban-alternative.mdnew file mode 100644index 00000000..e217f4fc--- /dev/null+++ b/blog/src/posts/vibe-kanban-alternative.md@@ -0,0 +1,95 @@+---+title: "A vibe-kanban Alternative for Coordinating AI Agents"+description: "vibe-kanban gives you a board to assign tasks to coding agents. When a self-routing hive is the better vibe-kanban alternative — and when a board wins."+date: 2026-06-03+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "vibe kanban alternative"+secondaryKeywords: ["vibe kanban alternative", "ai agent task board", "agentic coding tools"]+tags: ["Comparisons", "Orchestration", "Multi-Agent", "Tools"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>vibe-kanban</strong> is a kanban+board for AI coding agents: you create tasks as cards, assign them to agents, and move work through+columns. A <strong>vibe-kanban alternative</strong> makes sense when you'd rather <em>not</em> drive+the board yourself — when you want an orchestrator that decomposes your intent and routes work, plus+agents that share memory and message each other. Board vs. self-routing hive: pick by who you want+doing the routing.</p></div>++[vibe-kanban](https://github.com/BloopAI/vibe-kanban) is a clever reframing of agentic coding: treat+your agents like a team with a backlog. Before the alternative, here's what it does well — because the+board model is genuinely good for some workflows.++## What vibe-kanban does well++vibe-kanban is an open-source kanban board for orchestrating AI coding agents. It's agent-agnostic+(Claude Code, Gemini, Codex, and others), and you work the way you'd work any board: create tasks as+cards, assign them to agents, and move them through columns from to-do to in-progress to review.++- **The board is a legible mental model.** Everyone understands kanban. The state of all work is+ visible in one view.+- **It's agent-agnostic.** Mix and match the coding agents you already use.+- **Review is built into the flow.** Cards move to a review column so you approve outputs before they+ land.++If you think in tasks and want a project-management surface over your agents, vibe-kanban fits+naturally. The reason to look elsewhere is about *who does the routing*.++## Where a board leaves the work to you++A kanban board is something a human drives. That's its strength and its ceiling:++### You are the router+Cards don't move themselves. *You* decompose the goal into tasks, decide which agent gets which card,+and shuffle the board. For a tidy backlog that's fine; for fluid, branching work it becomes the+bottleneck — the [coordination overhead](/blog/from-one-terminal-to-a-team/) you were trying to escape.++### Cards don't carry shared memory+A card is a task, not a brain. Agents working different cards don't pool what they learn; there's no+shared [long-term memory](/blog/give-claude-code-long-term-memory/) across the board, so context+doesn't compound.++### Agents don't message each other+Coordination between cards goes through you and the board, not agent-to-agent. There's no mailbox for+one agent to hand a finding directly to another.++## What a self-routing hive does instead++The alternative flips the model: instead of *you* working a board, you describe intent and the system+routes the work.++- **An orchestrator decomposes and assigns.** A [GOD agent](/#how) you talk to in plain language+ breaks your goal into tasks and routes them to the right agents — the board management happens for+ you.+- **Shared memory.** Every agent reads and writes a [semantic memory layer](/#how) (MemPalace), so+ the team's knowledge accrues instead of living in disconnected cards.+- **Direct messaging.** Agents hand work and findings to each other through mailboxes.+- **Visibility without manual upkeep.** You watch a live office floor rather than maintaining columns+ — the state is observed, not curated.++That's [Munder Difflin](/#what): a [multi-agent harness](/#what) built around an orchestrator, shared+memory, and messaging, visualized as a watchable floor. Open source (MIT), local-first, on macOS,+Windows, and Linux.++## Board or hive? How to choose++- **Keep vibe-kanban** if you *want* a board — explicit tasks, manual assignment, a column-based+ review gate, and an agent-agnostic queue.+- **Choose a hive** if you'd rather describe a goal and have it routed for you, with agents that+ remember and talk to each other.++It's not that one is better — they answer different questions. For the full field, see [the best+tools to run multiple Claude Code agents](/blog/best-claude-code-multi-agent-tools/) and the+criteria-based [orchestration tools comparison](/blog/claude-code-orchestration-tools-compared/).++---++> The landscape changes quickly — check vibe-kanban's repo for current features. We've described it+> on its own terms; Munder Difflin is our own project.++If you'd rather orchestrate than administrate, [download Munder Difflin](/#install) and let the+routing happen for you — free and open source.diff --git a/blog/src/posts/what-are-claude-code-agents.md b/blog/src/posts/what-are-claude-code-agents.mdnew file mode 100644index 00000000..a1fba9c7--- /dev/null+++ b/blog/src/posts/what-are-claude-code-agents.md@@ -0,0 +1,100 @@+---+title: "What Are Claude Code Agents? And How to Use Many at Once"+description: "Claude Code agents explained in plain English — what an agent actually is, how subagents differ, and the leap from one agent to a coordinated team."+date: 2026-06-02+category: concepts+categoryLabel: Concepts+type: Non-technical+primaryKeyword: "claude code agents"+secondaryKeywords: ["claude code agents", "claude code subagents", "ai coding agents"]+tags: ["Concepts", "Multi-Agent", "Claude Code", "Getting Started"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What are Claude Code agents?"+ a: "A Claude Code agent is a running Claude session with a goal and a set of tools — it can read and edit files, run commands, and work toward a task in a loop. Each terminal you start a Claude session in is an agent."+ - q: "What's the difference between an agent and a subagent in Claude Code?"+ a: "An agent is a top-level session you drive. A subagent is a helper the main agent spawns inside its own run to fan out a piece of work — short-lived and scoped to that parent. Subagents are great for parallel sub-tasks but don't persist or share memory across your whole workflow."+ - q: "How do I use multiple Claude Code agents at once?"+ a: "Open several sessions, give each a clear role, and coordinate them — ideally with shared memory and messaging so they don't collide or forget. A multi-agent harness like Munder Difflin automates that coordination so the sessions act as one team."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>A <strong>Claude Code agent</strong> is a+running Claude session with a goal and tools — it reads files, edits code, and runs commands in a+loop. <strong>Subagents</strong> are short-lived helpers an agent spawns for fan-out. The real leap+isn't more agents; it's getting several to act as a <strong>coordinated team</strong> with roles,+shared memory, and messaging.</p></div>++If you're new to Claude Code, "agent" gets thrown around a lot. Here's the plain-English version —+what an agent actually is, how subagents fit, and what changes when you run several at once.++## What an agent actually is++An agent is just a loop with a goal. A Claude Code agent is a running Claude session that can:++- **read** your files and project context,+- **act** — edit code, run shell commands, call tools — toward a task, and+- **repeat**, observing the results and deciding the next step.++That's it. Every terminal where you start a `claude` session is an agent: one goal, one context+window, one loop. The magic isn't the word "agent" — it's that the loop can use tools and keep going+until the job's done.++## Agents vs. subagents++These two get conflated constantly, so let's separate them:++### Agent+A top-level session *you* drive. It owns a task from start to finish and you interact with it+directly.++### Subagent+A helper the main agent **spawns inside its own run** to fan out a chunk of work — "go research these+five files in parallel," for example. Subagents are powerful for parallelism, but they're+**short-lived and scoped to that one parent**: they don't persist after the run, and they don't share+memory across your whole workflow. For the deeper trade-offs, the difference between [subagents and a+full harness](/#what) is worth understanding before you lean on either.++The short version: subagents help *one* agent do more at once; they don't make *many* agents into a+team.++## From one agent to many++One agent handles most tasks fine. You start wanting *several* when work naturally splits — someone+writes tests while someone refactors while someone updates docs. The naive way is to open more+terminals, and that works… until it doesn't:++- agents **collide** on the same files,+- each session **forgets** what the others learned, and+- you lose track of **who's doing what** across a wall of tabs.++That's the wall every multi-agent setup hits. The fix isn't more agents — it's coordination. We wrote+the practical playbook in [how to run multiple Claude Code+agents](/blog/how-to-run-multiple-claude-code-agents/).++## What turns agents into a team++Three additions turn parallel sessions into something that behaves like a team:++- **Roles** — each agent gets a job, so "who should do this?" is obvious.+- **Shared memory** — a durable, [long-term memory](/blog/give-claude-code-long-term-memory/) every+ agent reads, so knowledge compounds instead of resetting.+- **Coordination** — agents message each other and an orchestrator routes work, so you're not the bus.++When you wrap your agents in that layer, you've got a [multi-agent harness](/blog/what-is-a-multi-agent-harness/)+— the concept that turns "five chat windows" into "one office."++## Where to go next++- Ready to run several? Start with [how to run multiple Claude Code+ agents](/blog/how-to-run-multiple-claude-code-agents/).+- Want the field of tools? See [the best tools to run multiple Claude Code+ agents](/blog/best-claude-code-multi-agent-tools/).+- Curious about the concept? [What is a multi-agent harness?](/blog/what-is-a-multi-agent-harness/)++---++Munder Difflin is the team layer for the Claude Code agents you already run — roles, shared memory,+messaging, and an orchestrator, all local. [Download Munder Difflin](/#install) to turn your agents+into an office; it's free and open source.diff --git a/blog/src/posts/why-local-first-matters-for-ai-agents.md b/blog/src/posts/why-local-first-matters-for-ai-agents.mdnew file mode 100644index 00000000..29fb553a--- /dev/null+++ b/blog/src/posts/why-local-first-matters-for-ai-agents.md@@ -0,0 +1,94 @@+---+title: "Why Local-First Matters for Your AI Agents"+description: "The control, privacy, and cost case for keeping your AI agents and their memory on your own machine — and what cloud orchestration quietly costs."+date: 2026-06-02+category: use-cases+categoryLabel: Use Cases+type: Non-technical+primaryKeyword: "local ai dev environment"+secondaryKeywords: ["local-first ai", "privacy", "ai data control"]+tags: ["Use Cases", "Local-First", "Privacy", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What does local-first mean for AI agents?"+ a: "Local-first means the orchestration layer, the agents, and their memory all run on your own machine — not in a vendor's cloud. Your agents still call the model API, but the coordination, files, and stored knowledge stay local."+ - q: "Is local-first more private than cloud agent platforms?"+ a: "Generally yes for everything except the model call itself. Your code, memory, message history, and orchestration never leave your machine, so there's a far smaller surface where your project data could be stored or exposed."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Local-first</strong> means your+agents, their orchestration, and their memory live on <em>your</em> machine — not in a vendor's cloud.+You get more <strong>control</strong> (it's your files and your rules), more <strong>privacy</strong>+(code and memory don't leave the box), and more predictable <strong>cost</strong> (no per-seat+platform fees on top of model usage). For AI agents that touch your whole codebase, that's not a+detail — it's the foundation.</p></div>++When people evaluate multi-agent tools, they fixate on features and skip the question that quietly+shapes everything: *where does this actually run?* For agents that read and edit your entire+codebase, the answer matters more than any single feature.++## What "local-first" actually means++Local-first doesn't mean "no internet." Your agents still call the model — that request goes to+Anthropic the same way your editor's does. Local-first is about *where the rest lives*:++- the **orchestration** that routes work between agents,+- the **files** the agents read and write,+- the **memory** the team accumulates, and+- the **message history** and event log of what happened.++In a [local-first setup](/#why), all of that stays on your machine. In a cloud platform, much of it+lives on someone else's servers. Same agents, very different trust model.++## Three reasons it matters++### 1. Control — it's your machine, your rules+Local agents work against your real working tree, your git, your environment, your tools. Nothing is+mediated by a platform's sandbox or subject to its outages, rate limits, or deprecations. When the+team is local, *you* own the failure modes — and you can fix them.++### 2. Privacy — your code and memory don't leave the box+Agents that touch your whole repo accumulate a lot of context: source, secrets-adjacent config,+internal docs, and a [memory store](/blog/give-claude-code-long-term-memory/) full of your project's+hard-won knowledge. Keeping orchestration and memory local means there's no third party storing your+codebase's working notes. For client work, regulated environments, or just good hygiene, that's a real+advantage.++### 3. Cost — predictable, without a platform tax+Cloud agent platforms typically charge per seat or per run *on top of* your model usage. Local-first+adds no platform tax — you pay for the model calls you'd make anyway. As you scale from a couple of+agents to a team, that difference compounds.++## What you give up in the cloud++It's only fair to name the trade. Cloud platforms can offer zero-setup onboarding, managed scaling,+and team features out of the box. If you need a hosted, shared, always-on service for a distributed+team, that convenience is real.++But for an individual developer or a small team running agents against their own code, the+convenience rarely outweighs handing over control, privacy, and predictable cost. You can have the+coordination *and* keep it local.++## Local-first doesn't mean uncoordinated++The old assumption was that local meant primitive — a few terminals, no shared brain. That's no longer+true. A [local multi-agent harness](/#what) gives you the full coordination layer — shared memory,+inter-agent messaging, an orchestrator, a visual floor — entirely on your machine. You don't trade+coordination for control; you get both.++That's the bet behind [running an office of AI agents](/blog/run-an-office-of-ai-agents/) locally, and+it's why the [shift from one terminal to a team](/blog/from-one-terminal-to-a-team/) doesn't require+moving to the cloud.++## The bottom line++For agents that live inside your codebase, *where it runs* is a first-class feature. Local-first buys+control, privacy, and predictable cost — and modern tooling means you no longer sacrifice coordination+to get them.++---++Munder Difflin is local-first by design: the hive, the orchestrator, and MemPalace all run on your+machine, on macOS, Windows, and Linux. [Download Munder Difflin](/#install) — free and open source.diff --git a/blog/src/posts/why-we-built-munder-difflin.md b/blog/src/posts/why-we-built-munder-difflin.mdnew file mode 100644index 00000000..8a065cc6--- /dev/null+++ b/blog/src/posts/why-we-built-munder-difflin.md@@ -0,0 +1,92 @@+---+title: "Why We Built Munder Difflin"+description: "The origin story of Munder Difflin — how the pain of juggling Claude Code terminals led to a coordinated, memory-backed hive of agents you can watch."+date: 2026-06-02+category: story+categoryLabel: Story+type: Non-technical+primaryKeyword: "munder difflin"+secondaryKeywords: ["munder difflin github", "multi-agent harness", "why munder difflin"]+tags: ["Story", "Multi-Agent", "Claude Code", "Open Source"]+author:+ name: Chaitanya Giri+ initials: CG+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>We built <strong>Munder Difflin</strong>+because running several Claude Code agents at once was powerful and miserable in equal measure — they+collided, forgot, and turned us into a human message bus. The fix wasn't a better terminal; it was a+<strong>coordination layer</strong>: roles, shared memory, messaging, and an orchestrator you talk to,+visualized as an office floor. This is the story of that itch.</p></div>++Every tool starts with an annoyance specific enough to act on. Munder Difflin started with a wall of+terminal tabs and the dawning realization that *I* had become the slowest part of my own setup.++## The itch++Claude Code is great. So great that one session was never enough for long. I'd open a second terminal+to parallelize, then a third, then a fourth. Throughput went up — and so did the chaos.++Three frustrations kept recurring, the same ones [everyone hits](/blog/from-one-terminal-to-a-team/):++- **They collided.** Two agents would edit the same file and race each other; git would throw+ `index.lock` errors and leave half-applied changes.+- **They forgot.** Each session started cold. What one agent figured out, the next couldn't use — so I+ copy-pasted findings between windows like a courier.+- **I lost track.** Six tabs in, "what is everyone doing right now?" had no answer. And lost track is+ where mistakes hide.++The agents weren't the bottleneck anymore. *I* was — the message bus, the conflict resolver, and the+project's only long-term memory.++## The realization++The instinct is to reach for a better terminal multiplexer. But the problem wasn't *running* agents in+parallel — plenty of tools do that well. The problem was that the agents had no way to **coordinate**:+no shared memory, no way to message each other, no one routing the work but me.++What I actually wanted was an *office*. A team where everyone has a role, shares what they learn, hands+work off directly, and answers to a manager I could talk to in plain language. The missing thing wasn't+more parallelism — it was the [coordination layer](/blog/what-is-a-multi-agent-harness/) on top of it.++## What we built++So that's what Munder Difflin is: a layer that wraps the Claude Code agents you already run and makes+them a team.++- **Roles** so each agent stays in its lane.+- **Shared memory** — a semantic store (MemPalace) the whole hive reads and writes, so knowledge+ compounds instead of resetting.+- **Messaging** — every agent has a mailbox; a router delivers between them, so they hand off work+ without me in the middle.+- **A GOD orchestrator** — a coordinator you talk to like a manager; it decomposes your intent and+ routes the work.+- **A floor you can watch** — agents as avatars at their desks, so the black box becomes something you+ can supervise at a glance.++And the joke that became the name: *the world's best agents, the world's worst paper company.* The+office metaphor isn't decoration — it turned out to be the clearest way to think about (and watch) a+team of coordinating agents.++## Why local, why open source++Two decisions were never really in question. **Local-first**, because agents that touch your whole+codebase shouldn't ship your code and memory to someone else's cloud — you keep the control, the+privacy, and the predictable cost ([the full case](/blog/why-local-first-matters-for-ai-agents/)).+And **open source (MIT)**, because a tool you run against your own code is one you should be able to+read, trust, and extend. The code lives on+[GitHub](https://github.com/chaitanyagiri/munder-difflin).++## What it's for++Munder Difflin is for the moment you've felt the wall — three or more agents, context evaporating, you+alt-tabbing as the message bus. It's the [office of agents](/blog/run-an-office-of-ai-agents/) I wanted+when I had eight tabs open and no idea what half of them were doing.++If you've been there, you already understand the itch. The rest of the common questions are answered in+the [Munder Difflin FAQ](/blog/munder-difflin-faq/).++---++We built it to scratch our own itch, then made it free for everyone with the same one. [Download+Munder Difflin](/#install) — it's open source and local-first, on macOS, Windows, and Linux.