Skip to content

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

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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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 &amp; 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.md
new file mode 100644
index 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.