an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
feat(blog): 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.