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

fix(blog): restore Kevin's internal link graph + add pillar uplinks on technical posts

Chaitanya Giri6da2cfdde3c7
diff --git a/blog/src/posts/atomic-file-mailboxes-for-agents.md b/blog/src/posts/atomic-file-mailboxes-for-agents.md
index 029d6876..4600faa5 100644
--- a/blog/src/posts/atomic-file-mailboxes-for-agents.md
+++ b/blog/src/posts/atomic-file-mailboxes-for-agents.md
@@ -163,7 +163,7 @@ agent-to-agent and agent-to-orchestrator.
---
-Munder Difflin runs exactly this mailbox system for a whole hive of Claude Code agents — atomic
+Munder Difflin runs exactly this mailbox system inside [a hive the GOD orchestrator runs](https://munderdiffl.in/#how) — atomic
delivery, speech-act messages, hop caps, and a full git audit trail, all local.
[Download Munder Difflin](https://munderdiffl.in/#install) to watch envelopes fly between agents on
the office floor; it's free and open source.
diff --git a/blog/src/posts/building-a-terminal-ui-xterm-node-pty.md b/blog/src/posts/building-a-terminal-ui-xterm-node-pty.md
index d8982092..c67e3f1c 100644
--- a/blog/src/posts/building-a-terminal-ui-xterm-node-pty.md
+++ b/blog/src/posts/building-a-terminal-ui-xterm-node-pty.md
@@ -202,7 +202,9 @@ A pool keeps correctness; a few habits keep it fast:
sessions, not a leak.
The deeper performance story — rendering backends, batching writes, and keeping CPU flat with many
-streaming PTYs — is its own topic, but the pool is the structural decision everything else builds on.
+streaming PTYs — gets its own deep dive in
+[rendering many live terminals without melting the CPU](/blog/rendering-many-live-terminals-performance/),
+but the pool is the structural decision everything else builds on.
## Why a harness needs all of this
diff --git a/blog/src/posts/claude-code-automation-while-you-sleep.md b/blog/src/posts/claude-code-automation-while-you-sleep.md
index 50a23351..ead51cb2 100644
--- a/blog/src/posts/claude-code-automation-while-you-sleep.md
+++ b/blog/src/posts/claude-code-automation-while-you-sleep.md
@@ -94,8 +94,10 @@ escalate to a human queue instead of executing. A good default critical list:
- **conflicts** the team can't resolve.
In a hive, the [orchestrator](/blog/how-the-god-orchestrator-works/) enforces this: routine decisions
-it makes itself, critical ones it routes to an approvals queue. You come back in the morning to a short
-list of "I needed your call on these," not a pile of irreversible actions.
+it makes itself, critical ones it routes to an approvals queue — the
+[human-in-the-loop approvals](/blog/human-in-the-loop-ai-agents/) that keep an overnight run safe. You
+come back in the morning to a short list of "I needed your call on these," not a pile of irreversible
+actions.
### Bounded scope
@@ -144,7 +146,7 @@ goals concrete and the guardrails tight, and the overnight shift earns its keep.
---
-Munder Difflin gives you the whole kit: an autonomous Stop-hook loop, an auto mode that skips routine
+Munder Difflin gives you [everything an overnight hive needs](https://munderdiffl.in/#why): an autonomous Stop-hook loop, an auto mode that skips routine
approvals, an orchestrator that escalates only the critical few, and a git audit log of the night.
[Download Munder Difflin](https://munderdiffl.in/#install) to let a hive of Claude Code agents build
while you sleep; it's free and open source.
diff --git a/blog/src/posts/claude-code-git-worktrees-vs-hive.md b/blog/src/posts/claude-code-git-worktrees-vs-hive.md
index 84bc764b..95655388 100644
--- a/blog/src/posts/claude-code-git-worktrees-vs-hive.md
+++ b/blog/src/posts/claude-code-git-worktrees-vs-hive.md
@@ -132,7 +132,8 @@ Pick based on how *interdependent* your parallel work is:
If you've ever wondered whether built-in mechanisms are enough versus an external coordination layer,
the same question shows up for [subagents vs a harness](/blog/claude-code-subagents-vs-multi-agent-harness/) —
and the answer rhymes: native primitives handle the small scale; a coordination layer handles the team
-scale.
+scale. For a concrete tool-vs-tool take on that coordination layer, see
+[Claude Squad vs Munder Difflin](/blog/claude-squad-vs-munder-difflin/).
## FAQ
@@ -147,7 +148,7 @@ not just isolation — is the thing you're missing.
---
-Munder Difflin is the coordination layer: shared memory, messaging, and a GOD orchestrator for a hive
+Munder Difflin is [the coordination layer](https://munderdiffl.in/#how): shared memory, messaging, and a GOD orchestrator for a hive
of Claude Code agents — and it plays nicely with the git workflow you already use.
[Download Munder Difflin](https://munderdiffl.in/#install) when isolation isn't enough and you need a
team; it's free and open source.
diff --git a/blog/src/posts/claude-code-hooks-explained.md b/blog/src/posts/claude-code-hooks-explained.md
index 66615688..87f50c9e 100644
--- a/blog/src/posts/claude-code-hooks-explained.md
+++ b/blog/src/posts/claude-code-hooks-explained.md
@@ -134,7 +134,8 @@ flags and environment variables.
Every tool event the harness receives is forwarded to the UI. That's what drives the office floor: when
an agent calls a file tool, its avatar walks to the right station; when it runs a command, it moves to
a terminal. Because the events are structured and come straight from Claude, the visualization reflects
-*real* activity rather than a scripted animation or fragile log-scraping.
+*real* activity rather than a scripted animation or fragile log-scraping — and it pairs with each
+agent's actual live terminal, [streamed without melting the CPU](/blog/rendering-many-live-terminals-performance/).
### Stop → the autonomous loop
@@ -179,7 +180,7 @@ elsewhere.
---
-Munder Difflin turns Claude Code's hook lifecycle into a live, autonomous office: real-time avatars
+Munder Difflin turns Claude Code's hook lifecycle into [a live, autonomous office](https://munderdiffl.in/#how): real-time avatars
from tool events and a self-draining work loop from the Stop hook — all without editing your repo.
[Download Munder Difflin](https://munderdiffl.in/#install) to see hooks driving a hive of agents; it's
free and open source.
diff --git a/blog/src/posts/claude-code-orchestration-guide.md b/blog/src/posts/claude-code-orchestration-guide.md
index 6e922bc0..d82d73ec 100644
--- a/blog/src/posts/claude-code-orchestration-guide.md
+++ b/blog/src/posts/claude-code-orchestration-guide.md
@@ -147,7 +147,7 @@ you stop being the router yourself, which is almost always the bigger time sink.
---
-Munder Difflin ships this orchestration model out of the box: a GOD agent you talk to, a reliable
+Munder Difflin ships this [orchestration model](https://munderdiffl.in/#how) out of the box: a GOD agent you talk to, a reliable
message router, and a human-approval queue for the critical few — all running locally.
[Download Munder Difflin](https://munderdiffl.in/#install) to orchestrate your own team of Claude Code
agents; it's free and open source.
diff --git a/blog/src/posts/claude-code-subagents-vs-multi-agent-harness.md b/blog/src/posts/claude-code-subagents-vs-multi-agent-harness.md
index da72a1a4..541b4084 100644
--- a/blog/src/posts/claude-code-subagents-vs-multi-agent-harness.md
+++ b/blog/src/posts/claude-code-subagents-vs-multi-agent-harness.md
@@ -125,7 +125,8 @@ Reach for a **harness** when:
That threshold — one agent's task vs. a coordinated team — is the whole decision. If you're hitting it,
the next read is [how to run multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/),
-and the concept underneath it is [what a multi-agent harness is](/blog/what-is-a-multi-agent-harness/).
+and for a concrete head-to-head of two ways to get a team, see
+[Claude Squad vs Munder Difflin](/blog/claude-squad-vs-munder-difflin/).
## FAQ
diff --git a/blog/src/posts/coordinating-ai-coding-agents.md b/blog/src/posts/coordinating-ai-coding-agents.md
index 8fca758a..2a2d67ec 100644
--- a/blog/src/posts/coordinating-ai-coding-agents.md
+++ b/blog/src/posts/coordinating-ai-coding-agents.md
@@ -132,6 +132,6 @@ running multiple agents.
---
Munder Difflin implements all five rules so you don't have to: single-writer workspaces, an atomic
-message router, a single-committer git layer, a single-scribe shared board, and a GOD orchestrator —
-all local and open source. [Download Munder Difflin](https://munderdiffl.in/#install) to coordinate
+message router, a single-committer git layer, a single-scribe shared board, and a
+[GOD orchestrator](https://munderdiffl.in/#how) — all local and open source. [Download Munder Difflin](https://munderdiffl.in/#install) to coordinate
your own team of Claude Code agents.
diff --git a/blog/src/posts/how-the-god-orchestrator-works.md b/blog/src/posts/how-the-god-orchestrator-works.md
index da7df3c7..28739a6e 100644
--- a/blog/src/posts/how-the-god-orchestrator-works.md
+++ b/blog/src/posts/how-the-god-orchestrator-works.md
@@ -125,9 +125,10 @@ addressed to the human (or flags it as needing human attention), and the harness
cap it at $5" — and that note is relayed back to the agent that asked, as a message from the human.
The agent picks up where it left off with your guidance in hand.
-Everything not on the critical list stays autonomous. This selective escalation is the entire reason a
-hive can run for a long stretch without babysitting: it interrupts you precisely when it should, and
-never otherwise. It's also the model's primary safety rail — the policy is the control surface, so you
+Everything not on the critical list stays autonomous. This selective escalation —
+[human-in-the-loop done right](/blog/human-in-the-loop-ai-agents/) — is the entire reason a hive can
+run for a long stretch without babysitting: it interrupts you precisely when it should, and never
+otherwise. It's also the model's primary safety rail — the policy is the control surface, so you
tighten or loosen it by editing the prompt.
## How a single request travels
@@ -173,6 +174,6 @@ another `claude` process — a special one.
---
-Munder Difflin's GOD orchestrator routes, adjudicates, and escalates for a whole hive of Claude Code
+Munder Difflin's [GOD orchestrator](https://munderdiffl.in/#how) routes, adjudicates, and escalates for a whole hive of Claude Code
agents — on your own machine, with a full audit trail. [Download Munder Difflin](https://munderdiffl.in/#install)
to put one in charge of your floor; it's free and open source.
diff --git a/blog/src/posts/manage-multiple-claude-code-sessions.md b/blog/src/posts/manage-multiple-claude-code-sessions.md
index 5f73bf4f..ad2fb4d2 100644
--- a/blog/src/posts/manage-multiple-claude-code-sessions.md
+++ b/blog/src/posts/manage-multiple-claude-code-sessions.md
@@ -123,6 +123,6 @@ the same progression with the orchestration layer in view.
---
-When the checklist starts feeling like a second job, that's what Munder Difflin automates: roles,
+When the checklist starts feeling like a second job, that's what a [multi-agent harness](https://munderdiffl.in/#what) like Munder Difflin automates: roles,
isolated agents, shared memory, and a single committer, all on your own machine.
[Download Munder Difflin](https://munderdiffl.in/#install) — it's free and open source.
diff --git a/blog/src/posts/semantic-memory-for-ai-agents.md b/blog/src/posts/semantic-memory-for-ai-agents.md
index 1c3e36f2..41e86971 100644
--- a/blog/src/posts/semantic-memory-for-ai-agents.md
+++ b/blog/src/posts/semantic-memory-for-ai-agents.md
@@ -80,8 +80,9 @@ There's also an architectural reason. Heavyweight memory frameworks tend to want
runtime* — they assume they're the thing running the loop. But when your agents are real `claude`
sessions, the runtime is already Claude Code. The memory layer should be a lightweight companion to
that, not a replacement for it. Markdown files plus a CLI-driven index fit that shape; a framework that
-wants to be in charge doesn't. (For the deeper case, see
-[how to give Claude Code long-term memory](/blog/give-claude-code-long-term-memory/).)
+wants to be in charge doesn't. (For the full argument, see
+[why we built agent memory markdown-first](/blog/markdown-first-agent-memory/); for the plain-English
+version, [how to give Claude Code long-term memory](/blog/give-claude-code-long-term-memory/).)
## The shape of a shared memory layer
@@ -163,7 +164,8 @@ it fuzzy.
---
-Munder Difflin gives every Claude Code agent markdown memory plus a shared semantic palace the whole
-hive can recall from — local, fast, and graceful when offline.
+Munder Difflin gives every Claude Code agent markdown memory plus
+[a shared semantic palace the whole hive can recall from](https://munderdiffl.in/#how) — local, fast,
+and graceful when offline.
[Download Munder Difflin](https://munderdiffl.in/#install) to give your agents memory that actually
sticks; it's free and open source.
diff --git a/blog/src/posts/single-committer-git-pattern.md b/blog/src/posts/single-committer-git-pattern.md
index 2da74a62..85b3c6fd 100644
--- a/blog/src/posts/single-committer-git-pattern.md
+++ b/blog/src/posts/single-committer-git-pattern.md
@@ -119,8 +119,9 @@ interactive input.
Here's the part that turns a workaround into an asset. Once one process owns every commit, the repo
stops being a liability and becomes a **serialized history of everything the team did**. Each routed
-message, each task assignment, each memory update lands as its own commit, in order. When a multi-agent
-run goes sideways, you don't guess — you read the log.
+message, each task assignment, each memory update lands as its own commit, in order — a natural
+companion to the [append-only event log](/blog/append-only-event-log-agents/) the hive also keeps. When
+a multi-agent run goes sideways, you don't guess — you read the history.
That pairs naturally with the messaging layer: agents coordinate through files (see
[atomic file mailboxes](/blog/atomic-file-mailboxes-for-agents/)), and the single committer commits
@@ -159,7 +160,7 @@ age-based cleanup, not just retries.
---
-Munder Difflin uses the single-committer pattern for its entire coordination layer: agents write
+Munder Difflin uses the single-committer pattern across the [multi-agent harness](https://munderdiffl.in/#what): agents write
files, one process commits with retry and stale-lock recovery, and the repo stays a clean audit log.
[Download Munder Difflin](https://munderdiffl.in/#install) to run a hive of Claude Code agents that
never corrupt their own state; it's free and open source.