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): seed three example posts from Kevin's SEO backlog

Chaitanya Giri6a42db22f97b
diff --git a/blog/src/posts/give-claude-code-long-term-memory.md b/blog/src/posts/give-claude-code-long-term-memory.md
new file mode 100644
index 00000000..207fc8d3
--- /dev/null
+++ b/blog/src/posts/give-claude-code-long-term-memory.md
@@ -0,0 +1,90 @@
+---
+title: "How to Give Claude Code Long-Term Memory"
+description: "Claude Code forgets between sessions. Here's how a markdown-first memory layer with semantic recall lets your agents remember across runs."
+date: 2026-05-27
+category: memory
+categoryLabel: Memory
+type: Technical
+primaryKeyword: "how to give claude code long-term memory"
+secondaryKeywords: ["ai agent long-term memory", "claude code memory", "semantic memory for ai agents"]
+tags: ["Memory", "MemPalace", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>Claude Code starts every session with a
+blank slate. Give it <strong>long-term memory</strong> by writing durable facts to plain markdown
+files the agent reads on startup, then layering a <strong>semantic index</strong> on top so it can
+recall the relevant note instead of re-reading everything. Markdown-first keeps memory
+human-readable, diffable, and degradation-proof.</p></div>
+
+Claude Code is sharp within a session and amnesiac between them. Close the terminal and the next run
+starts cold: it re-learns your conventions, re-discovers the codebase, re-asks what it already
+asked. For a single throwaway task that's fine. For a **team of agents** working over days, it's the
+core problem. Here's how to fix it.
+
+## Why agents forget
+
+An agent's "memory" is its context window — and the context window is wiped at the end of a session.
+Nothing it learned persists unless you **write it somewhere the next session will read.** That's the
+whole trick: long-term memory is just durable storage plus a habit of reading it on startup. This is
+the foundation of [agent long-term memory](https://munderdiffl.in/#how) in general.
+
+## Step 1: Write durable facts to markdown
+
+Give each agent a `memory.md` and a rule: when you learn something durable — a decision, a
+convention, a gotcha — append it. Keep entries small and atomic:
+
+```markdown
+## 2026-05-27 — build
+- The web bundle is built with electron-vite, NOT plain vite. Use `npm run build`.
+- node-pty needs an electron-rebuild after install (postinstall handles it).
+- Never edit docs/index.html by hand during a release — it's the REL fallback source.
+```
+
+Why markdown first? Because memory you can't read is memory you can't trust:
+
+- **Human-readable** — you can open it and see exactly what the agent "knows."
+- **Diffable** — it lives in git; you watch memory change over time.
+- **Degrades gracefully** — if the fancy index breaks, the files still work. A database that won't
+ open takes the memory with it.
+
+## Step 2: Add semantic recall on top
+
+Markdown alone doesn't scale — at 200 notes an agent can't read them all every startup. So index the
+notes and let the agent **recall by meaning**, not by filename:
+
+1. Embed each note (or each heading-scoped chunk) into a vector.
+2. On a new task, embed the task description and fetch the few most similar notes.
+3. Inject only those into context.
+
+This is what [semantic memory for AI agents](https://munderdiffl.in/#how) buys you: recall stays
+near-instant and the context window stays small, even as the knowledge base grows. In Munder Difflin
+this layer is **MemPalace** — a shared, searchable store the whole hive reads, mined automatically
+from each agent's markdown notes.
+
+### Keep writes single-owner
+
+One trap: if several agents write the same memory file at once, you get torn writes. Give each agent
+its **own** memory file and let a shared index aggregate them read-only. Same principle that keeps
+multi-agent git safe — one writer per file.
+
+## Step 3: Make reading a startup ritual
+
+Memory only helps if it's read. Bake it into the agent's startup: "before starting a task, recall
+relevant notes; after finishing, append what you learned." Once that loop is reliable, the briefs you
+write get shorter every week — the team stops needing context re-explained.
+
+## Where to go next
+
+- New to coordinating agents? Start with
+ [how to run multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/).
+- Want the bigger picture? [What is a multi-agent harness?](/blog/what-is-a-multi-agent-harness/)
+ explains where memory fits among messaging and orchestration.
+
+---
+
+Munder Difflin ships this memory model out of the box — markdown notes plus a shared semantic
+MemPalace, for a whole hive of agents. [Download Munder Difflin](https://munderdiffl.in/#install)
+to try it; it's free and open source.
diff --git a/blog/src/posts/how-to-run-multiple-claude-code-agents.md b/blog/src/posts/how-to-run-multiple-claude-code-agents.md
new file mode 100644
index 00000000..0496de42
--- /dev/null
+++ b/blog/src/posts/how-to-run-multiple-claude-code-agents.md
@@ -0,0 +1,101 @@
+---
+title: "How to Run Multiple Claude Code Agents (Without Losing Track)"
+description: "Run several Claude Code agents in parallel without the chaos: give each a role, let them coordinate, and stop alt-tabbing between terminal windows."
+date: 2026-06-01
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "how to run multiple claude code agents"
+secondaryKeywords: ["run multiple claude code agents", "claude code parallel agents", "claude code multi-agent setup"]
+tags: ["Guides", "Multi-Agent", "Claude Code", "Getting Started"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>You can run
+<strong>multiple Claude Code agents</strong> by opening several sessions, but the wins only show up
+once you <strong>give each a role</strong>, <strong>let them coordinate</strong> (messaging + shared
+memory), and <strong>watch the work</strong> instead of alt-tabbing. This guide covers the manual
+way, where it breaks, and the harness that automates it.</p></div>
+
+Running one Claude Code agent is easy. Running *five* usefully is the hard part — and it's where most
+people give up, drowning in terminal tabs. Here's how to run multiple Claude Code agents in parallel
+without losing the thread.
+
+## Start with the manual approach
+
+You don't need any tooling to begin. Open several terminals and start a `claude` session in each,
+one per task:
+
+```bash
+# terminal 1 — the test-writer
+cd ~/project && claude
+
+# terminal 2 — the docs-fixer
+cd ~/project && claude
+
+# terminal 3 — the refactorer
+cd ~/project && claude
+```
+
+This works for two or three **independent** tasks. The moment they overlap, three problems appear.
+
+## Where the manual approach breaks
+
+### 1. They collide on files
+Two agents editing the same file race each other; in a git repo you get `index.lock` errors and
+half-applied changes. Parallel agents need a coordination rule, not just separate windows.
+
+### 2. They don't share what they learn
+Each session has its own context. Agent 2 can't use what agent 1 just figured out, so you become the
+courier — copy-pasting findings between windows. That's the
+[long-term memory problem](/blog/give-claude-code-long-term-memory/), and it compounds fast.
+
+### 3. You can't see the whole board
+With six tabs open, "what is everyone doing right now?" has no answer. You lose track, and lost track
+is where mistakes hide.
+
+## Make it work: roles, coordination, visibility
+
+The fix isn't more tabs — it's three habits:
+
+### Give each agent a role
+Name them and scope them: *test-writer*, *reviewer*, *refactorer*. A role keeps an agent from
+wandering into another's work and makes "who should do this?" obvious.
+
+### Let them coordinate
+Agents need to pass messages and share memory **without going through you**. A durable mailbox
+(agent A writes, agent B reads) plus a shared memory store means findings flow between agents
+directly. For the coordination model, see
+[what is a multi-agent harness](/blog/what-is-a-multi-agent-harness/).
+
+### Route work through an orchestrator
+Instead of hand-assigning every task, you describe intent once and a coordinator decomposes and
+routes it. In Munder Difflin that's the [GOD orchestrator](https://munderdiffl.in/#how) — you talk to
+it in plain language and it assigns the agents.
+
+### Watch the floor
+Seeing the team work — who's busy, who's idle, what messages are flying — turns a black box into
+something you can supervise. Visibility is what makes running many agents feel calm instead of
+chaotic.
+
+## From tabs to a team
+
+The progression is always the same: one session → a few manual tabs → a coordinated team. Once you
+hit the tab-juggling stage, a harness automates exactly the three habits above so you stop being the
+message bus.
+
+## Next steps
+
+- [How to give Claude Code long-term memory](/blog/give-claude-code-long-term-memory/) — so the team
+ stops forgetting.
+- [What is a multi-agent harness?](/blog/what-is-a-multi-agent-harness/) — the concept behind the
+ coordination.
+
+---
+
+Munder Difflin runs all of this for you: roles, mailboxes, shared memory, a GOD orchestrator, and a
+live office floor — locally, on your own Claude plan.
+[Download Munder Difflin](https://munderdiffl.in/#install) to run your first coordinated team; it's
+free and open source.
diff --git a/blog/src/posts/what-is-a-multi-agent-harness.md b/blog/src/posts/what-is-a-multi-agent-harness.md
new file mode 100644
index 00000000..9e7c0152
--- /dev/null
+++ b/blog/src/posts/what-is-a-multi-agent-harness.md
@@ -0,0 +1,86 @@
+---
+title: "What Is a Multi-Agent Harness? (Plain-English Guide)"
+description: "A multi-agent harness coordinates several AI coding agents into one team — here's what that means, and how it differs from a single agent or a framework."
+date: 2026-05-22
+category: concepts
+categoryLabel: Concepts
+type: Non-technical
+primaryKeyword: "claude code multi-agent"
+secondaryKeywords: ["multi-agent harness", "multi-agent ai framework", "ai agent harness"]
+tags: ["Concepts", "Multi-Agent", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is a multi-agent harness?"
+ a: "A multi-agent harness is software that runs several AI agents at once and coordinates them — giving each a role, letting them message each other, sharing memory, and routing work — so they act as one team instead of isolated sessions."
+ - q: "How is a harness different from a framework like LangGraph or CrewAI?"
+ a: "A framework is a library you write an agent app with. A harness wraps agents you already run (like Claude Code terminals) and adds coordination — messaging, memory, orchestration, and visibility — without you rebuilding your agent from scratch."
+ - q: "Do I need a multi-agent harness to use Claude Code?"
+ a: "No. One Claude Code session is plenty for many tasks. A harness helps once you're running several at once and the coordination overhead (who does what, who knows what) starts to cost you time."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>A multi-agent harness</strong> is
+software that runs several AI agents at once and makes them act like a team: each gets a role, they
+message each other, share long-term memory, and a coordinator routes work between them. It's the
+layer that turns "five chat windows" into "one office."</p></div>
+
+If you've run more than one AI coding agent at the same time, you've felt the problem: two agents
+edit the same file, neither remembers what the other did, and you become the human message bus
+alt-tabbing between windows. A **multi-agent harness** is the software that fixes that.
+
+## A multi-agent harness, in one sentence
+
+> A multi-agent harness runs several AI agents concurrently and coordinates them — roles, messaging,
+> shared memory, and work routing — so they behave as a single team.
+
+That's the whole idea. Everything else is detail about *how* the coordination happens.
+
+## What it adds on top of a single agent
+
+A single agent is a loop: read context, take an action, repeat. A harness wraps **many** of those
+loops and adds the parts a lone agent doesn't have:
+
+- **Roles.** Each agent gets a job (researcher, builder, reviewer) instead of all of them doing
+ everything.
+- **Messaging.** Agents pass information to each other directly, rather than through you.
+- **Shared memory.** Durable, cross-session knowledge so agent B can use what agent A learned.
+- **Orchestration.** A coordinator that decomposes your intent and assigns work — in Munder Difflin
+ that's the [GOD orchestrator](https://munderdiffl.in/#how), an agent you talk to in plain language.
+- **Visibility.** A way to *see* what the team is doing, so it's not a black box.
+
+## Harness vs. framework vs. subagents
+
+These three get conflated. The difference is what you bring to the table:
+
+### Framework
+A library (LangGraph, CrewAI, AutoGen) you **build an agent application with**. You write the graph,
+the tools, the prompts. Powerful, but it's a from-scratch build.
+
+### Subagents
+A single agent **spawning helpers** inside its own run. Useful for fan-out, but the helpers are
+short-lived and scoped to that one parent — no shared memory across your whole workflow.
+
+### Harness
+Software that **wraps agents you already run** and coordinates them. You don't rebuild your agent;
+you keep using Claude Code, and the harness adds messaging, memory, orchestration, and a view of the
+floor. That's the [multi-agent harness](https://munderdiffl.in/#what) approach.
+
+## When you actually need one
+
+You don't need a harness to use Claude Code. You start wanting one when:
+
+- you're running **three or more** sessions and losing track of which is doing what,
+- you keep **re-explaining context** because each session forgets, or
+- two agents **collide** on the same files.
+
+If that's you, the next step is a practical one:
+[how to run multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/) without
+losing track, and [how to give Claude Code long-term memory](/blog/give-claude-code-long-term-memory/)
+so the team stops forgetting.
+
+---
+
+Munder Difflin is exactly this: a local, open-source multi-agent harness for Claude Code. If you
+want to watch a coordinated team of agents work an office floor,
+[download Munder Difflin](https://munderdiffl.in/#install) — it's free and MIT-licensed.