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

blog: refresh five flagship guides for v0.4.4, with rich bespoke illustrations

Chaitanya Giri0c941d16e3d7
diff --git a/blog/media-src/scene-lib.js b/blog/media-src/scene-lib.js
index 15f837cf..b12980c4 100644
--- a/blog/media-src/scene-lib.js
+++ b/blog/media-src/scene-lib.js
@@ -220,6 +220,237 @@ const ARCH = {
},
};
+// ---- extra parts for rich scenes ----
+const plant = (x, y, s = 1) => `<path d="M${x - 18 * s} ${y} h${36 * s} l${-5 * s} ${26 * s} h${-26 * s} z"/>` +
+ `<path d="M${x} ${y} C ${x - 4 * s} ${y - 28 * s}, ${x - 22 * s} ${y - 34 * s}, ${x - 26 * s} ${y - 52 * s} M${x} ${y} C ${x + 2 * s} ${y - 30 * s}, ${x + 20 * s} ${y - 30 * s}, ${x + 26 * s} ${y - 50 * s} M${x} ${y} V ${y - 44 * s}"/>`;
+const mug = (x, y, s = 1) => `<path d="M${x - 14 * s} ${y} v${-22 * s} h${28 * s} v${22 * s} z"/><path d="M${x + 14 * s} ${y - 18 * s} c ${12 * s} 0 ${12 * s} ${14 * s} 0 ${14 * s}"/>` +
+ `<path d="M${x - 4 * s} ${y - 30 * s} c 2 -4 -2 -6 0 -10 M${x + 5 * s} ${y - 30 * s} c 2 -4 -2 -6 0 -10"/>`;
+const laptop = (x, y, w) => `<rect x="${x}" y="${y - w * 0.6}" width="${w}" height="${w * 0.6}" rx="4"/><path d="M${x - w * 0.08} ${y} h${w * 1.16} l${-w * 0.05} ${w * 0.09} h${-w * 1.06} z"/>` +
+ `<path d="M${x + w * 0.14} ${y - w * 0.42} h${w * 0.5} M${x + w * 0.14} ${y - w * 0.3} h${w * 0.66} M${x + w * 0.14} ${y - w * 0.18} h${w * 0.4}"/>`;
+const rack = (x, y, w, h) => { let s = `<rect x="${x}" y="${y}" width="${w}" height="${h}" rx="5"/>`;
+ const rows = 4; for (let i = 0; i < rows; i++) { const ry = y + 12 + i * ((h - 24) / rows);
+ s += `<rect x="${x + 12}" y="${ry}" width="${w - 24}" height="${(h - 24) / rows - 10}" rx="3"/><circle cx="${x + 28}" cy="${ry + (h - 24) / rows / 2 - 5}" r="4"/><path d="M${x + w - 52} ${ry + (h - 24) / rows / 2 - 5} h28"/>`; }
+ return s; };
+const cloudS = (x, y, s = 1) => `<path d="M${x} ${y} a${26 * s} ${26 * s} 0 0 1 ${24 * s} ${-30 * s} a${30 * s} ${30 * s} 0 0 1 ${58 * s} ${-4 * s} a${22 * s} ${22 * s} 0 0 1 ${20 * s} ${34 * s} z"/>`;
+const keyI = (x, y, s = 1) => `<circle cx="${x}" cy="${y}" r="${13 * s}"/><path d="M${x + 11 * s} ${y + 8 * s} l${34 * s} ${24 * s}"/><path d="M${x + 30 * s} ${y + 21 * s} l${-7 * s} ${9 * s} M${x + 41 * s} ${y + 29 * s} l${-7 * s} ${9 * s}"/>`;
+const wrench = (x, y, s = 1) => `<path d="M${x} ${y} a${12 * s} ${12 * s} 0 1 0 ${8 * s} ${-20 * s} l${4 * s} ${-10 * s} a${16 * s} ${16 * s} 0 0 1 ${-20 * s} ${20 * s} z" transform="rotate(28 ${x} ${y})"/><path d="M${x + 4 * s} ${y + 4 * s} l${34 * s} ${34 * s}" stroke-width="5"/>`;
+const browserW = (x, y, w, h) => `<rect x="${x}" y="${y}" width="${w}" height="${h}" rx="7"/><path d="M${x} ${y + 34} h${w}"/>` +
+ `<circle cx="${x + 18}" cy="${y + 17}" r="4"/><circle cx="${x + 34}" cy="${y + 17}" r="4"/><circle cx="${x + 50}" cy="${y + 17}" r="4"/>` +
+ `<rect x="${x + 66}" y="${y + 8}" width="${w * 0.6}" height="18" rx="9"/>`;
+const checklist = (x, y, w, rows) => { let s = `<rect x="${x}" y="${y}" width="${w}" height="${rows.length * 44 + 26}" rx="6"/>`;
+ rows.forEach((r, i) => { const ry = y + 30 + i * 44;
+ s += `<rect x="${x + 16}" y="${ry - 14}" width="20" height="20" rx="4"/>`;
+ if (r) s += `<path d="M${x + 20} ${ry - 5} l5 6 l10 -13" stroke-width="3.4"/>`;
+ s += `<path d="M${x + 50} ${ry - 4} h${w * 0.5}"/>`; });
+ return s; };
+const diffdoc = (x, y, w, h) => { let s = `<rect x="${x}" y="${y}" width="${w}" height="${h}" rx="5"/><path d="M${x + w / 2} ${y} v${h}"/>`;
+ for (let i = 0; i < 4; i++) { const ry = y + h * 0.18 + i * h * 0.19;
+ s += `<path d="M${x + w * 0.08} ${ry} h${w * 0.3}"/><path d="M${x + w * 0.58} ${ry} h${w * 0.3}"/>`; }
+ s += `<text x="${x + w * 0.08}" y="${y + h * 0.12}" font-size="26" fill="${INK}" stroke="none" font-family="Caveat">−</text>` +
+ `<text x="${x + w * 0.58}" y="${y + h * 0.12}" font-size="26" fill="${INK}" stroke="none" font-family="Caveat">+</text>`;
+ return s; };
+const gauge = (x, y, r) => `<path d="M${x - r} ${y} a${r} ${r} 0 0 1 ${2 * r} 0"/><path d="M${x} ${y} L${x + r * 0.55} ${y - r * 0.55}" stroke-width="4"/><circle cx="${x}" cy="${y}" r="4"/>`;
+const chip = (x, y, w, label) => `<rect x="${x}" y="${y}" width="${w}" height="34" rx="17"/>` + txt(x + w / 2, y + 24, label, BLUE, 24, "middle");
+const stampI = (x, y, s = 1) => `<path d="M${x - 20 * s} ${y} h${40 * s} v${8 * s} h${-40 * s} z M${x - 8 * s} ${y} v${-16 * s} a${8 * s} ${8 * s} 0 0 1 ${16 * s} 0 v${16 * s}"/>`;
+
+// Bespoke rich hero scenes for flagship guides — keyed by slug, they override
+// the archetype. Denser: more props, more story, a few more (short) labels.
+const RICH = {
+ "your-first-hour-with-munder-difflin"(r, A) {
+ let s = `<path d="M120 700 L1480 700"/>`;
+ // stage 1: the download box
+ s += box(150, 590, 120, 100) + `<path d="M210 610 v40 m-14 -14 l14 14 l14 -14"/>`;
+ s += txt(140, 560, "min 0 — install", AMBER, 28);
+ // stage 2: wizard checklist
+ s += checklist(390, 480, 220, [true, true, true, false]);
+ s += txt(390, 452, "min 5 — meet your clone", BLUE, 28);
+ // stage 3: brief Michael at his desk
+ s += desk(720, 620, 300) + terminal(770, 500, 170, 100) + hei(700, 560, 0.72, { legs: "none", armR: "out", armL: "none" });
+ s += bubble(640, 350, 250, 84, 1) + txt(672, 402, "brief him once", BLUE, 26);
+ s += mug(1000, 618, 1) + plant(1090, 690, 1);
+ // stage 4: kanban + clock, walk away
+ s += `<rect x="1180" y="470" width="220" height="180" rx="4"/><path d="M1253 470 v180 M1326 470 v180"/><path d="M1180 505 h220"/>`;
+ s += sticky(1196, 520, 42, -3) + sticky(1268, 526, 42, 3) + sticky(1340, 520, 42, -2) + `<path d="M1348 578 l12 12 l20 -24" stroke-width="3.6"/>`;
+ s += clock(1450, 380, 52);
+ s += hei(1130, 380, 0.62, { legs: "walk", armL: "down", armR: "out" });
+ s += envelope(1030, 260, 56, 8);
+ s += txt(1170, 690, "min 60 — walk away", ORANGE, 30);
+ // journey arrows
+ s += `<path d="M290 640 C 330 640, 350 620, 380 600" marker-end="url(#ah)"/>`;
+ s += `<path d="M620 580 C 650 590, 670 600, 700 610" marker-end="url(#ah)"/>`;
+ s += `<path d="M1040 580 C 1090 570, 1120 555, 1165 540" marker-end="url(#ah)"/>`;
+ return s + txt(150, 240, "one hour, four moves", BLUE, 34);
+ },
+ "how-to-install-and-use-munder-difflin"(r, A) {
+ let s = `<path d="M140 700 L1460 700"/>`;
+ // big terminal running the install
+ s += terminal(430, 250, 480, 300);
+ s += txt(470, 480, "npm install && npm run dev", BLUE, 27);
+ // three platform boxes
+ [["macOS", 430], ["Windows", 600], ["Linux", 770]].forEach(([lbl, x]) => {
+ s += box(x, 590, 140, 84, false) + txt(x + 70, 645, lbl, BLUE, 26, "middle");
+ });
+ // prerequisites panel
+ s += checklist(1080, 260, 250, [true, true, true, true]);
+ s += txt(1085, 232, "prerequisites: all green", AMBER, 27);
+ // Hei carrying a box toward the desk, with tools
+ s += hei(250, 520, 0.9, { legs: "walk", armL: "up", armR: "up" });
+ s += box(200, 380, 110, 70);
+ s += wrench(1130, 560, 1);
+ s += plant(1420, 690, 1.1) + mug(1010, 588, 1);
+ s += `<path d="M950 400 C 1010 390, 1030 380, 1070 360" marker-end="url(#ah)"/>`;
+ return s + txt(150, 240, "ten engines, one office", BLUE, 32) + txt(950, 780, A.orange || "from zero to a working hive", ORANGE, 34);
+ },
+ "run-munder-difflin-on-open-models"(r, A) {
+ let s = `<path d="M120 700 L1480 700"/>`;
+ // left: your machine
+ s += desk(180, 620, 380) + laptop(260, 560, 180);
+ s += chip(200, 640, 190, "local/gpt-oss:20b") + mug(560, 618, 0.9);
+ s += txt(180, 300, "your machine", BLUE, 30) + txt(180, 338, "private · no per-token bill", AMBER, 24);
+ // right: provider rack + cloud
+ s += rack(1160, 380, 260, 240) + cloudS(1310, 250, 0.9);
+ s += chip(1150, 650, 280, "openrouter/deepseek-v4");
+ s += txt(1140, 300, "provider GPUs", BLUE, 30) + txt(1140, 338, "frontier scale · your key", AMBER, 24);
+ // center: Hei with the key, cables to both
+ s += hei(790, 500, 1, { legs: "stand", armL: "out", armR: "out" });
+ s += keyI(770, 350, 1.1);
+ s += `<path d="M700 520 C 600 540, 520 550, 450 560" marker-end="url(#ah)"/>`;
+ s += `<path d="M880 520 C 990 540, 1060 545, 1140 540" marker-end="url(#ah)"/>`;
+ return s + txt(620, 790, A.orange || "your floor, your weights", ORANGE, 34);
+ },
+ "deploy-a-blog-writer-agent"(r, A) {
+ let s = `<path d="M110 700 L1490 700"/>`;
+ // writer desk: papers + style book
+ s += desk(150, 620, 330) + terminal(200, 505, 150, 95) + hei(160, 560, 0.66, { legs: "none", armR: "out", armL: "none" });
+ s += `<rect x="370" y="560" width="70" height="8" rx="2"/><rect x="365" y="548" width="70" height="8" rx="2"/><rect x="372" y="536" width="70" height="8" rx="2"/>`;
+ s += book(300, 660, 120);
+ s += txt(150, 460, "draft, in a worktree", BLUE, 27);
+ // Michael integrates: stamp
+ s += desk(620, 620, 260) + hei(700, 545, 0.7, { legs: "none", armL: "down", armR: "up" });
+ s += stampI(790, 512, 1.2);
+ s += txt(610, 452, "one committer", AMBER, 26);
+ // build: blocks
+ s += box(960, 560, 90, 60, true) + box(985, 495, 90, 60, true);
+ // live site
+ s += browserW(1130, 420, 320, 210);
+ s += txt(1210, 462, "munderdiffl.in/blog", BLUE, 23);
+ s += `<path d="M1180 500 h220 M1180 540 h160 M1180 580 h190"/>`;
+ // human gate before the site
+ s += bell(1090, 350, 1) + `<path d="M1130 290 l14 -14 M1140 312 l18 -6"/>`;
+ s += txt(1010, 260, "one human gate: publish", ORANGE, 28);
+ // flow arrows
+ s += `<path d="M490 590 C 540 590, 560 585, 605 580" marker-end="url(#ah)"/>`;
+ s += `<path d="M890 580 C 920 575, 930 570, 950 565" marker-end="url(#ah)"/>`;
+ s += `<path d="M1080 520 C 1100 510, 1110 505, 1125 500" marker-end="url(#ah)"/>`;
+ s += plant(560, 690, 1) + mug(905, 618, 0.9) + envelope(520, 400, 54, -8);
+ return s + txt(150, 250, "the blog that writes itself", BLUE, 33);
+ },
+ "deploy-automated-pr-reviewer-agent"(r, A) {
+ let s = `<path d="M110 700 L1490 700"/>`;
+ // incoming PR envelopes on a conveyor
+ s += `<path d="M150 470 h300"/><circle cx="190" cy="486" r="14"/><circle cx="300" cy="486" r="14"/><circle cx="410" cy="486" r="14"/>`;
+ s += envelope(170, 400, 78, -5) + envelope(280, 405, 78, 4) + envelope(390, 398, 78, -2);
+ s += txt(160, 360, "PRs + issues, all of them", BLUE, 27);
+ // reviewer reading the real diff
+ s += desk(620, 620, 320) + hei(690, 545, 0.8, { legs: "none", armR: "out", armL: "none" });
+ s += diffdoc(790, 420, 210, 180) + magnifier(770, 480, 1);
+ s += txt(620, 380, "reads the real source", AMBER, 27);
+ // dupes funnel into one finding
+ s += `<path d="M1090 430 L1210 430 L1180 520 L1120 520 z"/>`;
+ s += sticky(1098, 380, 34, -6) + sticky(1140, 372, 34, 4) + sticky(1180, 382, 34, -3);
+ s += box(1110, 560, 90, 62, true);
+ s += txt(1230, 400, "dupes in", AMBER, 24) + txt(1230, 600, "one finding out", AMBER, 24);
+ // escalation: flag + bell to you
+ s += flag(1390, 560, 1.2) + bell(1400, 660, 0.9);
+ s += `<path d="M1210 590 C 1280 585, 1320 580, 1360 570" marker-end="url(#ah)"/>`;
+ s += `<path d="M470 440 C 530 460, 560 480, 600 520" marker-end="url(#ah)"/>`;
+ s += mug(960, 618, 0.9) + plant(560, 690, 1);
+ return s + txt(1010, 780, A.orange || "pings you only when it matters", ORANGE, 32);
+ },
+};
+
+// Bespoke rich note vignettes, keyed "slug#n" — override NOTES for these posts.
+const RICHNOTE = {
+ "your-first-hour-with-munder-difflin#1"(r) {
+ let s = checklist(360, 130, 300, [true, true, true, true]);
+ s += txt(370, 105, "git ✓ node ✓ uv ✓ engines ✓", AMBER, 26);
+ s += hei(850, 330, 0.8, { legs: "stand", armL: "out", armR: "down" }) + wrench(950, 240, 0.9);
+ return s;
+ },
+ "your-first-hour-with-munder-difflin#2"(r) {
+ let s = desk(320, 420, 560) + terminal(380, 250, 240, 150);
+ s += gauge(760, 330, 54) + txt(700, 410, "context left", BLUE, 25);
+ s += hei(280, 350, 0.66, { legs: "none", armR: "out", armL: "none" }) + mug(680, 418, 0.9);
+ return s;
+ },
+ "how-to-install-and-use-munder-difflin#1"(r) {
+ let s = checklist(380, 110, 320, [true, true, false, true]);
+ s += txt(390, 88, "prerequisites", AMBER, 26);
+ s += hei(880, 320, 0.8, { legs: "stand", armR: "out", armL: "down" });
+ s += bubble(940, 130, 200, 78, -1) + txt(975, 178, "I'll install it", BLUE, 24);
+ return s;
+ },
+ "how-to-install-and-use-munder-difflin#2"(r) {
+ let s = `<rect x="380" y="110" width="330" height="330" rx="8"/>`;
+ s += `<path d="M410 170 h180 M410 225 h240 M410 280 h150 M410 335 h210"/>`;
+ s += hei(560, 395, 0.42, { legs: "none", armL: "none", armR: "none" });
+ s += txt(400, 92, "add agent", BLUE, 26);
+ s += `<path d="M730 280 C 790 285, 820 290, 860 300" marker-end="url(#ah)"/>`;
+ s += miniAtDesk(950, 290);
+ return s;
+ },
+ "run-munder-difflin-on-open-models#1"(r) {
+ let s = chip(230, 160, 230, "local/gpt-oss:20b");
+ s += chip(230, 250, 250, "ollama/qwen3:30b");
+ s += chip(230, 340, 320, "openrouter/deepseek-v4");
+ s += txt(240, 130, "same model, three prefixes", AMBER, 26);
+ s += hei(820, 310, 0.8, { legs: "stand", armL: "out", armR: "down" }) + magnifier(730, 230, 0.9);
+ return s;
+ },
+ "run-munder-difflin-on-open-models#2"(r) {
+ let s = keyI(280, 210, 1.2) + box(480, 160, 190, 110, true);
+ s += txt(490, 140, "write-only broker", AMBER, 25);
+ s += `<path d="M330 240 C 390 235, 420 225, 470 215" marker-end="url(#ah)"/>`;
+ s += `<path d="M680 215 C 750 225, 790 245, 840 270" marker-end="url(#ah)"/>`;
+ s += miniAtDesk(950, 290);
+ return s;
+ },
+ "deploy-a-blog-writer-agent#1"(r) {
+ let s = "";
+ const stages = ["brief", "draft", "commit", "build", "gate"];
+ stages.forEach((t, i) => {
+ const x = 190 + i * 190;
+ s += box(x, 230, 130, 84, false) + txt(x + 65, 285, t, BLUE, 26, "middle");
+ if (i < 4) s += `<path d="M${x + 138} 272 C ${x + 158} 272, ${x + 165} 272, ${x + 182} 272" marker-end="url(#ah)"/>`;
+ });
+ s += clock(1090, 150, 44);
+ s += `<path d="M1055 380 l14 16 l26 -30" stroke-width="4"/>`;
+ return s;
+ },
+ "deploy-a-blog-writer-agent#2"(r) {
+ let s = hei(400, 300, 0.85, { legs: "stand", armR: "up", armL: "down" }) + stampI(505, 210, 1.2);
+ s += browserW(640, 150, 300, 200);
+ s += `<path d="M690 230 h200 M690 270 h150 M690 310 h180"/>`;
+ s += `<path d="M960 250 l20 22 l36 -42" stroke-width="4"/>`;
+ return s;
+ },
+ "deploy-automated-pr-reviewer-agent#1"(r) {
+ let s = diffdoc(420, 120, 300, 260) + magnifier(400, 260, 1.2);
+ s += hei(280, 330, 0.75, { legs: "stand", armR: "out", armL: "down" });
+ s += txt(760, 180, "the diff, not the description", AMBER, 26);
+ return s;
+ },
+ "deploy-automated-pr-reviewer-agent#2"(r) {
+ let s = envelope(220, 140, 66, -6) + envelope(310, 130, 66, 5) + envelope(260, 220, 66, 2) + envelope(350, 210, 66, -3);
+ s += `<path d="M440 220 L620 220 L580 320 L480 320 z"/>`;
+ s += box(500, 360, 90, 64, true);
+ s += `<path d="M600 390 C 680 385, 730 375, 790 360" marker-end="url(#ah)"/>`;
+ s += bell(880, 350, 1.1) + `<path d="M935 275 l16 -16 M945 300 l22 -8"/>`;
+ s += txt(700, 160, "noise in, signal out", AMBER, 27);
+ return s;
+ },
+};
+
// ---- inline note vignettes (1200x560) ----
// Small mid-post sketches. One or two parts, at most a tiny fixed label —
// the post's own figcaption (if any) carries the meaning. Two variants per
@@ -357,8 +588,9 @@ function buildNote(slug, spec, which) {
const r = rng(`${slug}#note${which}`);
const seed = Math.floor(r() * 900) + 2;
LABELS = "";
+ const rich = RICHNOTE[`${slug}#${which}`];
const variants = NOTES[spec.a] || [V.walk, V.point];
- const inner = variants[(which - 1) % variants.length](r, spec);
+ const inner = rich ? rich(r, spec) : variants[(which - 1) % variants.length](r, spec);
return `<svg width="${NOTE_W}" height="${NOTE_H}" viewBox="0 0 ${NOTE_W} ${NOTE_H}" font-family="Caveat">
<defs>
<filter id="wob" x="-5%" y="-5%" width="110%" height="110%">
@@ -381,7 +613,7 @@ function buildScene(slug, spec) {
const r = rng(slug);
const seed = Math.floor(r() * 900) + 2;
LABELS = "";
- const inner = ARCH[spec.a](r, spec);
+ const inner = (RICH[slug] || ARCH[spec.a])(r, spec);
return `<svg width="1600" height="900" viewBox="0 0 1600 900" font-family="Caveat">
<defs>
<filter id="wob" x="-5%" y="-5%" width="110%" height="110%">
diff --git a/blog/src/assets/media/deploy-a-blog-writer-agent/hero.png b/blog/src/assets/media/deploy-a-blog-writer-agent/hero.png
index 0b6c8e44..069534d8 100644
Binary files a/blog/src/assets/media/deploy-a-blog-writer-agent/hero.png and b/blog/src/assets/media/deploy-a-blog-writer-agent/hero.png differ
diff --git a/blog/src/assets/media/deploy-a-blog-writer-agent/note-1.png b/blog/src/assets/media/deploy-a-blog-writer-agent/note-1.png
index d7faecc4..cc53765d 100644
Binary files a/blog/src/assets/media/deploy-a-blog-writer-agent/note-1.png and b/blog/src/assets/media/deploy-a-blog-writer-agent/note-1.png differ
diff --git a/blog/src/assets/media/deploy-a-blog-writer-agent/note-2.png b/blog/src/assets/media/deploy-a-blog-writer-agent/note-2.png
index f3f4c1e7..b2a1c48e 100644
Binary files a/blog/src/assets/media/deploy-a-blog-writer-agent/note-2.png and b/blog/src/assets/media/deploy-a-blog-writer-agent/note-2.png differ
diff --git a/blog/src/assets/media/deploy-automated-pr-reviewer-agent/hero.png b/blog/src/assets/media/deploy-automated-pr-reviewer-agent/hero.png
index b60090d4..41490b8b 100644
Binary files a/blog/src/assets/media/deploy-automated-pr-reviewer-agent/hero.png and b/blog/src/assets/media/deploy-automated-pr-reviewer-agent/hero.png differ
diff --git a/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-1.png b/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-1.png
index 738806fc..1c90be20 100644
Binary files a/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-1.png and b/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-1.png differ
diff --git a/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-2.png b/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-2.png
index 6dafa86e..d8ca277d 100644
Binary files a/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-2.png and b/blog/src/assets/media/deploy-automated-pr-reviewer-agent/note-2.png differ
diff --git a/blog/src/assets/media/how-to-install-and-use-munder-difflin/hero.png b/blog/src/assets/media/how-to-install-and-use-munder-difflin/hero.png
index bf812aac..5c12fa2f 100644
Binary files a/blog/src/assets/media/how-to-install-and-use-munder-difflin/hero.png and b/blog/src/assets/media/how-to-install-and-use-munder-difflin/hero.png differ
diff --git a/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-1.png b/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-1.png
index 81d7bfb7..1edc69e4 100644
Binary files a/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-1.png and b/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-1.png differ
diff --git a/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-2.png b/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-2.png
index 758755e2..b12e94bc 100644
Binary files a/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-2.png and b/blog/src/assets/media/how-to-install-and-use-munder-difflin/note-2.png differ
diff --git a/blog/src/assets/media/run-munder-difflin-on-open-models/hero.png b/blog/src/assets/media/run-munder-difflin-on-open-models/hero.png
index 01f0b5b5..84c6d9ff 100644
Binary files a/blog/src/assets/media/run-munder-difflin-on-open-models/hero.png and b/blog/src/assets/media/run-munder-difflin-on-open-models/hero.png differ
diff --git a/blog/src/assets/media/run-munder-difflin-on-open-models/note-1.png b/blog/src/assets/media/run-munder-difflin-on-open-models/note-1.png
index 2939e3ec..ed8b759f 100644
Binary files a/blog/src/assets/media/run-munder-difflin-on-open-models/note-1.png and b/blog/src/assets/media/run-munder-difflin-on-open-models/note-1.png differ
diff --git a/blog/src/assets/media/run-munder-difflin-on-open-models/note-2.png b/blog/src/assets/media/run-munder-difflin-on-open-models/note-2.png
index 2e66282e..03f6e98b 100644
Binary files a/blog/src/assets/media/run-munder-difflin-on-open-models/note-2.png and b/blog/src/assets/media/run-munder-difflin-on-open-models/note-2.png differ
diff --git a/blog/src/assets/media/your-first-hour-with-munder-difflin/hero.png b/blog/src/assets/media/your-first-hour-with-munder-difflin/hero.png
index 06b6cca8..7b821a04 100644
Binary files a/blog/src/assets/media/your-first-hour-with-munder-difflin/hero.png and b/blog/src/assets/media/your-first-hour-with-munder-difflin/hero.png differ
diff --git a/blog/src/assets/media/your-first-hour-with-munder-difflin/note-1.png b/blog/src/assets/media/your-first-hour-with-munder-difflin/note-1.png
index 1800b639..05b4bddf 100644
Binary files a/blog/src/assets/media/your-first-hour-with-munder-difflin/note-1.png and b/blog/src/assets/media/your-first-hour-with-munder-difflin/note-1.png differ
diff --git a/blog/src/assets/media/your-first-hour-with-munder-difflin/note-2.png b/blog/src/assets/media/your-first-hour-with-munder-difflin/note-2.png
index 9c648739..059a4dad 100644
Binary files a/blog/src/assets/media/your-first-hour-with-munder-difflin/note-2.png and b/blog/src/assets/media/your-first-hour-with-munder-difflin/note-2.png differ
diff --git a/blog/src/posts/deploy-a-blog-writer-agent.md b/blog/src/posts/deploy-a-blog-writer-agent.md
index 64a9db15..c48326fd 100644
--- a/blog/src/posts/deploy-a-blog-writer-agent.md
+++ b/blog/src/posts/deploy-a-blog-writer-agent.md
@@ -1,7 +1,8 @@
---
title: "Deploy a Blog-Writer Agent: The One That Wrote This Post"
-description: "How Munder Difflin's blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own."
+description: "How Munder Difflin's blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own."
date: 2026-06-10
+updated: 2026-08-20
category: use-cases
categoryLabel: Use Cases
type: Non-technical
@@ -13,22 +14,23 @@ author:
initials: CG
faq:
- q: "Did an AI actually write the Munder Difflin blog?"
- a: "Yes — most of it. A writer agent in the hive drafts each post from a topic brief and a house-style reference, the GOD orchestrator integrates it as the single committer, Eleventy builds the markdown into the static site, and a human approves the final deploy to munderdiffl.in. This very post is an example of that pipeline running. At time of writing there are 85 published posts in the blog."
+ a: "Yes — most of it. A writer agent in the hive drafts each post from a topic brief and a house-style reference, Michael integrates it as the single committer, Eleventy builds the markdown into the static site, and a human approves the final deploy to munderdiffl.in. This very post is an example of that pipeline running — and as of August 2026, the same office also draws every post's illustrations as code."
- q: "Is the blog-writer agent fully autonomous?"
a: "Almost — it's deliberately human-gated at one point: publish. The agent drafts and self-reviews against a style reference in an isolated worktree; the orchestrator integrates and builds; a person reviews the diff and approves the deploy. That keeps the volume high and hands-off without putting an unreviewed post on the live domain."
- q: "How do I build my own blog-writer agent?"
- a: "Give one agent in the hive three things: a topic or brief, a house-style reference (a few of your best existing posts), and write access to an isolated worktree. Let it draft, have a reviewer agent or the orchestrator check it, then human-approve the build and deploy. Munder Difflin gives you the worktree isolation, single-committer git, and approval queue out of the box."
+ a: "Give one agent in the hive three things: a topic or brief, a house-style reference (a few of your best existing posts), and write access to an isolated worktree. Let it draft, have a reviewer agent or the orchestrator check it, then human-approve the build and deploy. Munder Difflin gives you the worktree isolation, single-committer git, skills, and approval queue out of the box."
- q: "Why use a multi-agent hive instead of one prompt to write blog posts?"
a: "One prompt writes one post. A hive runs a content function: a writer drafts, a reviewer checks, the orchestrator integrates and builds, and a scheduled mission can fire the loop on a cadence — so you get a steady, compounding stream of on-topic posts rather than a single output you have to re-prompt for each time."
---
<div class="callout tldr"><span class="ic">TL;DR</span><p>The Munder Difflin blog is written by an
<strong>automated writer agent</strong> living in the hive. The loop: a writer agent drafts a post in an
-<strong>isolated worktree</strong> from a topic brief + a house-style reference; the
-<strong>GOD orchestrator</strong> integrates it as the single committer; <strong>Eleventy</strong> builds
+<strong>isolated worktree</strong> from a topic brief + a house-style reference; <strong>Michael</strong>
+integrates it as the single committer; <strong>Eleventy</strong> builds
<code>blog/src/posts</code> → <code>docs/blog</code>; and a human approves the deploy to
-<strong>munderdiffl.in</strong>. The outcome is a steady, on-topic stream of posts — <strong>85 and
-counting</strong> — that compounds into real SEO. <em>This post was written that way.</em></p></div>
+<strong>munderdiffl.in</strong>. The outcome is a steady, on-topic stream — <strong>well over a hundred
+posts and counting</strong>, every one now illustrated by code the same office wrote.
+<em>This post was made that way.</em></p></div>
Here's a fact that's either a confession or a flex, depending on how you read it: the blog you're reading
is mostly written by one of our own agents. Not "AI-assisted." Not "drafted then heavily rewritten." A
@@ -39,22 +41,19 @@ This very post is an instance of that system working. So let me do the most on-b
it as the worked example. Here's how the blog-writer agent is automated, why the outcome compounds, and how
to stand up your own.
-## The outcome first: so many blogs about us
+## The outcome first: a library, not a launch post
-Before the *how*, the *why it matters*. As of today there are **85 published posts** in this blog. They're
-not filler — they cluster into a real content strategy:
+Before the *how*, the *why it matters*. This blog now holds **well over a hundred published posts** —
+the topic chips at the top of [the index](/blog/) show the live counts. They're not filler — they
+cluster into a real content strategy: guides, internals deep-dives, concept explainers, comparisons,
+orchestration patterns, and a pointed story set, including [why we built
+Munder Difflin](/blog/why-we-built-munder-difflin/) and the
+[launch-week retros](/blog/what-reddit-told-us-about-munder-difflin/). The thought-leadership thread
+does the heavy SEO lifting — the [multi-agent cost playbook](/blog/the-multi-agent-cost-playbook/),
+[compressing agent memory](/blog/compressing-agent-memory/),
+[context engineering for AI agents](/blog/context-engineering-for-ai-agents/), and more.
-- **23 guides**, **15 internals** deep-dives, **13 concept** explainers, **12 comparisons**, and
- **8 orchestration** posts.
-- A small but pointed **story** set (5 posts), including [why we built
- Munder Difflin](/blog/why-we-built-munder-difflin/) and the
- [v0.2.4 launch](/blog/launching-munder-difflin-v0-2-4/).
-- A thought-leadership thread that does the heavy SEO lifting — the
- [multi-agent cost playbook](/blog/the-multi-agent-cost-playbook/),
- [compressing agent memory without losing the original](/blog/compressing-agent-memory/),
- [context engineering for AI agents](/blog/context-engineering-for-ai-agents/), and more.
-
-That's the whole point of automating the writer: **volume that stays on-topic compounds**. Eighty-five
+That's the whole point of automating the writer: **volume that stays on-topic compounds**. A hundred-plus
internally-linked, keyword-targeted posts is a discoverability moat you cannot hand-write at a startup's
spare-time pace. When someone — or an AI answer engine — searches "single-committer git multi-agent" or
"compressing agent memory," there's a post for that, and it links to five neighbors. The blog-writer agent
@@ -63,7 +62,7 @@ is how a one-person project publishes like a content team.
And crucially: it's *largely hands-off*. The expensive part of blogging isn't typing — it's the discipline
to keep shipping. An agent has no problem with discipline.
-{% img "note-1" %}
+{% img "note-1", "The content function: brief in, draft in a worktree, one committer, one build, one human gate — on a timer." %}
## The pipeline, end to end
@@ -76,16 +75,18 @@ The writer agent gets a **brief** (a topic + intent, usually straight from our S
**house-style reference**: a handful of existing posts to mirror for voice, front-matter, and structure. It
works in its **own git worktree** — a separate working directory so its in-progress draft never collides
with anyone else's files. (We wrote about why that isolation matters in
-[git worktrees vs a hive](/blog/claude-code-git-worktrees-vs-hive/).)
+[git worktrees vs a hive](/blog/claude-code-git-worktrees-vs-hive/).) Since v0.4.4 the writer can also
+carry an installed **skill** — a house-style checklist it re-reads on every draft, instead of a prompt
+we hope it remembers.
-The agent reads the reference posts, counts what already exists, picks internal links to neighbors, writes
-the front-matter (title, description, category, keywords, FAQ schema), and drafts ~1,000–1,400 words of
-body. It self-checks against the style reference before handing off. The output is a single `.md` file in
+The agent reads the reference posts, picks internal links to neighbors, writes the front-matter (title,
+description, category, keywords, FAQ schema), and drafts ~1,000–1,400 words of body. It self-checks
+against the style reference before handing off. The output is a single `.md` file in
`blog/src/posts/` — filename becomes the URL slug.
### 2. Integrate — the orchestrator is the single committer
-The writer **never commits**. It writes a plain file; the **GOD orchestrator** owns every commit. This is
+The writer **never commits**. It writes a plain file; **Michael** owns every commit. This is
the [single-committer pattern](/blog/single-committer-git-pattern/) — agents write files, one process
serializes all the git, so parallel agents never race on `.git/index.lock` and the repo stays a clean audit
log. The orchestrator picks up the finished draft, reviews routing, and commits it into the real tree.
@@ -98,6 +99,12 @@ each tag page, the sitemap, and the RSS feed — plus the SEO that's already wir
`BlogPosting` + `FAQPage` JSON-LD). No other file gets touched. That's deliberate: the agent's job is *write
one file correctly*, and the build does the rest.
+**And since August 2026, the pictures are part of the pipeline too.** Every post's hero and inline
+sketches are [drawn as code by an agent](/blog/an-agent-redesigned-this-blog/) — an SVG parts library,
+composition archetypes, and one spec file, rendered through a headless browser for exactly $0 in image
+APIs. One `media.json` manifest drives every image on the blog; a post ships with designed placeholders
+until its drawings land, so nothing is ever broken.
+
### 4. Deploy — human-gated, on purpose
This is the one stage that is **not** automated, by design. The build output under `docs/blog` is served by
@@ -109,6 +116,8 @@ The split is the lesson: **drafting and integration are autonomous; publishing i
throughput of an agent and the safety of a final human read. Nobody wants a hallucinated claim on their
front page — so that one gate stays manual while everything upstream runs hands-off.
+{% img "note-2", "One gate stays human on purpose: the deploy. Everything upstream of it runs itself." %}
+
## Build your own blog-writer agent
You don't need our exact stack. The pattern transfers to any static site or CMS. Here's the recipe.
@@ -117,9 +126,9 @@ You don't need our exact stack. The pattern transfers to any static site or CMS.
agent is always writing something discoverable, not random.
**2. Give it a house-style reference.** This is the highest-leverage input. Point the agent at three to five
-of your *best* existing posts and tell it to mirror their front-matter, voice, length, and link density. A
-writer with a strong reference produces something publishable; a writer without one produces generic AI
-slop. Your style guide is just "be like these."
+of your *best* existing posts and tell it to mirror their front-matter, voice, length, and link density —
+or install that guidance as a **skill**, so every draft re-reads it. A writer with a strong reference
+produces something publishable; a writer without one produces generic AI slop.
**3. Isolate the draft.** Let the agent write in its own worktree (or branch, or scratch directory) so an
in-flight draft can't clobber live files. In Munder Difflin this is a per-agent Git isolation toggle.
@@ -132,33 +141,20 @@ the next backlog item each time. One prompt to the orchestrator stood up [an hou
reviewer](/blog/one-prompt-automated-pr-review/) for us the same way — automation that just keeps running.
Point that same scheduling at content and the blog writes itself on a timer.
-{% img "note-2" %}
-
## The meta-point
A multi-agent hive isn't only for code. Once you have a writer that drafts, an orchestrator that integrates
and commits, a build that publishes, and one human gate, you have a **content function** — not a one-off
-prompt. The difference shows up as 85 posts instead of 1.
+prompt. The difference shows up as a library instead of a launch post.
So consider this post Exhibit A. It was briefed, drafted in a worktree against a style reference, integrated
-single-committer, Eleventy-built, and human-approved to the domain — the exact loop it describes. The system
-is, quite literally, writing about itself.
-
-## FAQ
-
-**Did an AI really write this?** Yes — drafted by a writer agent in the hive from a brief and a house-style
-reference, then human-reviewed before publish. That's the whole pipeline this post documents.
-
-**Is it fully autonomous?** Almost. Draft and integration are hands-off; **publish is human-gated** on
-purpose, so nothing reaches the live domain unread.
-
-**Does the volume actually help?** It's the point. On-topic, internally-linked posts compound into SEO and
-answer-engine reach you can't hand-write at solo pace — 85 of them and climbing.
+single-committer, Eleventy-built, illustrated by code, and human-approved to the domain — the exact loop it
+describes. The system is, quite literally, writing about itself.
---
-Munder Difflin runs a [hive of Claude Code, Codex, and Antigravity agents](https://munderdiffl.in/#how) on
-your own machine — with isolated worktrees, single-committer git, and a human-approval queue built in, so an
-agent can draft and integrate while you keep the one gate that matters.
+Munder Difflin runs a [hive of agents on ten engines](https://munderdiffl.in/#how) on
+your own machine — with isolated worktrees, single-committer git, skills, and a human-approval queue built
+in, so an agent can draft and integrate while you keep the one gate that matters.
[Download Munder Difflin](https://munderdiffl.in/#install) to put a blog-writer (or any worker) on your
floor; it's free and open source.
diff --git a/blog/src/posts/deploy-automated-pr-reviewer-agent.md b/blog/src/posts/deploy-automated-pr-reviewer-agent.md
index 5711a21f..c2e0003c 100644
--- a/blog/src/posts/deploy-automated-pr-reviewer-agent.md
+++ b/blog/src/posts/deploy-automated-pr-reviewer-agent.md
@@ -2,6 +2,7 @@
title: "Deploy a PR Reviewer That Never Sleeps — In About One Prompt"
description: "A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue."
date: 2026-06-10
+updated: 2026-08-20
category: orchestration
categoryLabel: Orchestration
type: Technical
@@ -13,9 +14,9 @@ author:
initials: CG
faq:
- q: "How do you deploy an automated PR reviewer in Munder Difflin?"
- a: "You brief the GOD orchestrator in plain English: give it a review objective, point it at the repo and its open PRs/issues, and ask it to post reviews back and escalate anything serious. The orchestrator spins up a dedicated PR Reviewer agent, runs the first pass, and sets up a recurring mission so new PRs get reviewed on a cadence. No YAML, no webhook, no per-seat SaaS subscription."
+ a: "You brief Michael, the orchestrator, in plain English: give him a review objective, point him at the repo and its open PRs/issues, and ask him to post reviews back and escalate anything serious. He spins up a dedicated PR Reviewer agent, runs the first pass, and registers a recurring mission in the Triggers tab so new PRs get reviewed on a cadence. No YAML, no webhook, no per-seat SaaS subscription."
- q: "Does the reviewer read the actual code or just the PR description?"
- a: "The actual code. The PR Reviewer agent is a real CLI agent (Claude Code, Codex, or Antigravity) with filesystem and git access to the checked-out repo, so it reviews diffs and issues against the released source — not just the summary text in the PR. That's what lets it verify a claimed bug is real before it escalates."
+ a: "The actual code. The PR Reviewer agent is a real CLI agent — any of the ten supported engines, Claude Code being the usual pick — with filesystem and git access to the checked-out repo, so it reviews diffs and issues against the released source, not just the summary text in the PR. That's what lets it verify a claimed bug is real before it escalates."
- q: "Will it spam every PR with low-value comments?"
a: "It doesn't have to. Because the reviewer reads shared hive memory and the full set of open issues at once, it can consolidate duplicate reports into one signal and only escalate findings that are verified and high-impact. In a recent run it collapsed 22 duplicate/breaker firings down to two real findings before pinging a human."
- q: "Is this a cloud service?"
@@ -30,7 +31,7 @@ We built ours differently, and we run it on ourselves. This is a how-to for depl
## What "PR Reviewer agent" actually means here
-In Munder Difflin, an agent isn't a chat window — it's a real CLI (Claude Code, Codex, or Antigravity) running on your machine with filesystem and git access, plugged into the hive's shared inbox and memory. So a "PR Reviewer" is just a worker you've given one job: watch the repo, review what comes in, and report back.
+In Munder Difflin, an agent isn't a chat window — it's a real CLI (any of the ten supported engines, from Claude Code to Codex to OpenCode) running on your machine with filesystem and git access, plugged into the hive's shared inbox and memory. So a "PR Reviewer" is just a worker you've given one job: watch the repo, review what comes in, and report back. Since v0.4.4 you can also hand it an installed **skill** — a review checklist it re-reads on every pass, so your severity bar and house rules survive across sessions.
That framing matters because of what it unlocks:
@@ -42,7 +43,7 @@ That framing matters because of what it unlocks:
## Deploying it: the one-prompt version
-You don't configure this. You brief it. Open Munder Difflin, select the GOD orchestrator, and describe the outcome the way you'd brief a coworker:
+You don't configure this. You brief it. Open Munder Difflin, select Michael, and describe the outcome the way you'd brief a coworker:
> *Stand up a PR Reviewer for our GitHub repo. Review the open PRs and any new bug-report issues against the released source — verify each claim in the actual code, post a review comment on each, consolidate duplicates into one finding, and ping me directly for anything HIGH severity. Then check for new ones every hour and do the same.*
@@ -90,7 +91,7 @@ That's the difference between an automated commenter and an automated *reviewer*
Two limits worth stating plainly, because overselling this helps no one:
- **It runs while the app is open.** The scheduler lives in the desktop app's process — this is local-first, not a cloud cron. It catches up on overdue ticks at next launch (each mission remembers when it last fired), so the cadence resumes after a restart. But if you need reviews while the laptop is shut, that's a cloud job's territory, and we'd rather tell you that than pretend otherwise.
-- **It's judgment, not an oracle.** It's a Claude/Codex/Antigravity agent reading real code, so it brings real judgment — and, like any reviewer, it can be wrong. The escalation bar exists precisely so a human sees the consequential calls. Treat its reviews like a sharp colleague's, not a CI gate that's always right.
+- **It's judgment, not an oracle.** It's a real coding agent reading real code, so it brings real judgment — and, like any reviewer, it can be wrong. The escalation bar exists precisely so a human sees the consequential calls. Treat its reviews like a sharp colleague's, not a CI gate that's always right.
Within those limits, what you get is genuinely useful: a reviewer that never sleeps, reads your actual diff and source, de-dupes the noise, and only escalates what matters.
@@ -98,9 +99,9 @@ Within those limits, what you get is genuinely useful: a reviewer that never sle
If you maintain a repo with more inbound than time, this is roughly a five-minute setup and zero ongoing babysitting:
-1. [Download Munder Difflin](https://munderdiffl.in/#install) — free, open source, local-first, macOS/Windows/Linux.
-2. Add a CLI agent (`claude`, `codex`, or `agy` — whichever subscription you already have).
-3. Brief the GOD orchestrator with the prompt above, swapping in your repo and your escalation bar.
+1. [Download Munder Difflin](https://munderdiffl.in/#install) — free, open source, local-first, macOS/Windows/Linux (and yes, [Windows is first-class as of v0.4.4](/blog/launching-munder-difflin-v0-4-4/)).
+2. Add a CLI agent on whichever engine subscription you already have — the app supports ten, and **Settings → Prerequisites** confirms which binaries it can see.
+3. Brief Michael with the prompt above, swapping in your repo and your escalation bar.
4. Leave it running on a second monitor and let new PRs get reviewed on the hour.
The pitch is simple, and it's true: **a reviewer that never sleeps, reads your real source, de-dupes the noise, and only escalates what matters — set up in about one prompt.** Go point one at your backlog.
diff --git a/blog/src/posts/how-to-install-and-use-munder-difflin.md b/blog/src/posts/how-to-install-and-use-munder-difflin.md
index 8f928bd3..8f89d768 100644
--- a/blog/src/posts/how-to-install-and-use-munder-difflin.md
+++ b/blog/src/posts/how-to-install-and-use-munder-difflin.md
@@ -1,51 +1,53 @@
---
title: "How to Install and Use Munder Difflin"
-description: "Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish."
+description: "Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish."
date: 2026-06-05
+updated: 2026-08-20
category: guides
categoryLabel: Guides
type: Technical
primaryKeyword: "how to install munder difflin"
-secondaryKeywords: ["munder difflin download", "munder difflin app", "munder difflin tutorial"]
+secondaryKeywords: ["munder difflin download", "munder difflin app", "munder difflin tutorial", "munder difflin windows"]
tags: ["Guides", "Getting Started", "Tutorial", "Claude Code", "Automation", "Video"]
author:
name: Chaitanya Giri
initials: CG
faq:
- q: "Is Munder Difflin free?"
- a: "Yes. Munder Difflin is free and open source under the MIT license. Download a build for macOS, Windows, or Linux, or run it from source — there's no paid tier."
+ a: "Yes. Munder Difflin is free and open source under the MIT license. Download a build for macOS, Windows, or Linux, or run it from source — and once installed, the app keeps itself up to date from GitHub releases, telling you what's in each update before you restart into it."
- q: "Do I need Claude Code to use Munder Difflin?"
- a: "Yes. Munder Difflin coordinates real Claude Code sessions, so you bring your own Claude Code (the `claude` CLI on your PATH). Each agent runs a real `claude` process; the harness adds memory, messaging, and the GOD orchestrator on top."
+ a: "No — you need at least one supported engine, and Claude Code is the most popular of ten: Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI. Each agent runs a real CLI process; the harness adds memory, messaging, skills, and the orchestrator on top. Mixing engines on one floor is normal."
+ - q: "Does it work properly on Windows?"
+ a: "Yes — and if you tried before v0.4.4, try again. That release fixed the bug that silently broke agent-to-agent messaging on Windows, made first runs start their own hive services, and rebuilt dark mode. Windows is a first-class platform now, OpenCode included."
- q: "Can I leave it running for hours or days?"
- a: "Yes — that's the point. With auto mode on, agents run unattended and a GOD orchestrator routes work and escalates only the critical calls to you. Give an agent a persistent Goal and it keeps working a long-horizon task across many prompts while you're away."
- - q: "What platforms does it support?"
- a: "macOS, Windows, and Linux. Grab the matching installer (.dmg, .exe, or .AppImage) from the latest release, or build from source with Node 18+ in two commands."
+ a: "Yes — that's the point. With auto mode on, agents run unattended and Michael routes work and escalates only the critical calls to you. Give an agent a persistent Goal and it keeps working a long-horizon task across many prompts while you're away."
- q: "Is auto mode safe?"
- a: "Auto mode spawns agents with `--permission-mode bypassPermissions`, so they don't pause for file edits or shell commands. It's the right default for the unattended control-room experience, but it's a foot-gun on production repos. Keep it on for sandboxed or disposable working copies; turn it off (or drop the flag per agent) when you want to babysit."
+ a: "Auto mode spawns agents without per-tool permission prompts, so they don't pause for file edits or shell commands. It's the right default for the unattended control-room experience, but it's a foot-gun on production repos. Keep it on for sandboxed or disposable working copies; turn it off (or per agent) when you want to babysit."
---
<div class="callout tldr"><span class="ic">TL;DR</span><p>Install <strong>Munder Difflin</strong> by
-downloading a build (macOS, Windows, or Linux) or running it from source with Node 18+. On first
-launch you'll pick a harness home, add your repos, and confirm auto mode. Then you talk to
-<strong>Michael</strong> — the <a href="/#how">GOD orchestrator</a> — spin up agents with a
-<strong>Goal</strong>, and let the hive work <strong>ambitious, long-horizon tasks for hours or
-days</strong> while you watch the floor.</p></div>
+downloading a build (macOS, Windows, or Linux) or running from source with Node 18+. Onboarding
+opens on the real pitch — <strong>a clone of you, working 24/7</strong> — validates your setup at
+step one, and the <strong>Prerequisites</strong> page shows live status for every tool an engine
+needs. Then you talk to <strong>Michael</strong>, spin up agents on any of <strong>ten
+engines</strong> with a <strong>Goal</strong>, hand them <strong>skills</strong>, and let the hive
+work <strong>long-horizon tasks for hours or days</strong> while you watch the floor.</p></div>
*Watch the 51-second setup walkthrough:*
<video controls preload="none" playsinline poster="/media/demo/setup-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;"><source src="/media/demo/setup.mp4" type="video/mp4" /></video>
-Most tools help you run a Claude Code agent. Munder Difflin helps you run a *team* of them —
+Most tools help you run one coding agent. Munder Difflin helps you run a *team* of them —
unattended, coordinated, and aimed at the big jobs: a multi-day refactor, a migration, an
-investigation that needs to grind overnight. This is the start-to-finish guide: install it, meet the
-orchestrator, and put the hive to work on something ambitious.
+investigation that needs to grind overnight. This is the start-to-finish guide, current as of
+**v0.4.4**: install it, meet your clone, and put the hive to work on something ambitious.
## What Munder Difflin does best
Before the steps, the mental model — because it shapes how you'll use it. Munder Difflin wraps the
-[Claude Code](https://claude.com/claude-code) terminals you already run as full agents, gives each
-**long-term memory** and a **mailbox**, and puts a **GOD orchestrator** (named Michael) in charge —
-the one agent *you* talk to. You describe intent; it routes work, lets agents message each other, and
-escalates only the critical calls to you.
+agent CLIs you already run as full agents, gives each **long-term memory** and a **mailbox**, and
+puts **Michael** in charge — a clone of you, the one agent *you* talk to. His card says **BOSS**:
+he's the boss of the agents, you're still the boss of him. You describe intent; he routes work,
+lets agents message each other, and escalates only the critical calls to you.
That design pays off most on **long-horizon work**. A single session loses steam (and context) on a
multi-hour task. A coordinated [hive that remembers](/blog/give-claude-code-long-term-memory/) can
@@ -54,14 +56,21 @@ use case is exactly what it's built for. Keep that in mind as you set it up.
## Step 1: What you'll need
-- **Node.js 18+** and npm.
-- A **C/C++ toolchain** for `node-pty`'s native addon: Xcode Command Line Tools on macOS
- (`xcode-select --install`), `build-essential` on Linux, or the Visual Studio Build Tools on Windows.
- (If you download a prebuilt app instead of building from source, you don't need the toolchain.)
-- **Claude Code** on your `PATH` — agents run the `claude` command by default. You bring your own
- Claude Code; Munder Difflin coordinates it.
-- *Optional:* the semantic memory index for instant cross-session recall. The app works without it —
- plain-markdown memory still functions and the index degrades gracefully.
+- **At least one supported agent CLI** on your `PATH`. Ten engines are first-class: **Claude Code,
+ Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI.** Bring
+ whichever subscriptions you already have — mixing engines on one floor is normal.
+- **From source only:** Node.js 18+ with npm, and a C/C++ toolchain for `node-pty`'s native addon
+ (Xcode Command Line Tools on macOS, `build-essential` on Linux, VS Build Tools on Windows).
+ Prebuilt apps need none of this.
+- *Optional:* **MemPalace**, the semantic memory index, for instant cross-session recall. The app
+ works without it — plain-markdown memory still functions.
+
+And here's the v0.4.4 upgrade to this whole step: you don't have to audit any of it by hand.
+**Settings → Prerequisites** shows live status for uv, git, Node, MemPalace and every engine —
+with real paths, the platform-correct install command for anything missing, and a button that
+asks Michael to fill the gaps for you.
+
+{% img "note-1", "The Prerequisites page does this checklist for you — live status, real paths, and Michael on standby to install what's missing." %}
## Step 2: Install it
@@ -79,10 +88,15 @@ release):
| Linux | `Munder-Difflin-<version>-linux-x86_64.AppImage` |
Open the installer, launch the app, and skip to [first launch](#step-3-first-launch-the-onboarding-wizard).
+From here the app maintains itself: updates download in the background from GitHub releases, the
+toast tells you what's actually in them, and installation only ever happens on your click.
+(**Settings → General** also answers "am I on the latest?" with a single Check-for-updates button.)
-### Option B — Build from source (two commands)
+A word to Windows users specifically: **v0.4.4 is the release that made Windows first-class.**
+Agent-to-agent messaging, first-run hive services, the setup wizard, dark mode — all fixed. If an
+earlier version burned you, [this one is owed to you](/blog/launching-munder-difflin-v0-4-4/).
-If you'd rather run the code directly (or you're on a platform you want to build yourself):
+### Option B — Build from source (two commands)
```bash
git clone https://github.com/chaitanyagiri/munder-difflin.git
@@ -96,164 +110,165 @@ to load after an Electron upgrade, re-run `npm install` to rebuild it.
## Step 3: First launch — the onboarding wizard
-The first time you open Munder Difflin, a three-step wizard sets up your control room:
-
-1. **Harness home.** Pick a folder where the harness keeps its own files — agent metadata, logs, and
- any repos you create from inside the app. Something like `~/HarnessAgents` is a fine default; it's
- created if it doesn't exist. Think of it as the town hall: agent state is pinned here so sessions
- survive a restart.
-2. **Your repos.** Add the existing project folders you want agents to work in. Each becomes a room on
- the floor, and multiple agents can share a repo. This is optional and you can add more later — but
- adding your main project now saves a step.
-3. **Auto mode.** Confirm whether agents should run unattended (covered next). The default is on.
+First launch opens on what the product actually is — **a clone of you, working 24/7** — then asks
+the few questions that matter:
-Finish the wizard and you land on the office floor. Michael — your orchestrator — boots into his
-office automatically; give him a few seconds to clock in.
+1. **Your clone's engine.** Michael runs on a pluggable engine; the card names all ten. Claude
+ Code is the natural default, and you can change it later.
+2. **Harness home.** A folder where the harness keeps its own files — agent metadata, memory,
+ mailboxes, logs. `~/HarnessAgents` is a fine default. The wizard validates this immediately:
+ an empty or impossible folder fails at step one, not after step four.
+3. **Your repos.** Add the project folders you want agents to work in. Each becomes a room on the
+ floor; multiple agents can share a repo. Optional, and you can add more later.
+4. **Auto mode.** Confirm whether agents run unattended (covered next). There's also a "share
+ anonymous usage stats" toggle — opt-out, governed by a
+ [public contract](https://github.com/chaitanyagiri/munder-difflin/blob/main/TELEMETRY.md).
-{% img "note-1" %}
+Finish the wizard and you land on the office floor. Michael boots into his office automatically —
+and everything the hive needs (message router, hook server, mission scheduler) starts with him,
+on the very first run.
-## Step 4: Meet Michael, your GOD orchestrator
+## Step 4: Meet Michael, your clone
-Michael is the **GOD agent**: he runs the floor, triages requests, assigns work, and escalates only
-the critical calls to you. He's the agent you talk to.
+Michael runs the floor: he triages requests, assigns work, and escalates only the critical calls
+to you. He's the agent you talk to.
To talk to any agent (Michael included), select them on the floor to open their panel, then use the
-**command bar** at the bottom — type a message and hit Enter (or *send*). The bar has three modes:
+**command bar** at the bottom — type a message and hit Enter. The bar has three modes:
- **free** — plain natural-language instructions (the default).
-- **/skill** — invoke a Claude Code skill or slash command.
+- **/skill** — invoke an installed skill or slash command.
- **quick** — fast canned actions.
Talking to Michael in plain language is how you steer the whole team: describe a goal, and he
-decomposes and routes it. That's the [orchestration model](/#how) in practice — you manage, he
-delegates. (New to the idea? [How to run multiple Claude Code
-agents](/blog/how-to-run-multiple-claude-code-agents/) covers why an orchestrator beats juggling tabs.)
+decomposes and routes it. You manage, he delegates. He also listens — his voice mode opens with a
+live floor snapshot and can run nearly the whole app hands-free. (New to the idea? [How to run
+multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/) covers why an
+orchestrator beats juggling tabs.)
## Step 5: Understand auto mode
-Auto mode is what makes unattended runs possible. With it on, every agent is spawned with:
+Auto mode is what makes unattended runs possible. With it on, agents are spawned with their
+engine's permission prompts bypassed — Claude Code, for instance, runs as:
```text
claude --permission-mode bypassPermissions
```
-That means Claude won't stop to ask before editing files or running shell commands — essential for a
-"set it going and walk away" workflow. It's also a loaded foot-gun on a production repo, so:
+That means the agent won't stop to ask before editing files or running shell commands — essential
+for a "set it going and walk away" workflow. It's also a loaded foot-gun on a production repo, so:
- **Keep auto mode on** for sandboxed, disposable, or branch-isolated working copies — anywhere a
- mistake is cheap to undo. This is the right default for the control-room experience.
-- **Turn it off** (or drop the flag for a single agent in the Add Agent dialog) when you want to
- babysit a sensitive repo and approve each tool call.
+ mistake is cheap to undo.
+- **Turn it off** (or drop it for a single agent in the Add Agent dialog) when you want to babysit
+ a sensitive repo and approve each tool call.
-Either way, Munder Difflin keeps a **human-in-the-loop approvals queue**: even in auto mode, the GOD
-agent escalates genuinely critical actions (spending real money, destructive operations, big scope
-changes) for your sign-off, so unattended doesn't mean unsupervised.
+Either way, Munder Difflin keeps a **human-in-the-loop approvals queue**: even in auto mode,
+Michael escalates genuinely critical actions (spending real money, destructive operations, big
+scope changes) for your sign-off, so unattended doesn't mean unsupervised.
## Step 6: Spin up your first agent
Click **Add agent** to open the spawn dialog. The fields:
- **Name** — the agent's handle (picking a character fills this in for you).
-- **Folder** — the working directory. Pick one of your registered repos with a click, or browse to
- another.
-- **Command** — defaults to `claude` (plus `--permission-mode bypassPermissions` in auto mode). Pick a
- **model** above (Sonnet, Opus, Haiku, or CLI default) — the harness restarts the agent on the new
- model if you change it later.
+- **Folder** — the working directory. Pick a registered repo with a click, or browse.
+- **Engine & model** — any of the ten engines, with a model picker per engine (Grok 4.6 landed in
+ v0.4.4). The harness restarts the agent on the new model if you change it later.
- **Description** — a short note on what this agent is for.
-- **Goal (optional)** — *a long-running directive injected on every prompt.* This is the most
- important field for long tasks (more below).
+- **Goal (optional)** — *a long-running directive injected on every prompt.* The most important
+ field for long tasks (more below).
- **Character & Color** — pick from the office cast and an accent.
-- **Git isolation (optional)** — checking 'Git isolation (own worktree)' auto-creates a dedicated git
- checkout for this agent and tears it down when you kill it. Use this whenever two agents share the
- same repo so they work on separate branches without colliding.
+- **Git isolation (optional)** — auto-creates a dedicated git worktree for this agent and tears it
+ down when you kill it. Use it whenever two agents share a repo.
-Hit **spawn**. The agent appears as an avatar at a desk, provisioned in the hive with its own memory,
-mailbox, and identity. You'll see it walk to a station and start working; envelopes fly desk-to-desk
-when agents message each other.
+Hit **spawn**. The agent appears as an avatar at a desk, provisioned in the hive with its own
+memory, mailbox, and identity. Envelopes fly desk-to-desk when agents message each other.
-## Step 7: Run an ambitious, long-horizon task
+{% img "note-2", "One dialog, one new hire: engine, model, goal, character — and a desk appears on the floor." %}
+
+## Step 7: Give your agents skills
+
+Before the big task, arm the team. **Skills** (new in v0.4.4) is a browsable catalog of hundreds
+of installable skills — search, category and publisher filters, one-click install across Claude
+Code, OpenCode and Codex, with scope precedence handled and uninstall guarded. A reviewer with a
+review checklist beats a generalist told to "review carefully"; a writer with your style guide
+beats one guessing at your voice. ([MCP and skills in a hive](/blog/mcp-and-skills-in-a-hive/)
+covers when skills beat tools.)
+
+## Step 8: Run an ambitious, long-horizon task
Here's where Munder Difflin earns its keep. To set a team working for hours or days:
1. **Give agents a persistent Goal.** The *Goal* field is injected into every prompt, so the agent
- keeps orienting toward the same long-running directive even as the conversation turns over. This is
- how a task survives across many cycles instead of drifting. Write it like a brief: *"Migrate the
- test suite from Mocha to Vitest, one directory at a time, keeping CI green after each."*
-2. **Let Michael route the rest.** Tell the GOD orchestrator the high-level objective and let him
- assign sub-tasks across agents. You describe the *what*; the hive figures out the *who* and *when*.
-3. **Scope each agent and let them coordinate.** Give each a clear role so they stay in their lane and
- hand off through mailboxes instead of colliding. Shared
- [long-term memory](/blog/give-claude-code-long-term-memory/) means what one agent learns, the next
- one inherits — knowledge compounds over a long run.
-4. **Walk away.** With auto mode on, the team keeps going unattended. Check the approvals queue when
- you're back; the GOD agent only interrupts you for the critical calls.
-
-This is the [run-an-office-of-agents-while-you-sleep](/blog/run-an-office-of-ai-agents/) workflow, and
-the practical guardrails behind it are in [Claude Code automation while you
-sleep](/blog/claude-code-automation-while-you-sleep/). Be honest with yourself about scope — bounded,
+ keeps orienting toward the same directive even as the conversation turns over. Write it like a
+ brief: *"Migrate the test suite from Mocha to Vitest, one directory at a time, keeping CI green
+ after each."*
+2. **Let Michael route the rest.** Tell him the high-level objective and let him assign sub-tasks.
+ You describe the *what*; the hive figures out the *who* and *when*.
+3. **Scope each agent and let them coordinate.** Clear roles, handoffs through mailboxes, and
+ shared [long-term memory](/blog/give-claude-code-long-term-memory/) so what one agent learns,
+ the next inherits.
+4. **Walk away.** With auto mode on, the team keeps going unattended. Check the approvals queue
+ when you're back; Michael only interrupts you for the critical calls.
+
+This is the [run-an-office-while-you-sleep](/blog/run-an-office-of-ai-agents/) workflow, and the
+practical guardrails are in [Claude Code automation while you
+sleep](/blog/claude-code-automation-while-you-sleep/). Be honest about scope — bounded,
well-specified jobs go best.
-{% img "note-2" %}
-
-## Step 8: Use Michael's Command Center
+## Step 9: Use Michael's Command Center
-Select Michael on the floor and open his panel — it's not a plain terminal. It's a control surface
-with six tabs:
+Select Michael on the floor and open his panel — a control surface, not a plain terminal:
-- **Terminal** — Michael's live session, plus a message queue so you can park tasks while he's working.
-- **Floor** — the full agent roster with per-agent model selectors, a dispatch box (send a task to one
- agent or broadcast to all), and your registered repos. The **Enrich** toggle routes your queued
- messages through Dwight — a background prep assistant who gathers context and rewrites the prompt
- before Michael sees it.
-- **Memory** — MemPalace semantic search plus full-text search across all hive files (board, tasks,
- agent memories) and a memory graph.
-- **Activity** — live event log, the shared board, and real token + cost telemetry per agent (read
- directly from your Claude Code transcript files).
-- **Tasks** — a dependency-aware kanban board. Add tasks with assignees, priorities, and `dependsOn`
- links; Michael and his team track status here.
-- **Triggers** — every way the office wakes itself, starting with recurring missions. Set a label, interval (1h / 6h / 24h / weekly), and a directive
- body; the harness dispatches it to the target agent automatically, no human needed.
+- **Terminal** — Michael's live session, plus a message queue so you can park tasks while he works.
+- **Floor** — the full agent roster with per-agent model selectors, a dispatch box, and your
+ registered repos. The **Enrich** toggle routes queued messages through a background prep
+ assistant who gathers context before Michael sees them.
+- **Memory** — MemPalace semantic search plus full-text search across all hive files, and a
+ memory graph.
+- **Activity** — live event log, the shared board, and real token + cost telemetry per agent.
+- **Tasks** — a dependency-aware kanban board Michael and his team track status on.
+- **Triggers** — every way the office wakes itself: recurring missions with a label, interval,
+ and directive body, dispatched to the target agent automatically.
-For long-running floors, the Triggers tab is the most powerful: set a '30-minute floor check' mission
-pointing at Michael with a directive like 'Are all agents making progress? Re-engage anyone idle.' —
-and the harness keeps the team moving even when you're away.
+For long-running floors, Triggers is the most powerful tab: a "30-minute floor check" mission
+pointed at Michael — *"Are all agents making progress? Re-engage anyone idle."* — keeps the team
+moving even when you're away.
## Tips for best results
-- **Scope beats ambition.** A precise Goal ("do X, in this order, with this definition of done") runs
- longer and cleaner than a vague one.
-- **Use branch-isolated working copies.** Auto mode plus a throwaway branch is cheap to discard — and
- the 'Git isolation' checkbox in Add Agent automates this: each agent gets its own worktree
- provisioned and torn down for you.
-- **Register your repos.** Pre-adding projects in onboarding (or later) makes spawning agents one
- click instead of a folder hunt.
-- **Lean on memory.** Tell agents to write durable facts to their notes; the shared semantic palace
- turns those into instant recall for the whole hive.
-- **Watch the floor early.** The visual office isn't a gimmick — seeing who's busy, idle, or blocked
- catches problems before they compound.
+- **Scope beats ambition.** A precise Goal runs longer and cleaner than a vague one.
+- **Use git isolation.** Auto mode plus per-agent worktrees means mistakes are cheap and agents
+ never collide on branches.
+- **Register your repos.** Pre-adding projects makes spawning agents one click.
+- **Lean on memory.** Tell agents to write durable facts to their notes; the shared semantic
+ palace turns those into instant recall for the whole hive.
+- **Watch the floor early.** Seeing who's busy, idle, or blocked catches problems before they
+ compound — fullscreen roster cards even show each agent's live context gauge.
## Troubleshooting
-- **`node-pty` fails to load after an update** → re-run `npm install` (the postinstall rebuilds the
- native addon against the current Electron ABI).
-- **Agents won't start / "claude: command not found"** → make sure Claude Code is installed and on the
- `PATH` of the shell that launched the app.
-- **Native build errors on `npm install`** → install your platform's C/C++ toolchain (Xcode Command
- Line Tools, `build-essential`, or VS Build Tools), then reinstall.
-- **No instant recall** → the semantic memory index is optional; without it, markdown memory still
- works, just without the fast semantic search.
+- **`node-pty` fails to load after an update** (source builds) → re-run `npm install`.
+- **Agents won't start / "command not found"** → open **Settings → Prerequisites**; it shows
+ which engine binaries the app can actually see, with install commands for the missing ones.
+- **Native build errors on `npm install`** → install your platform's C/C++ toolchain, reinstall.
+- **No instant recall** → MemPalace is optional; without it, markdown memory still works, just
+ without fast semantic search.
+- **On Windows and something's off?** Make sure you're on v0.4.4 or later — it's the release
+ that fixed agent messaging, first-run services, and the wizard on Windows.
## Where to go next
-- [How to run multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/) — the habits
- that keep a team from colliding.
-- [Run an office of AI agents while you sleep](/blog/run-an-office-of-ai-agents/) — the long-horizon
- vision, with guardrails.
-- [What is a multi-agent harness?](/blog/what-is-a-multi-agent-harness/) — the concept underneath it
- all.
+- [Your first hour with Munder Difflin](/blog/your-first-hour-with-munder-difflin/) — the
+ minute-by-minute version of everything above.
+- [How to run multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/) — the
+ habits that keep a team from colliding.
+- [Run an office of AI agents while you sleep](/blog/run-an-office-of-ai-agents/) — the
+ long-horizon vision, with guardrails.
---
-That's the whole path from zero to a working hive. [Download Munder Difflin](/#install) — it's free,
-open source, and local-first on macOS, Windows, and Linux — and put a team of agents on your next big
-task.
+That's the whole path from zero to a working hive. [Download Munder Difflin](/#install) — free,
+open source, and local-first on macOS, Windows, and Linux — and put a team of agents on your next
+big task.
diff --git a/blog/src/posts/run-munder-difflin-on-open-models.md b/blog/src/posts/run-munder-difflin-on-open-models.md
index 20ff0048..8aa323ad 100644
--- a/blog/src/posts/run-munder-difflin-on-open-models.md
+++ b/blog/src/posts/run-munder-difflin-on-open-models.md
@@ -1,32 +1,33 @@
---
title: "Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider"
-description: "Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines."
+description: "Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker's own CLI. Here's the wiring, current as of v0.4.4."
date: 2026-06-22
+updated: 2026-08-20
category: guides
categoryLabel: Guides
type: Technical
primaryKeyword: "run ai agents on open source models"
-secondaryKeywords: ["local llm coding agent", "ollama coding agent", "openrouter coding agent", "gpt-oss", "byok open models", "opencode crush pi"]
+secondaryKeywords: ["local llm coding agent", "ollama coding agent", "openrouter coding agent", "gpt-oss", "byok open models", "opencode crush pi", "qwen cli agent"]
tags: ["Guides", "Local-First", "Open Source", "CLI Agents", "Tutorial"]
author:
name: Chaitanya Giri
initials: CG
faq:
- q: "Can Munder Difflin run entirely on open-source models?"
- a: "Yes. As of v0.3.1 the OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models. You can run every agent — workers and the god orchestrator — on open-weight models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi, either fully local on your own hardware or through a third-party OSS provider with your own API key."
+ a: "Yes. The OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models, and the Qwen and Kimi CLIs are first-class engines whose flagship models are open-weight. You can run every agent — workers and Michael himself — on open models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi: fully local on your own hardware, or through a third-party OSS provider with your own API key."
- q: "What's the difference between running local and using a third-party provider?"
a: "Local (Ollama, LM Studio, vLLM) runs the weights on your own machine — fully private, no per-token bill, but bounded by your RAM and GPU. A third-party OSS provider (OpenRouter, Groq, Together, Fireworks, DeepInfra) hosts the same open weights on their hardware and you pay per token with your own key — no local hardware limit, so you can reach the 100B–1T-parameter frontier models a laptop can't hold."
- - q: "Which open model should I pick for the god orchestrator?"
- a: "The god seat does the reasoning and long-context coordination, so give it a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration."
+ - q: "Which open model should I pick for the orchestrator seat?"
+ a: "Michael does the reasoning and long-context coordination, so give him a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration."
- q: "Do I need a different model id for each engine?"
- a: "No — the upstream model id is the same. All three engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/<id> while Crush and pi use ollama/<id>."
+ a: "No — the upstream model id is the same. All three BYOK engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/<id> while Crush uses ollama/<id>."
---
-<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin v0.3.1 runs entirely on open models.</strong> The three new engines — <strong>OpenCode</strong>, <strong>Crush</strong>, and <strong>pi</strong> — all support bring-your-own-key and local LLMs, for workers <em>and</em> the god orchestrator. Two routes: <strong>fully local</strong> (Ollama / LM Studio / vLLM on your own machine — private, no per-token bill, bounded by RAM) or a <strong>third-party OSS provider</strong> (OpenRouter, Groq, Together, Fireworks, DeepInfra — their hardware, your key, reaching frontier 100B–1T models a laptop can't hold). Every engine uses a <code>provider/model</code> slug; you set keys and local base-URLs in <strong>Settings → AI Engines</strong>, then pick the model in the Add-Agent modal.</p></div>
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin runs entirely on open models.</strong> Three routes: <strong>fully local</strong> (Ollama / LM Studio / vLLM on your own machine — private, no per-token bill, bounded by RAM), a <strong>third-party OSS provider</strong> (OpenRouter, Groq, Together, Fireworks, DeepInfra — their hardware, your key, reaching frontier 100B–1T models a laptop can't hold), or the <strong>model-maker's own CLI</strong> — the Qwen and Kimi engines are first-class hires whose flagship models are open-weight. The BYOK engines (<strong>OpenCode</strong>, <strong>Crush</strong>, <strong>pi</strong>) all use a <code>provider/model</code> slug; keys and local base-URLs live in <strong>Settings → AI Engines</strong>, and <strong>Settings → Prerequisites</strong> tells you which engine binaries the app can actually see.</p></div>
-Munder Difflin started as a harness for the closed frontier CLIs — Claude Code, Codex, Antigravity. Useful, but it tied your agent floor to a handful of vendors and their pricing. **v0.3.1 breaks that open.** It adds three engines that were built, from the start, to point at *any* model: [OpenCode](https://opencode.ai), [Crush](https://charm.land), and [pi](https://pi.dev). All three speak the open-weight ecosystem — and that means you can run an entire office of agents on models whose weights are public.
+Munder Difflin started as a harness for the closed frontier CLIs — Claude Code, Codex, Antigravity. Useful, but it tied your agent floor to a handful of vendors and their pricing. That's long since broken open: of the **ten engines** the app now ships — Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI — three ([OpenCode](https://opencode.ai), [Crush](https://charm.land), [pi](https://pi.dev)) were built from the start to point at *any* model, and two more (Qwen, Kimi) are the model-makers' own CLIs for families whose weights are public.
-There are two honest ways to do that, and they trade off differently. This guide walks both, then shows the exact wiring for each engine. (For the why-bother, see [why local-first matters for AI agents](/blog/why-local-first-matters-for-ai-agents/) and [why CLI agents are so powerful](/blog/why-cli-agents-are-powerful/).)
+That means you can run an entire office of agents on models anyone can download. There are two honest ways to do it, and they trade off differently. This guide walks both, then shows the exact wiring for each engine — current as of **v0.4.4**. (For the why-bother, see [why local-first matters for AI agents](/blog/why-local-first-matters-for-ai-agents/) and [why CLI agents are so powerful](/blog/why-cli-agents-are-powerful/).)
## Two routes: your hardware, or someone else's
@@ -41,26 +42,28 @@ There are two honest ways to do that, and they trade off differently. This guide
| **Setup** | Pull a model + point the engine at `localhost`. | Paste one API key. |
| **Best for** | Private work, 24/7 unattended, fixed cost. | Frontier quality, zero local hardware, bursty use. |
-You don't have to choose globally — Munder Difflin sets the engine and model *per agent*. A common pattern: a strong provider-hosted model in the god seat for orchestration, and cheap local workers for the routine majority. That's exactly the [capability-routing](/blog/do-more-with-less-model-routing/) idea, now with open weights on both ends.
+You don't have to choose globally — Munder Difflin sets the engine and model *per agent*. A common pattern: a strong provider-hosted model in the orchestrator seat, and cheap local workers for the routine majority. That's exactly the [capability-routing](/blog/do-more-with-less-model-routing/) idea, now with open weights on both ends.
-## How the three engines name a model
+And route three, for the least wiring of all: **hire the model-maker's own CLI.** The Qwen and Kimi engines are first-class in the Add-Agent dialog — their vendor CLIs, their auth, no slug to compose — and Qwen3 and Kimi K2.6 are open-weight families. If all you want is "an open-model worker on my floor, now," that's one dropdown.
-One thing to internalize before any wiring: **all three engines use the same `provider/model` slug form.** The *model* part is just the upstream's id (e.g. `openai/gpt-oss-120b`, `qwen3:30b-a3b`). The *provider* prefix resolves one of two ways:
+## How the three BYOK engines name a model
-- **A built-in provider** the engine already knows — supply the matching API-key env var and you're done. OpenCode (via the AI-SDK / models.dev registry), Crush, and pi each ship a list of recognized providers: `openrouter`, `openai`, `anthropic`, `groq`, `deepseek`, `mistral`, and the local ones.
+One thing to internalize before any wiring: **OpenCode, Crush, and pi all use the same `provider/model` slug form.** The *model* part is just the upstream's id (e.g. `openai/gpt-oss-120b`, `qwen3:30b-a3b`). The *provider* prefix resolves one of two ways:
+
+- **A built-in provider** the engine already knows — supply the matching API-key env var and you're done: `openrouter`, `openai`, `anthropic`, `groq`, `deepseek`, `mistral`, and the local ones.
- **A custom OpenAI-compatible provider** you define once (a `base_url` + key block) for any host that isn't built in — Together, Fireworks, DeepInfra, Novita, Z.ai, Moonshot. Then the slug is `<your-name>/<model-id>`.
The *local* route differs slightly by engine — same id, different prefix and wiring:
-| Engine | How v0.3.1 wires local | Local slug |
+| Engine | How the app wires local | Local slug |
|---|---|---|
| **OpenCode** | Injects a custom provider named `local` (OpenAI-compatible) with your base-URL. | `local/<id>` |
| **Crush** | Writes a provider block (`type: ollama / lmstudio / openai-compat`) into the agent's config. | `ollama/<id>` |
-| **pi** | Not wired in v0.3.1 — the local base-URL field is **reserved** (file-based `models.json` is a fast-follow). Run open models on pi via a third-party provider key for now (see Path B). | — |
+| **pi** | Still **reserved** as of v0.4.4 — the harness doesn't yet write pi a `models.json`. Run open models on pi via a provider key (Path B). | — |
Default endpoints are the usual ones: Ollama `http://localhost:11434/v1`, LM Studio `http://127.0.0.1:1234/v1`, vLLM whatever you exposed (often `:8000/v1`). You set these in the app — no shell exports required.
-{% img "note-1" %}
+{% img "note-1", "Same model id everywhere — only the prefix changes: local/ on OpenCode, ollama/ on Crush, provider/ for BYOK." %}
## Path A — fully local (Ollama / LM Studio / vLLM)
@@ -77,7 +80,7 @@ ollama serve # exposes the OpenAI-compatible API on :11434
(LM Studio works the same way — load the model in the app and it serves on `:1234`. vLLM and llama.cpp expose their own OpenAI-compatible endpoint.)
-**2. Point the engine at it.** Open **Settings → AI Engines**, find the engine you'll use (**OpenCode** or **Crush**), and set its **local base-URL** field to your endpoint — e.g. `http://localhost:11434/v1` for Ollama. This is the per-CLI local field v0.3.1 added; the harness uses it to inject the right provider config when it spawns the agent. No API key needed for local. (pi's local base-URL field is **reserved** in v0.3.1 — the harness doesn't yet write it a `models.json` — so to run open models on pi today, use a third-party provider key via Path B below.)
+**2. Point the engine at it.** Open **Settings → AI Engines**, find the engine you'll use (**OpenCode** or **Crush**), and set its **local base-URL** field to your endpoint — e.g. `http://localhost:11434/v1` for Ollama. The harness uses it to inject the right provider config when it spawns the agent. No API key needed for local.
**3. Hire an agent on that model.** In the **Add-Agent** modal, choose the engine, then pick the local model. The picker offers the open-model quick-picks; the slug it sends is `local/gpt-oss:20b` on OpenCode, or `ollama/gpt-oss:20b` on Crush (keep the colon in the tag). That agent now runs fully on your hardware.
@@ -94,13 +97,13 @@ Which local model? Match it to your machine. These picks are from the project's
| Llama 3.3 70B | `llama3.3:70b` | 64 GB | Bigger generalist |
| gpt-oss 120B | `gpt-oss:120b` | 96 GB | Top local (Studio-class) |
-A note on what *won't* fit: the headline frontier open models — DeepSeek-V4 (1.6T / 284B), Kimi K2.6 (~1T), GLM-5.2 (744B), Qwen3-235B — are server-class. The Ollama tags exist, but no consumer Mac holds them. For those, you want Path B. (Choosing a local model by RAM is the whole subject of the companion [Mac Mini setup guide](/blog/run-munder-difflin-on-a-mac-mini/).)
+A note on what *won't* fit: the headline frontier open models — DeepSeek-V4, Kimi K2.6, GLM-5.2, Qwen3-235B — are server-class. The Ollama tags exist, but no consumer Mac holds them. For those, you want Path B. (Choosing a local model by RAM is the whole subject of the companion [Mac Mini setup guide](/blog/run-munder-difflin-on-a-mac-mini/).)
## Path B — a third-party OSS provider (BYOK)
Same open weights, hosted on someone else's GPUs, billed to your own key. This is how you reach the big models, and it's a two-field setup.
-**1. Get a key.** Sign up with a provider and copy an API key. [OpenRouter](https://openrouter.ai) is the easiest start — one key, the widest catalog (it fronts most of the others). [Groq](https://groq.com) is the fastest for the models it carries. Together, Fireworks, and DeepInfra host the heavyweights.
+**1. Get a key.** Sign up with a provider and copy an API key. [OpenRouter](https://openrouter.ai) is the easiest start — one key, the widest catalog. [Groq](https://groq.com) is the fastest for the models it carries. Together, Fireworks, and DeepInfra host the heavyweights.
**2. Paste it into the app.** In **Settings → AI Engines**, enter the key in the matching field. Keys are stored **write-only through the broker** — the renderer can set a key but never read it back; only the main process injects it as the right env var (`OPENROUTER_API_KEY`, `GROQ_API_KEY`, …) when an agent spawns, and only for the provider that agent actually uses. Nothing lands in plaintext config.
@@ -116,9 +119,11 @@ Same open weights, hosted on someone else's GPUs, billed to your own key. This i
| Qwen3-Coder 480B | OpenRouter | `openrouter/qwen/qwen3-coder` | `OPENROUTER_API_KEY` |
| gpt-oss 120B | OpenRouter | `openrouter/openai/gpt-oss-120b` | `OPENROUTER_API_KEY` |
-Prefer a model maker's own API? Those work too: DeepSeek (`deepseek/deepseek-v4-flash`, `DEEPSEEK_API_KEY`), Mistral (`mistral/...`, `MISTRAL_API_KEY`), Z.ai for GLM, Moonshot for Kimi. A couple of moving targets worth knowing as of mid-2026: DeepSeek's `deepseek-chat` / `deepseek-reasoner` aliases retire on 2026-07-24 (wire `deepseek-v4-flash` directly), and Groq is sunsetting Llama 4 — so on Groq stick to gpt-oss and `llama-3.3-70b-versatile`. The full slug-by-slug table, with citations and verify-live caveats, lives in the project's open-model catalog (the single source of truth this post and the Mac Mini guide both cite).
+Prefer a model maker's own API? Those work too: DeepSeek (`deepseek/deepseek-v4-flash`, `DEEPSEEK_API_KEY`), Mistral (`mistral/...`, `MISTRAL_API_KEY`), Z.ai for GLM, Moonshot for Kimi. On Groq, stick to gpt-oss and `llama-3.3-70b-versatile`. The full slug-by-slug table, with citations, lives in the project's open-model catalog (the single source of truth this post and the Mac Mini guide both cite).
+
+One honest fix from v0.4.4 worth knowing: OpenCode used to preselect a BYOK slug **and silently fall back** to a different model when the key was absent — while every surface kept reporting the model it had asked for. That's gone. If a key is missing now, you find out; you never unknowingly run a model you didn't pick.
-{% img "note-2" %}
+{% img "note-2", "One key, the whole frontier: paste it once in Settings, and the write-only broker injects it per spawn — never into plaintext config." %}
## Per-engine cheat-sheet
@@ -134,12 +139,14 @@ You rarely touch these directly — the AI Engines panel writes them — but her
then select `ollama/qwen3:30b-a3b`. For a host like Together, it's an `openai-compat` block with that provider's `base_url` and your key.
-**pi** (the Pi Coding Agent) ships 15+ built-in providers, so BYOK is just the provider key. Slugs look like `groq/llama-3.3-70b-versatile` or `openrouter/qwen/qwen3-coder`. Its local base-URL field is **reserved** in v0.3.1 — Munder Difflin doesn't yet write pi a `models.json` — so for now run open models on pi through a third-party provider key rather than a local endpoint; local-via-base-URL is a fast-follow.
+**pi** ships 15+ built-in providers, so BYOK is just the provider key. Slugs look like `groq/llama-3.3-70b-versatile` or `openrouter/qwen/qwen3-coder`. Its local base-URL field remains **reserved** as of v0.4.4 — run open models on pi through a provider key rather than a local endpoint.
+
+**Qwen and Kimi** are the zero-wiring route: vendor CLIs as first-class engines. Sign in the way each CLI wants and hire away — no slugs, no base-URLs.
-All three are god-eligible in v0.3.1, so you can put an open model in the orchestrator seat, not just the workers. For the god seat, give it a strong one — `gpt-oss:120b` or `llama3.3:70b` locally (64–96 GB), or a frontier provider model like `openrouter/deepseek/deepseek-v4-flash`. Sub-8B models are great workers but thin for orchestration.
+All the BYOK engines are orchestrator-eligible, so you can put an open model in Michael's seat, not just the workers'. Give the seat a strong one — `gpt-oss:120b` or `llama3.3:70b` locally (64–96 GB), or a frontier provider model like `openrouter/deepseek/deepseek-v4-flash`. Sub-8B models are great workers but thin for orchestration.
## The bottom line
-Open weights turn Munder Difflin from "a harness for three vendors' CLIs" into "a harness for the whole open ecosystem." Run it **fully local** when privacy and fixed cost matter and your RAM can hold the model; run it on a **third-party provider** when you want frontier quality or no local hardware at all — and mix the two across your floor, agent by agent. The setup is two fields in **Settings → AI Engines** and a pick in Add-Agent; the open-model slugs are curated in the project catalog so you don't have to guess.
+Open weights turn Munder Difflin from "a harness for three vendors' CLIs" into "a harness for the whole open ecosystem." Run it **fully local** when privacy and fixed cost matter and your RAM can hold the model; run it on a **third-party provider** when you want frontier quality or no local hardware at all; hire the **vendor CLI** when you want zero wiring — and mix all three across your floor, agent by agent. The setup is two fields in **Settings → AI Engines** and a pick in Add-Agent, with **Settings → Prerequisites** confirming every engine binary the app can see.
-That's the promise kept: a virtual office of CLI agents on your own computer, now running on models whose weights anyone can read. [Download Munder Difflin](https://munderdiffl.in/#install) — it's free, open source, and local-first. Then point your favorite open model at it. (On a Mac and want the hardware-by-RAM walkthrough? Read the [Mac Mini setup guide](/blog/run-munder-difflin-on-a-mac-mini/).)
+That's the promise kept: a virtual office of CLI agents on your own computer, running on models whose weights anyone can read. [Download Munder Difflin](https://munderdiffl.in/#install) — free, open source, local-first — and point your favorite open model at it. (On a Mac and want the hardware-by-RAM walkthrough? Read the [Mac Mini setup guide](/blog/run-munder-difflin-on-a-mac-mini/).)
diff --git a/blog/src/posts/your-first-hour-with-munder-difflin.md b/blog/src/posts/your-first-hour-with-munder-difflin.md
index 1c2d7786..6c2f5376 100644
--- a/blog/src/posts/your-first-hour-with-munder-difflin.md
+++ b/blog/src/posts/your-first-hour-with-munder-difflin.md
@@ -1,65 +1,66 @@
---
title: "Your First Hour With Munder Difflin"
-description: "A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running."
+description: "A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running."
date: 2026-07-03
+updated: 2026-08-20
category: guides
categoryLabel: Guides
type: Non-technical
primaryKeyword: "munder difflin onboarding"
-secondaryKeywords: ["getting started with munder difflin", "multi-agent harness tutorial", "first hour with a multi-agent harness", "god orchestrator first brief", "ai agent approval queue", "scheduled agent missions"]
+secondaryKeywords: ["getting started with munder difflin", "multi-agent harness tutorial", "first hour with a multi-agent harness", "ai agent approval queue", "scheduled agent missions", "munder difflin skills"]
tags: ["Guides", "Onboarding", "Getting Started", "Multi-Agent", "Local-First"]
author:
name: Chaitanya Giri
initials: CG
faq:
- q: "How long does it take to get Munder Difflin running?"
- a: "About five minutes if you already have Node.js 18+ and one supported agent CLI installed. You clone the repo, run npm install and npm run dev, and the onboarding wizard walks you through the rest: harness home, registered repos, default command, and auto-mode. Signed macOS, Windows, and Linux builds are also available on the releases page."
+ a: "About five minutes. Grab the signed build for macOS, Windows, or Linux from the releases page, or run from source with Node.js 18+. Onboarding validates your setup at the very first step — as of v0.4.4 it checks your home folder immediately instead of failing four steps later, and the Prerequisites page in Settings shows live status for every tool an engine needs, with a button that asks Michael to install what's missing."
- q: "What do I need before installing Munder Difflin?"
- a: "Node.js 18+ with npm, a C/C++ toolchain for node-pty's native addon (Xcode Command Line Tools on macOS), and at least one supported terminal-agent CLI on your PATH — Claude Code, Antigravity, OpenAI Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. If a chosen engine's binary is missing, the harness runs its installer in the terminal and restarts into it automatically."
+ a: "At least one supported agent CLI — Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, or GitHub Copilot CLI. If you're missing one (or git, Node, uv, MemPalace), Settings → Prerequisites shows exactly what's absent with the platform-correct install command, and can hand the whole job to Michael."
- q: "Who is Michael and how do I give him work?"
- a: "Michael is the GOD orchestrator — the one agent you talk to. You type a brief into his terminal (or use the Talk voice channel with your own OpenAI Realtime key) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in Michael's office automatically on first launch."
+ a: "Michael is a clone of you — the boss of the agents, while you stay the boss of him. You type a brief into his terminal (or talk to him by voice) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in his office automatically on first launch."
- q: "Do I have to approve everything the agents do?"
- a: "No. The GOD orchestrator resolves routine requests itself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest."
+ a: "No. Michael resolves routine requests himself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest."
- q: "How do I review what an agent actually changed?"
- a: "Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD — the VS Code editor engine, fully self-hosted, with all filesystem and git access brokered through the main process. There's also a per-agent git tab with status, log, and commit graph."
+ a: "Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD. There's a per-agent git tab with status, log, and commit graph — and since v0.4.4 the IDE previews images too, so a design change is as reviewable as a code change."
- q: "Can Munder Difflin keep working after I walk away?"
- a: "Yes — that's the point. The Triggers tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs 24/7 on hardware you already own."
+ a: "Yes — that's the point. The Triggers tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs on hardware you already own — and the app keeps itself current, telling you exactly what's in each update before you restart into it."
---
-<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>You can go from zero to a running AI office in one hour.</strong> Minute 0: install. Minute 5: the <strong>onboarding wizard</strong> (harness home, repos, auto-mode, orchestrator engine). Minute 10: your <strong>first brief to Michael</strong>, the GOD orchestrator. Minute 20: watch avatars work the floor and open a real desk terminal. Minute 40: your <strong>first approval</strong> and a side-by-side diff in the built-in <strong>Monaco IDE</strong>. Minute 60: set a <strong>schedule</strong> and walk away — the office keeps working.</p></div>
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>You can go from zero to a running AI office in one hour.</strong> Minute 0: install. Minute 5: onboarding — it opens on the honest pitch, <strong>a clone of you, working 24/7</strong>, and validates your setup at step one. Minute 10: your <strong>first brief to Michael</strong>. Minute 20: watch avatars work the floor and open a real desk terminal. Minute 40: your <strong>first approval</strong> and a side-by-side diff in the built-in <strong>Monaco IDE</strong>. Minute 60: set a <strong>schedule</strong> and walk away — the office keeps working.</p></div>
<video controls preload="none" playsinline poster="/media/demo/intro-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">
<source src="/media/demo/intro.mp4" type="video/mp4" />
</video>
-Most tools ask you to learn them before they do anything. Munder Difflin is the other kind: within an hour you've briefed an orchestrator, watched agents work, approved a real change, and left the office running without you. Here's that hour, minute by minute.
+Most tools ask you to learn them before they do anything. Munder Difflin is the other kind: within an hour you've briefed an orchestrator, watched agents work, approved a real change, and left the office running without you. Here's that hour, minute by minute — current as of v0.4.4.
{% youtube "", "Your first hour with Munder Difflin — full walkthrough" %}
## Minute 0 — Install
-Two paths: grab a signed build (macOS, Windows, Linux) from the [releases page](https://github.com/chaitanyagiri/munder-difflin/releases/latest), or clone and run from source with `npm install && npm run dev`. You need Node.js 18+, a C/C++ toolchain for `node-pty`, and at least one supported agent CLI on your `PATH` — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI.
+Two paths: grab a signed build (macOS, Windows, Linux) from the [releases page](https://github.com/chaitanyagiri/munder-difflin/releases/latest), or clone and run from source with `npm install && npm run dev`. You'll want at least one supported agent CLI on your `PATH` — the engine card now honestly names all ten: Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI.
-I won't repeat the details here; the [install and usage guide](/blog/how-to-install-and-use-munder-difflin/) covers prerequisites, troubleshooting, and the `node-pty` rebuild gotcha. Budget five minutes.
+Missing something? You no longer have to find out the hard way. **Settings → Prerequisites** shows live status for git, Node, uv, MemPalace and every engine — real paths, platform-correct install commands, and a button that simply asks Michael to fill the gaps for you. The [install and usage guide](/blog/how-to-install-and-use-munder-difflin/) covers the deeper details. Budget five minutes.
-## Minute 5 — The onboarding wizard
+{% img "note-1", "Prerequisites, before they become surprises: live status for every tool, and a button that hands the gaps to Michael." %}
-First launch drops you into a short wizard, and the four choices it asks for are the actual shape of the product:
+## Minute 5 — Onboarding: meet your clone
-- **Harness home** — the folder where the hive lives: per-agent memory, mailboxes, the blackboard, the event log. Plain files in a local git repo, relocatable later.
-- **Registered repos** — the codebases your agents will work on. This is what feeds GitHub issue ingestion and the CI watcher later.
-- **Default command / auto-mode** — which agent CLI new hires run by default, and whether the floor runs in auto-mode (agents proceed without per-tool prompts; the approval gate still catches critical items).
-- **Orchestrator engine** — Michael himself runs on a pluggable engine. Claude Code is the natural default, but the wizard lets you pick, and you can change it later.
+First launch opens on the pitch the whole product keeps: **a clone of you, working 24/7.** The wizard's few questions are the actual shape of the product:
-Finish the wizard and you land on the floor: a pixel-art office, empty except for Michael, who seats himself in his office automatically.
+- **Your clone's engine** — Michael runs on a pluggable engine; pick from the ten, change it later.
+- **Harness home** — the folder where the hive lives: per-agent memory, mailboxes, the blackboard, the event log. Plain files in a local git repo. The wizard validates this at step one — an empty or impossible folder fails immediately, not after step four.
+- **Registered repos** — the codebases your agents will work on.
+- **Auto-mode** — whether agents proceed without per-tool prompts (the approval gate still catches critical items).
-{% img "note-1" %}
+Finish the wizard and you land on the floor: a pixel-art office, empty except for Michael, who seats himself in his office automatically — with a **BOSS** tag on his card, because he's the boss of the agents while you stay the boss of him. Everything the hive needs starts with him: as of v0.4.4 a brand-new install boots its message router, hook server and mission scheduler on the very first run.
## Minute 10 — Your first brief to Michael
-You don't manage the workers. You talk to one agent — the GOD orchestrator — and he runs the floor. Click into Michael's terminal and type a brief the way you'd brief a colleague: what you want, which repo, what "done" looks like.
+You don't manage the workers. You talk to your clone, and he runs the floor. Click into Michael's terminal and type a brief the way you'd brief a colleague: what you want, which repo, what "done" looks like. Prefer talking? His voice mode opens with a live snapshot of the floor and can run nearly the whole app.
-Michael adjudicates. He creates tasks on the kanban, assigns them, and routes messages between agent inboxes. Workers you hire via **Add agent** each get a real CLI process in its own pseudo-terminal and, with the git-isolation toggle, their own worktree — so nobody collides on branches. How he decides what to route, resolve, or escalate is its own post: [how the GOD orchestrator works](/blog/how-the-god-orchestrator-works/).
+Michael adjudicates. He creates tasks on the kanban, assigns them, and routes messages between agent inboxes. Workers you hire via **Add agent** each get a real CLI process in its own pseudo-terminal and, with the git-isolation toggle, their own worktree — so nobody collides on branches. How he decides what to route, resolve, or escalate is its own post: [how the orchestrator works](/blog/how-the-god-orchestrator-works/).
A good first brief is small and self-contained: "read this repo and write a REPORT.md summarizing the architecture" beats "refactor everything" for hour one.
@@ -69,24 +70,28 @@ Now the part that makes the product legible: the floor is not a decoration, it's
{% img "floor-view", "The floor mid-task: every movement maps to a real event." %}
-Click any agent and you get their desk: the live terminal (you can type back into it), a sandboxed file browser, and a git tab with status, log, and commit graph. This is the moment the abstraction clicks — that avatar is a real `claude` process, and you're reading its actual stdout.
+Click any agent and you get their desk: the live terminal (you can type back into it), a sandboxed file browser, and a git tab with status, log, and commit graph. Go fullscreen and the roster cards show each agent's model, project, and a live context gauge — the fuel dial for every worker at a glance. This is the moment the abstraction clicks: that avatar is a real CLI process, and you're reading its actual stdout.
-{% img "note-2" %}
+{% img "note-2", "Every desk is real: a live terminal, a file browser, a git tab — and a context gauge telling you how much runway the agent has left." %}
## Minute 40 — Your first approval, and the diff
Sometime in the first hour, something lands in the approvals queue — a spend threshold, a destructive operation, a scope change. This is by design: Michael resolves routine requests himself and escalates only critical items, so the queue stays short and every item in it deserves your attention. (The philosophy behind that gate: [approving AI agents without babysitting them](/blog/human-in-the-loop-approving-ai-agents/).)
-Before you click approve, look at the work. Hit the title-bar **IDE** button and the built-in Monaco editor — the VS Code editor engine, fully self-hosted — opens over the floor. The git CHANGES rail lists what changed; click a file for a read-only side-by-side diff against HEAD. Read the diff, approve the item, watch the envelope fly.
+Before you click approve, look at the work. Hit the title-bar **IDE** button and the built-in Monaco editor — the VS Code editor engine, fully self-hosted — opens over the floor. The git CHANGES rail lists what changed; click a file for a read-only side-by-side diff against HEAD. Images preview right in the IDE now, so a screenshot or SVG an agent produced is one click to inspect. Read the diff, approve the item, watch the envelope fly.
+
+## Minute 50 — Give an agent a skill
+
+New in v0.4.4 and worth five minutes of your first hour: **Skills.** A browsable catalog of hundreds of skills — search, category and publisher filters — installable across Claude Code, OpenCode and Codex with scope precedence handled for you. Give your reviewer a review checklist, your writer a style guide, your researcher a source-citing discipline. It's the difference between hiring generalists and hiring people who've read the manual. (Background: [MCP and skills in a hive](/blog/mcp-and-skills-in-a-hive/).)
## Minute 60 — Leave it running
The last move of the hour is the one that changes your relationship with the tool: schedule something. The Command Center's **Triggers** tab takes a label, an interval, a target agent, and a mission body — "every morning, triage new GitHub issues," say — and a heartbeat re-engages the floor if it goes quiet. Last-fired and next-fired times are right there in the tab.
-Close the laptop. It's local-first, so tomorrow the office is exactly where you left it — probably with mail in your queue. For patterns on what's worth automating, see [scheduling autonomous agent missions](/blog/scheduling-autonomous-agent-missions/).
+Close the laptop. It's local-first, so tomorrow the office is exactly where you left it — probably with mail in your queue. And when the next release ships, the app tells you itself: the update toast says what's actually inside before you restart into it. For patterns on what's worth automating, see [scheduling autonomous agent missions](/blog/scheduling-autonomous-agent-missions/).
## The hour, in one line
-Install, answer four wizard questions, brief one agent, watch the floor, read one diff, set one schedule — and you've gone from "a CLI in a terminal" to "an office that works while you don't."
+Install, meet your clone, brief him once, watch the floor, read one diff, install one skill, set one schedule — and you've gone from "a CLI in a terminal" to "an office that works while you don't."
[Download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — free, MIT-licensed, local-first — and if the first hour earns it, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.
diff --git a/blog/src/topic.njk b/blog/src/topic.njk
index 16b4cb6c..0a10ed67 100644
--- a/blog/src/topic.njk
+++ b/blog/src/topic.njk
@@ -7,7 +7,7 @@ pagination:
permalink: "/topics/{{ cat.slug }}/index.html"
eleventyComputed:
title: "{{ cat.name }}"
- description: "Munder Difflin blog posts on {{ cat.name }} — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory."
+ description: "Munder Difflin blog posts on {{ cat.name }} — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor."
seoTitle: "{{ cat.name }} — Munder Difflin Blog"
canonicalUrl: "{{ site.origin }}/blog/topics/{{ cat.slug }}/"
---
@@ -19,7 +19,17 @@ eleventyComputed:
</nav>
<p class="eyebrow">Topic</p>
<h1>{{ cat.name }}</h1>
- <p class="lead">{{ cat.posts.length }} post{{ "s" if cat.posts.length != 1 }} in this cluster.</p>
+ {%- set blurbs = {
+ "guides": "Step-by-step walkthroughs you can follow today — install the app, meet your clone, hire agents on any of ten engines, and leave real work running overnight.",
+ "use-cases": "Real workflows the hive actually runs — writing this blog, reviewing PRs, mining launch feedback, shipping releases — each one a recipe you can point at your own work.",
+ "internals": "How the machine actually works: postmortems, architecture decisions, and the bugs we document instead of burying.",
+ "concepts": "The ideas underneath the product — harnesses, hives, memory, orchestration — explained without the hand-waving.",
+ "comparisons": "Honest side-by-sides with the other ways to run many coding agents, trade-offs included.",
+ "orchestration": "Patterns for making one boss agent run a floor of workers without you in the middle.",
+ "memory": "How agents remember across sessions — and how a whole team shares what any one of them learned.",
+ "story": "Launches, releases, and the occasional confession — the running diary of building this thing in the open."
+ } -%}
+ <p class="lead">{{ blurbs[cat.slug] or (cat.posts.length ~ " post" ~ ("s" if cat.posts.length != 1) ~ " in this cluster.") }}</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="{{ '/' | u }}">All</a>
diff --git a/docs/blog/assets/media/deploy-a-blog-writer-agent/hero.png b/docs/blog/assets/media/deploy-a-blog-writer-agent/hero.png
index 0b6c8e44..069534d8 100644
Binary files a/docs/blog/assets/media/deploy-a-blog-writer-agent/hero.png and b/docs/blog/assets/media/deploy-a-blog-writer-agent/hero.png differ
diff --git a/docs/blog/assets/media/deploy-a-blog-writer-agent/note-1.png b/docs/blog/assets/media/deploy-a-blog-writer-agent/note-1.png
index d7faecc4..cc53765d 100644
Binary files a/docs/blog/assets/media/deploy-a-blog-writer-agent/note-1.png and b/docs/blog/assets/media/deploy-a-blog-writer-agent/note-1.png differ
diff --git a/docs/blog/assets/media/deploy-a-blog-writer-agent/note-2.png b/docs/blog/assets/media/deploy-a-blog-writer-agent/note-2.png
index f3f4c1e7..b2a1c48e 100644
Binary files a/docs/blog/assets/media/deploy-a-blog-writer-agent/note-2.png and b/docs/blog/assets/media/deploy-a-blog-writer-agent/note-2.png differ
diff --git a/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/hero.png b/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/hero.png
index b60090d4..41490b8b 100644
Binary files a/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/hero.png and b/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/hero.png differ
diff --git a/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-1.png b/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-1.png
index 738806fc..1c90be20 100644
Binary files a/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-1.png and b/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-1.png differ
diff --git a/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-2.png b/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-2.png
index 6dafa86e..d8ca277d 100644
Binary files a/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-2.png and b/docs/blog/assets/media/deploy-automated-pr-reviewer-agent/note-2.png differ
diff --git a/docs/blog/assets/media/how-to-install-and-use-munder-difflin/hero.png b/docs/blog/assets/media/how-to-install-and-use-munder-difflin/hero.png
index bf812aac..5c12fa2f 100644
Binary files a/docs/blog/assets/media/how-to-install-and-use-munder-difflin/hero.png and b/docs/blog/assets/media/how-to-install-and-use-munder-difflin/hero.png differ
diff --git a/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-1.png b/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-1.png
index 81d7bfb7..1edc69e4 100644
Binary files a/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-1.png and b/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-1.png differ
diff --git a/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-2.png b/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-2.png
index 758755e2..b12e94bc 100644
Binary files a/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-2.png and b/docs/blog/assets/media/how-to-install-and-use-munder-difflin/note-2.png differ
diff --git a/docs/blog/assets/media/run-munder-difflin-on-open-models/hero.png b/docs/blog/assets/media/run-munder-difflin-on-open-models/hero.png
index 01f0b5b5..84c6d9ff 100644
Binary files a/docs/blog/assets/media/run-munder-difflin-on-open-models/hero.png and b/docs/blog/assets/media/run-munder-difflin-on-open-models/hero.png differ
diff --git a/docs/blog/assets/media/run-munder-difflin-on-open-models/note-1.png b/docs/blog/assets/media/run-munder-difflin-on-open-models/note-1.png
index 2939e3ec..ed8b759f 100644
Binary files a/docs/blog/assets/media/run-munder-difflin-on-open-models/note-1.png and b/docs/blog/assets/media/run-munder-difflin-on-open-models/note-1.png differ
diff --git a/docs/blog/assets/media/run-munder-difflin-on-open-models/note-2.png b/docs/blog/assets/media/run-munder-difflin-on-open-models/note-2.png
index 2e66282e..03f6e98b 100644
Binary files a/docs/blog/assets/media/run-munder-difflin-on-open-models/note-2.png and b/docs/blog/assets/media/run-munder-difflin-on-open-models/note-2.png differ
diff --git a/docs/blog/assets/media/your-first-hour-with-munder-difflin/hero.png b/docs/blog/assets/media/your-first-hour-with-munder-difflin/hero.png
index 06b6cca8..7b821a04 100644
Binary files a/docs/blog/assets/media/your-first-hour-with-munder-difflin/hero.png and b/docs/blog/assets/media/your-first-hour-with-munder-difflin/hero.png differ
diff --git a/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-1.png b/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-1.png
index 1800b639..05b4bddf 100644
Binary files a/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-1.png and b/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-1.png differ
diff --git a/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-2.png b/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-2.png
index 9c648739..059a4dad 100644
Binary files a/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-2.png and b/docs/blog/assets/media/your-first-hour-with-munder-difflin/note-2.png differ
diff --git a/docs/blog/claude-code-git-worktrees-vs-hive/index.html b/docs/blog/claude-code-git-worktrees-vs-hive/index.html
index 242e5dd7..bbcf1f7a 100644
--- a/docs/blog/claude-code-git-worktrees-vs-hive/index.html
+++ b/docs/blog/claude-code-git-worktrees-vs-hive/index.html
@@ -322,7 +322,7 @@ team; it’s free and open source.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/claude-code-orchestration-guide/index.html b/docs/blog/claude-code-orchestration-guide/index.html
index bfba5223..a94c1088 100644
--- a/docs/blog/claude-code-orchestration-guide/index.html
+++ b/docs/blog/claude-code-orchestration-guide/index.html
@@ -320,7 +320,7 @@ agents; it’s free and open source.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/coordinating-ai-coding-agents/index.html b/docs/blog/coordinating-ai-coding-agents/index.html
index cfd67fe5..e26ebae4 100644
--- a/docs/blog/coordinating-ai-coding-agents/index.html
+++ b/docs/blog/coordinating-ai-coding-agents/index.html
@@ -307,7 +307,7 @@ your own team of Claude Code agents.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/deploy-a-blog-writer-agent/index.html b/docs/blog/deploy-a-blog-writer-agent/index.html
index db4bca97..c3e6f9b8 100644
--- a/docs/blog/deploy-a-blog-writer-agent/index.html
+++ b/docs/blog/deploy-a-blog-writer-agent/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Deploy a Blog-Writer Agent: The One That Wrote This Post — Munder Difflin Blog</title>
-<meta name="description" content="How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own." />
+<meta name="description" content="How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own." />
<link rel="canonical" href="https://munderdiffl.in/blog/deploy-a-blog-writer-agent/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="Deploy a Blog-Writer Agent: The One That Wrote This Post — Munder Difflin Blog" />
-<meta property="og:description" content="How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own." />
+<meta property="og:description" content="How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own." />
<meta property="og:url" content="https://munderdiffl.in/blog/deploy-a-blog-writer-agent/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -31,7 +31,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Deploy a Blog-Writer Agent: The One That Wrote This Post — Munder Difflin Blog" />
-<meta name="twitter:description" content="How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own." />
+<meta name="twitter:description" content="How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -45,10 +45,10 @@
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Deploy a Blog-Writer Agent: The One That Wrote This Post",
- "description": "How Munder Difflin's blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.",
+ "description": "How Munder Difflin's blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.",
"image": ["https://munderdiffl.in/media/og.png"],
"datePublished": "2026-06-10T00:00:00.000Z",
- "dateModified": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-08-20T00:00:00.000Z",
"author": { "@type": "Person", "name": "Chaitanya Giri" },
"publisher": {
"@type": "Organization",
@@ -79,9 +79,9 @@
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
- { "@type": "Question", "name": "Did an AI actually write the Munder Difflin blog?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — most of it. A writer agent in the hive drafts each post from a topic brief and a house-style reference, the GOD orchestrator integrates it as the single committer, Eleventy builds the markdown into the static site, and a human approves the final deploy to munderdiffl.in. This very post is an example of that pipeline running. At time of writing there are 85 published posts in the blog." } },
+ { "@type": "Question", "name": "Did an AI actually write the Munder Difflin blog?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — most of it. A writer agent in the hive drafts each post from a topic brief and a house-style reference, Michael integrates it as the single committer, Eleventy builds the markdown into the static site, and a human approves the final deploy to munderdiffl.in. This very post is an example of that pipeline running — and as of August 2026, the same office also draws every post's illustrations as code." } },
{ "@type": "Question", "name": "Is the blog-writer agent fully autonomous?", "acceptedAnswer": { "@type": "Answer", "text": "Almost — it's deliberately human-gated at one point: publish. The agent drafts and self-reviews against a style reference in an isolated worktree; the orchestrator integrates and builds; a person reviews the diff and approves the deploy. That keeps the volume high and hands-off without putting an unreviewed post on the live domain." } },
- { "@type": "Question", "name": "How do I build my own blog-writer agent?", "acceptedAnswer": { "@type": "Answer", "text": "Give one agent in the hive three things: a topic or brief, a house-style reference (a few of your best existing posts), and write access to an isolated worktree. Let it draft, have a reviewer agent or the orchestrator check it, then human-approve the build and deploy. Munder Difflin gives you the worktree isolation, single-committer git, and approval queue out of the box." } },
+ { "@type": "Question", "name": "How do I build my own blog-writer agent?", "acceptedAnswer": { "@type": "Answer", "text": "Give one agent in the hive three things: a topic or brief, a house-style reference (a few of your best existing posts), and write access to an isolated worktree. Let it draft, have a reviewer agent or the orchestrator check it, then human-approve the build and deploy. Munder Difflin gives you the worktree isolation, single-committer git, skills, and approval queue out of the box." } },
{ "@type": "Question", "name": "Why use a multi-agent hive instead of one prompt to write blog posts?", "acceptedAnswer": { "@type": "Answer", "text": "One prompt writes one post. A hive runs a content function: a writer drafts, a reviewer checks, the orchestrator integrates and builds, and a scheduled mission can fire the loop on a cadence — so you get a steady, compounding stream of on-topic posts rather than a single output you have to re-prompt for each time." } }
]
@@ -142,7 +142,7 @@
<a href="/blog/topics/use-cases/">Use Cases</a>
</nav>
<h1>Deploy a Blog-Writer Agent: The One That Wrote This Post</h1>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="byline">
<span class="av" aria-hidden="true">CG</span>
<strong>Chaitanya Giri</strong>
@@ -160,11 +160,12 @@
<div class="prose">
<div class="callout tldr"><span class="ic">TL;DR</span><p>The Munder Difflin blog is written by an
<strong>automated writer agent</strong> living in the hive. The loop: a writer agent drafts a post in an
-<strong>isolated worktree</strong> from a topic brief + a house-style reference; the
-<strong>GOD orchestrator</strong> integrates it as the single committer; <strong>Eleventy</strong> builds
+<strong>isolated worktree</strong> from a topic brief + a house-style reference; <strong>Michael</strong>
+integrates it as the single committer; <strong>Eleventy</strong> builds
<code>blog/src/posts</code> → <code>docs/blog</code>; and a human approves the deploy to
-<strong>munderdiffl.in</strong>. The outcome is a steady, on-topic stream of posts — <strong>85 and
-counting</strong> — that compounds into real SEO. <em>This post was written that way.</em></p></div>
+<strong>munderdiffl.in</strong>. The outcome is a steady, on-topic stream — <strong>well over a hundred
+posts and counting</strong>, every one now illustrated by code the same office wrote.
+<em>This post was made that way.</em></p></div>
<p>Here’s a fact that’s either a confession or a flex, depending on how you read it: the blog you’re reading
is mostly written by one of our own agents. Not “AI-assisted.” Not “drafted then heavily rewritten.” A
<strong>writer agent</strong> in the Munder Difflin hive takes a brief, drafts a full post, and hands it down a pipeline
@@ -172,28 +173,24 @@ that ends — after one human nod — on the live site.</p>
<p>This very post is an instance of that system working. So let me do the most on-brand thing possible and use
it as the worked example. Here’s how the blog-writer agent is automated, why the outcome compounds, and how
to stand up your own.</p>
-<h2 id="the-outcome-first-so-many-blogs-about-us" tabindex="-1">The outcome first: so many blogs about us <a class="anchor" href="#the-outcome-first-so-many-blogs-about-us" aria-hidden="true">#</a></h2>
-<p>Before the <em>how</em>, the <em>why it matters</em>. As of today there are <strong>85 published posts</strong> in this blog. They’re
-not filler — they cluster into a real content strategy:</p>
-<ul>
-<li><strong>23 guides</strong>, <strong>15 internals</strong> deep-dives, <strong>13 concept</strong> explainers, <strong>12 comparisons</strong>, and
-<strong>8 orchestration</strong> posts.</li>
-<li>A small but pointed <strong>story</strong> set (5 posts), including <a href="/blog/why-we-built-munder-difflin/">why we built
+<h2 id="the-outcome-first-a-library-not-a-launch-post" tabindex="-1">The outcome first: a library, not a launch post <a class="anchor" href="#the-outcome-first-a-library-not-a-launch-post" aria-hidden="true">#</a></h2>
+<p>Before the <em>how</em>, the <em>why it matters</em>. This blog now holds <strong>well over a hundred published posts</strong> —
+the topic chips at the top of <a href="/blog/">the index</a> show the live counts. They’re not filler — they
+cluster into a real content strategy: guides, internals deep-dives, concept explainers, comparisons,
+orchestration patterns, and a pointed story set, including <a href="/blog/why-we-built-munder-difflin/">why we built
Munder Difflin</a> and the
-<a href="/blog/launching-munder-difflin-v0-2-4/">v0.2.4 launch</a>.</li>
-<li>A thought-leadership thread that does the heavy SEO lifting — the
-<a href="/blog/the-multi-agent-cost-playbook/">multi-agent cost playbook</a>,
-<a href="/blog/compressing-agent-memory/">compressing agent memory without losing the original</a>,
-<a href="/blog/context-engineering-for-ai-agents/">context engineering for AI agents</a>, and more.</li>
-</ul>
-<p>That’s the whole point of automating the writer: <strong>volume that stays on-topic compounds</strong>. Eighty-five
+<a href="/blog/what-reddit-told-us-about-munder-difflin/">launch-week retros</a>. The thought-leadership thread
+does the heavy SEO lifting — the <a href="/blog/the-multi-agent-cost-playbook/">multi-agent cost playbook</a>,
+<a href="/blog/compressing-agent-memory/">compressing agent memory</a>,
+<a href="/blog/context-engineering-for-ai-agents/">context engineering for AI agents</a>, and more.</p>
+<p>That’s the whole point of automating the writer: <strong>volume that stays on-topic compounds</strong>. A hundred-plus
internally-linked, keyword-targeted posts is a discoverability moat you cannot hand-write at a startup’s
spare-time pace. When someone — or an AI answer engine — searches “single-committer git multi-agent” or
“compressing agent memory,” there’s a post for that, and it links to five neighbors. The blog-writer agent
is how a one-person project publishes like a content team.</p>
<p>And crucially: it’s <em>largely hands-off</em>. The expensive part of blogging isn’t typing — it’s the discipline
to keep shipping. An agent has no problem with discipline.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/deploy-a-blog-writer-agent/note-1.png" alt="Hand-drawn sketch from “Deploy a Blog-Writer Agent: The One That Wrote This Post”" loading="lazy" decoding="async" /></figure>
+<figure class="fig fig-inline"><img src="/blog/assets/media/deploy-a-blog-writer-agent/note-1.png" alt="Hand-drawn sketch from “Deploy a Blog-Writer Agent: The One That Wrote This Post”" loading="lazy" decoding="async" /><figcaption>The content function: brief in, draft in a worktree, one committer, one build, one human gate — on a timer.</figcaption></figure>
<h2 id="the-pipeline-end-to-end" tabindex="-1">The pipeline, end to end <a class="anchor" href="#the-pipeline-end-to-end" aria-hidden="true">#</a></h2>
<p>The writer agent isn’t a magic monolith. It’s one role in a hive, and the post moves through the same
machinery any work does. Four stages:</p>
@@ -202,13 +199,15 @@ machinery any work does. Four stages:</p>
<strong>house-style reference</strong>: a handful of existing posts to mirror for voice, front-matter, and structure. It
works in its <strong>own git worktree</strong> — a separate working directory so its in-progress draft never collides
with anyone else’s files. (We wrote about why that isolation matters in
-<a href="/blog/claude-code-git-worktrees-vs-hive/">git worktrees vs a hive</a>.)</p>
-<p>The agent reads the reference posts, counts what already exists, picks internal links to neighbors, writes
-the front-matter (title, description, category, keywords, FAQ schema), and drafts ~1,000–1,400 words of
-body. It self-checks against the style reference before handing off. The output is a single <code>.md</code> file in
+<a href="/blog/claude-code-git-worktrees-vs-hive/">git worktrees vs a hive</a>.) Since v0.4.4 the writer can also
+carry an installed <strong>skill</strong> — a house-style checklist it re-reads on every draft, instead of a prompt
+we hope it remembers.</p>
+<p>The agent reads the reference posts, picks internal links to neighbors, writes the front-matter (title,
+description, category, keywords, FAQ schema), and drafts ~1,000–1,400 words of body. It self-checks
+against the style reference before handing off. The output is a single <code>.md</code> file in
<code>blog/src/posts/</code> — filename becomes the URL slug.</p>
<h3 id="2-integrate-the-orchestrator-is-the-single-committer" tabindex="-1">2. Integrate — the orchestrator is the single committer <a class="anchor" href="#2-integrate-the-orchestrator-is-the-single-committer" aria-hidden="true">#</a></h3>
-<p>The writer <strong>never commits</strong>. It writes a plain file; the <strong>GOD orchestrator</strong> owns every commit. This is
+<p>The writer <strong>never commits</strong>. It writes a plain file; <strong>Michael</strong> owns every commit. This is
the <a href="/blog/single-committer-git-pattern/">single-committer pattern</a> — agents write files, one process
serializes all the git, so parallel agents never race on <code>.git/index.lock</code> and the repo stays a clean audit
log. The orchestrator picks up the finished draft, reviews routing, and commits it into the real tree.</p>
@@ -218,6 +217,11 @@ markdown file is the entire authoring action: the build auto-adds the post to th
each tag page, the sitemap, and the RSS feed — plus the SEO that’s already wired (canonical URLs, OpenGraph,
<code>BlogPosting</code> + <code>FAQPage</code> JSON-LD). No other file gets touched. That’s deliberate: the agent’s job is <em>write
one file correctly</em>, and the build does the rest.</p>
+<p><strong>And since August 2026, the pictures are part of the pipeline too.</strong> Every post’s hero and inline
+sketches are <a href="/blog/an-agent-redesigned-this-blog/">drawn as code by an agent</a> — an SVG parts library,
+composition archetypes, and one spec file, rendered through a headless browser for exactly $0 in image
+APIs. One <code>media.json</code> manifest drives every image on the blog; a post ships with designed placeholders
+until its drawings land, so nothing is ever broken.</p>
<h3 id="4-deploy-human-gated-on-purpose" tabindex="-1">4. Deploy — human-gated, on purpose <a class="anchor" href="#4-deploy-human-gated-on-purpose" aria-hidden="true">#</a></h3>
<p>This is the one stage that is <strong>not</strong> automated, by design. The build output under <code>docs/blog</code> is served by
GitHub Pages at <strong><a href="http://munderdiffl.in/blog">munderdiffl.in/blog</a></strong>. Before that goes live, a person reviews the diff and approves the
@@ -226,14 +230,15 @@ action</a> to the human-approval queue rather than shipping it itself.</p>
<p>The split is the lesson: <strong>drafting and integration are autonomous; publishing is human-gated.</strong> You get the
throughput of an agent and the safety of a final human read. Nobody wants a hallucinated claim on their
front page — so that one gate stays manual while everything upstream runs hands-off.</p>
+<figure class="fig fig-inline"><img src="/blog/assets/media/deploy-a-blog-writer-agent/note-2.png" alt="Hand-drawn sketch from “Deploy a Blog-Writer Agent: The One That Wrote This Post”" loading="lazy" decoding="async" /><figcaption>One gate stays human on purpose: the deploy. Everything upstream of it runs itself.</figcaption></figure>
<h2 id="build-your-own-blog-writer-agent" tabindex="-1">Build your own blog-writer agent <a class="anchor" href="#build-your-own-blog-writer-agent" aria-hidden="true">#</a></h2>
<p>You don’t need our exact stack. The pattern transfers to any static site or CMS. Here’s the recipe.</p>
<p><strong>1. Give it a brief.</strong> One topic, the search intent, and the angle. Pull it from a keyword backlog so the
agent is always writing something discoverable, not random.</p>
<p><strong>2. Give it a house-style reference.</strong> This is the highest-leverage input. Point the agent at three to five
-of your <em>best</em> existing posts and tell it to mirror their front-matter, voice, length, and link density. A
-writer with a strong reference produces something publishable; a writer without one produces generic AI
-slop. Your style guide is just “be like these.”</p>
+of your <em>best</em> existing posts and tell it to mirror their front-matter, voice, length, and link density —
+or install that guidance as a <strong>skill</strong>, so every draft re-reads it. A writer with a strong reference
+produces something publishable; a writer without one produces generic AI slop.</p>
<p><strong>3. Isolate the draft.</strong> Let the agent write in its own worktree (or branch, or scratch directory) so an
in-flight draft can’t clobber live files. In Munder Difflin this is a per-agent Git isolation toggle.</p>
<p><strong>4. Review before publish.</strong> Have a reviewer agent or your orchestrator check the draft against the brief,
@@ -242,25 +247,17 @@ then put the <strong>deploy</strong> behind a human approval. Draft and integrat
the next backlog item each time. One prompt to the orchestrator stood up <a href="/blog/one-prompt-automated-pr-review/">an hourly PR
reviewer</a> for us the same way — automation that just keeps running.
Point that same scheduling at content and the blog writes itself on a timer.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/deploy-a-blog-writer-agent/note-2.png" alt="Hand-drawn sketch from “Deploy a Blog-Writer Agent: The One That Wrote This Post”" loading="lazy" decoding="async" /></figure>
<h2 id="the-meta-point" tabindex="-1">The meta-point <a class="anchor" href="#the-meta-point" aria-hidden="true">#</a></h2>
<p>A multi-agent hive isn’t only for code. Once you have a writer that drafts, an orchestrator that integrates
and commits, a build that publishes, and one human gate, you have a <strong>content function</strong> — not a one-off
-prompt. The difference shows up as 85 posts instead of 1.</p>
+prompt. The difference shows up as a library instead of a launch post.</p>
<p>So consider this post Exhibit A. It was briefed, drafted in a worktree against a style reference, integrated
-single-committer, Eleventy-built, and human-approved to the domain — the exact loop it describes. The system
-is, quite literally, writing about itself.</p>
-<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
-<p><strong>Did an AI really write this?</strong> Yes — drafted by a writer agent in the hive from a brief and a house-style
-reference, then human-reviewed before publish. That’s the whole pipeline this post documents.</p>
-<p><strong>Is it fully autonomous?</strong> Almost. Draft and integration are hands-off; <strong>publish is human-gated</strong> on
-purpose, so nothing reaches the live domain unread.</p>
-<p><strong>Does the volume actually help?</strong> It’s the point. On-topic, internally-linked posts compound into SEO and
-answer-engine reach you can’t hand-write at solo pace — 85 of them and climbing.</p>
+single-committer, Eleventy-built, illustrated by code, and human-approved to the domain — the exact loop it
+describes. The system is, quite literally, writing about itself.</p>
<hr>
-<p>Munder Difflin runs a <a href="https://munderdiffl.in/#how">hive of Claude Code, Codex, and Antigravity agents</a> on
-your own machine — with isolated worktrees, single-committer git, and a human-approval queue built in, so an
-agent can draft and integrate while you keep the one gate that matters.
+<p>Munder Difflin runs a <a href="https://munderdiffl.in/#how">hive of agents on ten engines</a> on
+your own machine — with isolated worktrees, single-committer git, skills, and a human-approval queue built
+in, so an agent can draft and integrate while you keep the one gate that matters.
<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to put a blog-writer (or any worker) on your
floor; it’s free and open source.</p>
@@ -271,7 +268,7 @@ floor; it’s free and open source.</p>
<div class="qa">
<p class="q">Did an AI actually write the Munder Difflin blog?</p>
- <p class="a">Yes — most of it. A writer agent in the hive drafts each post from a topic brief and a house-style reference, the GOD orchestrator integrates it as the single committer, Eleventy builds the markdown into the static site, and a human approves the final deploy to munderdiffl.in. This very post is an example of that pipeline running. At time of writing there are 85 published posts in the blog.</p>
+ <p class="a">Yes — most of it. A writer agent in the hive drafts each post from a topic brief and a house-style reference, Michael integrates it as the single committer, Eleventy builds the markdown into the static site, and a human approves the final deploy to munderdiffl.in. This very post is an example of that pipeline running — and as of August 2026, the same office also draws every post&#39;s illustrations as code.</p>
</div>
<div class="qa">
@@ -281,7 +278,7 @@ floor; it’s free and open source.</p>
<div class="qa">
<p class="q">How do I build my own blog-writer agent?</p>
- <p class="a">Give one agent in the hive three things: a topic or brief, a house-style reference (a few of your best existing posts), and write access to an isolated worktree. Let it draft, have a reviewer agent or the orchestrator check it, then human-approve the build and deploy. Munder Difflin gives you the worktree isolation, single-committer git, and approval queue out of the box.</p>
+ <p class="a">Give one agent in the hive three things: a topic or brief, a house-style reference (a few of your best existing posts), and write access to an isolated worktree. Let it draft, have a reviewer agent or the orchestrator check it, then human-approve the build and deploy. Munder Difflin gives you the worktree isolation, single-committer git, skills, and approval queue out of the box.</p>
</div>
<div class="qa">
@@ -305,7 +302,7 @@ floor; it’s free and open source.</p>
<aside class="toc-rail" aria-label="Table of contents">
<div class="tt">On this page</div>
<ol>
- <li class="lvl-2"><a href="#the-outcome-first-so-many-blogs-about-us">The outcome first: so many blogs about us</a></li><li class="lvl-2"><a href="#the-pipeline-end-to-end">The pipeline, end to end</a></li><li class="lvl-3"><a href="#1-draft-in-an-isolated-worktree">1. Draft — in an isolated worktree</a></li><li class="lvl-3"><a href="#2-integrate-the-orchestrator-is-the-single-committer">2. Integrate — the orchestrator is the single committer</a></li><li class="lvl-3"><a href="#3-build-eleventy-turns-markdown-into-a-site">3. Build — Eleventy turns markdown into a site</a></li><li class="lvl-3"><a href="#4-deploy-human-gated-on-purpose">4. Deploy — human-gated, on purpose</a></li><li class="lvl-2"><a href="#build-your-own-blog-writer-agent">Build your own blog-writer agent</a></li><li class="lvl-2"><a href="#the-meta-point">The meta-point</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
+ <li class="lvl-2"><a href="#the-outcome-first-a-library-not-a-launch-post">The outcome first: a library, not a launch post</a></li><li class="lvl-2"><a href="#the-pipeline-end-to-end">The pipeline, end to end</a></li><li class="lvl-3"><a href="#1-draft-in-an-isolated-worktree">1. Draft — in an isolated worktree</a></li><li class="lvl-3"><a href="#2-integrate-the-orchestrator-is-the-single-committer">2. Integrate — the orchestrator is the single committer</a></li><li class="lvl-3"><a href="#3-build-eleventy-turns-markdown-into-a-site">3. Build — Eleventy turns markdown into a site</a></li><li class="lvl-3"><a href="#4-deploy-human-gated-on-purpose">4. Deploy — human-gated, on purpose</a></li><li class="lvl-2"><a href="#build-your-own-blog-writer-agent">Build your own blog-writer agent</a></li><li class="lvl-2"><a href="#the-meta-point">The meta-point</a></li>
</ol>
</aside>
diff --git a/docs/blog/deploy-automated-pr-reviewer-agent/index.html b/docs/blog/deploy-automated-pr-reviewer-agent/index.html
index 179441eb..9e5eb157 100644
--- a/docs/blog/deploy-automated-pr-reviewer-agent/index.html
+++ b/docs/blog/deploy-automated-pr-reviewer-agent/index.html
@@ -48,7 +48,7 @@
"description": "A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.",
"image": ["https://munderdiffl.in/media/og.png"],
"datePublished": "2026-06-10T00:00:00.000Z",
- "dateModified": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-08-20T00:00:00.000Z",
"author": { "@type": "Person", "name": "Chaitanya Giri" },
"publisher": {
"@type": "Organization",
@@ -79,8 +79,8 @@
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
- { "@type": "Question", "name": "How do you deploy an automated PR reviewer in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "You brief the GOD orchestrator in plain English: give it a review objective, point it at the repo and its open PRs/issues, and ask it to post reviews back and escalate anything serious. The orchestrator spins up a dedicated PR Reviewer agent, runs the first pass, and sets up a recurring mission so new PRs get reviewed on a cadence. No YAML, no webhook, no per-seat SaaS subscription." } },
- { "@type": "Question", "name": "Does the reviewer read the actual code or just the PR description?", "acceptedAnswer": { "@type": "Answer", "text": "The actual code. The PR Reviewer agent is a real CLI agent (Claude Code, Codex, or Antigravity) with filesystem and git access to the checked-out repo, so it reviews diffs and issues against the released source — not just the summary text in the PR. That's what lets it verify a claimed bug is real before it escalates." } },
+ { "@type": "Question", "name": "How do you deploy an automated PR reviewer in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "You brief Michael, the orchestrator, in plain English: give him a review objective, point him at the repo and its open PRs/issues, and ask him to post reviews back and escalate anything serious. He spins up a dedicated PR Reviewer agent, runs the first pass, and registers a recurring mission in the Triggers tab so new PRs get reviewed on a cadence. No YAML, no webhook, no per-seat SaaS subscription." } },
+ { "@type": "Question", "name": "Does the reviewer read the actual code or just the PR description?", "acceptedAnswer": { "@type": "Answer", "text": "The actual code. The PR Reviewer agent is a real CLI agent — any of the ten supported engines, Claude Code being the usual pick — with filesystem and git access to the checked-out repo, so it reviews diffs and issues against the released source, not just the summary text in the PR. That's what lets it verify a claimed bug is real before it escalates." } },
{ "@type": "Question", "name": "Will it spam every PR with low-value comments?", "acceptedAnswer": { "@type": "Answer", "text": "It doesn't have to. Because the reviewer reads shared hive memory and the full set of open issues at once, it can consolidate duplicate reports into one signal and only escalate findings that are verified and high-impact. In a recent run it collapsed 22 duplicate/breaker firings down to two real findings before pinging a human." } },
{ "@type": "Question", "name": "Is this a cloud service?", "acceptedAnswer": { "@type": "Answer", "text": "No. Munder Difflin is a local-first desktop app. The reviewer runs on your machine using the CLI subscriptions you already pay for, and the scheduler that re-fires it lives in the app process — so it reviews while the app is open, and catches up on overdue ticks at next launch." } }
@@ -149,7 +149,7 @@
<span class="dot" aria-hidden="true">·</span>
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true">·</span>
- <span>6 min read</span>
+ <span>7 min read</span>
<span class="tag kind">Orchestration</span>
</div>
</header>
@@ -162,7 +162,7 @@
<p>Every team that ships open source hits the same wall: the issues and PRs arrive faster than anyone can read them, and most of the noise is duplicates of the same two real bugs. The SaaS review bots help — but they read the PR <em>description</em>, charge per seat, and don’t understand the rest of your backlog.</p>
<p>We built ours differently, and we run it on ourselves. This is a how-to for deploying the same thing: a <strong>PR Reviewer agent</strong> that lives in your hive, reads your actual diff and source, de-dupes the noise, and only taps a human when something is genuinely worth a human. Then a case study of what that looks like on a real, messy day.</p>
<h2 id="what-pr-reviewer-agent-actually-means-here" tabindex="-1">What “PR Reviewer agent” actually means here <a class="anchor" href="#what-pr-reviewer-agent-actually-means-here" aria-hidden="true">#</a></h2>
-<p>In Munder Difflin, an agent isn’t a chat window — it’s a real CLI (Claude Code, Codex, or Antigravity) running on your machine with filesystem and git access, plugged into the hive’s shared inbox and memory. So a “PR Reviewer” is just a worker you’ve given one job: watch the repo, review what comes in, and report back.</p>
+<p>In Munder Difflin, an agent isn’t a chat window — it’s a real CLI (any of the ten supported engines, from Claude Code to Codex to OpenCode) running on your machine with filesystem and git access, plugged into the hive’s shared inbox and memory. So a “PR Reviewer” is just a worker you’ve given one job: watch the repo, review what comes in, and report back. Since v0.4.4 you can also hand it an installed <strong>skill</strong> — a review checklist it re-reads on every pass, so your severity bar and house rules survive across sessions.</p>
<p>That framing matters because of what it unlocks:</p>
<ul>
<li><strong>It reads the real source, not the summary.</strong> When a PR claims “fixes the Windows usage meter,” the agent can open the reconciler, trace the path-encoding logic, and confirm the fix — instead of trusting the PR title.</li>
@@ -171,7 +171,7 @@
</ul>
<figure class="fig fig-inline"><img src="/blog/assets/media/deploy-automated-pr-reviewer-agent/note-1.png" alt="Hand-drawn sketch from “Deploy a PR Reviewer That Never Sleeps — In About One Prompt”" loading="lazy" decoding="async" /></figure>
<h2 id="deploying-it-the-one-prompt-version" tabindex="-1">Deploying it: the one-prompt version <a class="anchor" href="#deploying-it-the-one-prompt-version" aria-hidden="true">#</a></h2>
-<p>You don’t configure this. You brief it. Open Munder Difflin, select the GOD orchestrator, and describe the outcome the way you’d brief a coworker:</p>
+<p>You don’t configure this. You brief it. Open Munder Difflin, select Michael, and describe the outcome the way you’d brief a coworker:</p>
<blockquote>
<p><em>Stand up a PR Reviewer for our GitHub repo. Review the open PRs and any new bug-report issues against the released source — verify each claim in the actual code, post a review comment on each, consolidate duplicates into one finding, and ping me directly for anything HIGH severity. Then check for new ones every hour and do the same.</em></p>
</blockquote>
@@ -207,15 +207,15 @@
<p>Two limits worth stating plainly, because overselling this helps no one:</p>
<ul>
<li><strong>It runs while the app is open.</strong> The scheduler lives in the desktop app’s process — this is local-first, not a cloud cron. It catches up on overdue ticks at next launch (each mission remembers when it last fired), so the cadence resumes after a restart. But if you need reviews while the laptop is shut, that’s a cloud job’s territory, and we’d rather tell you that than pretend otherwise.</li>
-<li><strong>It’s judgment, not an oracle.</strong> It’s a Claude/Codex/Antigravity agent reading real code, so it brings real judgment — and, like any reviewer, it can be wrong. The escalation bar exists precisely so a human sees the consequential calls. Treat its reviews like a sharp colleague’s, not a CI gate that’s always right.</li>
+<li><strong>It’s judgment, not an oracle.</strong> It’s a real coding agent reading real code, so it brings real judgment — and, like any reviewer, it can be wrong. The escalation bar exists precisely so a human sees the consequential calls. Treat its reviews like a sharp colleague’s, not a CI gate that’s always right.</li>
</ul>
<p>Within those limits, what you get is genuinely useful: a reviewer that never sleeps, reads your actual diff and source, de-dupes the noise, and only escalates what matters.</p>
<h2 id="deploy-yours" tabindex="-1">Deploy yours <a class="anchor" href="#deploy-yours" aria-hidden="true">#</a></h2>
<p>If you maintain a repo with more inbound than time, this is roughly a five-minute setup and zero ongoing babysitting:</p>
<ol>
-<li><a href="https://munderdiffl.in/#install">Download Munder Difflin</a> — free, open source, local-first, macOS/Windows/Linux.</li>
-<li>Add a CLI agent (<code>claude</code>, <code>codex</code>, or <code>agy</code> — whichever subscription you already have).</li>
-<li>Brief the GOD orchestrator with the prompt above, swapping in your repo and your escalation bar.</li>
+<li><a href="https://munderdiffl.in/#install">Download Munder Difflin</a> — free, open source, local-first, macOS/Windows/Linux (and yes, <a href="/blog/launching-munder-difflin-v0-4-4/">Windows is first-class as of v0.4.4</a>).</li>
+<li>Add a CLI agent on whichever engine subscription you already have — the app supports ten, and <strong>Settings → Prerequisites</strong> confirms which binaries it can see.</li>
+<li>Brief Michael with the prompt above, swapping in your repo and your escalation bar.</li>
<li>Leave it running on a second monitor and let new PRs get reviewed on the hour.</li>
</ol>
<p>The pitch is simple, and it’s true: <strong>a reviewer that never sleeps, reads your real source, de-dupes the noise, and only escalates what matters — set up in about one prompt.</strong> Go point one at your backlog.</p>
@@ -227,12 +227,12 @@
<div class="qa">
<p class="q">How do you deploy an automated PR reviewer in Munder Difflin?</p>
- <p class="a">You brief the GOD orchestrator in plain English: give it a review objective, point it at the repo and its open PRs/issues, and ask it to post reviews back and escalate anything serious. The orchestrator spins up a dedicated PR Reviewer agent, runs the first pass, and sets up a recurring mission so new PRs get reviewed on a cadence. No YAML, no webhook, no per-seat SaaS subscription.</p>
+ <p class="a">You brief Michael, the orchestrator, in plain English: give him a review objective, point him at the repo and its open PRs/issues, and ask him to post reviews back and escalate anything serious. He spins up a dedicated PR Reviewer agent, runs the first pass, and registers a recurring mission in the Triggers tab so new PRs get reviewed on a cadence. No YAML, no webhook, no per-seat SaaS subscription.</p>
</div>
<div class="qa">
<p class="q">Does the reviewer read the actual code or just the PR description?</p>
- <p class="a">The actual code. The PR Reviewer agent is a real CLI agent (Claude Code, Codex, or Antigravity) with filesystem and git access to the checked-out repo, so it reviews diffs and issues against the released source — not just the summary text in the PR. That&#39;s what lets it verify a claimed bug is real before it escalates.</p>
+ <p class="a">The actual code. The PR Reviewer agent is a real CLI agent — any of the ten supported engines, Claude Code being the usual pick — with filesystem and git access to the checked-out repo, so it reviews diffs and issues against the released source, not just the summary text in the PR. That&#39;s what lets it verify a claimed bug is real before it escalates.</p>
</div>
<div class="qa">
diff --git a/docs/blog/feed.xml b/docs/blog/feed.xml
index 8667affc..b77d368b 100644
--- a/docs/blog/feed.xml
+++ b/docs/blog/feed.xml
@@ -252,8 +252,8 @@
<link href="https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" />
<id>https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/</id>
<published>2026-07-03T00:00:00.000Z</published>
- <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />
- <summary>A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</summary>
+ <updated>2026-08-20T00:00:00.000Z</updated><category term="Guides" />
+ <summary>A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</summary>
</entry>
<entry>
<title>Launching Munder Difflin v0.3.2: Talk to Michael, a Realtime Voice Orchestrator</title>
@@ -276,8 +276,8 @@
<link href="https://munderdiffl.in/blog/run-munder-difflin-on-open-models/" />
<id>https://munderdiffl.in/blog/run-munder-difflin-on-open-models/</id>
<published>2026-06-22T00:00:00.000Z</published>
- <updated>2026-06-22T00:00:00.000Z</updated><category term="Guides" />
- <summary>Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</summary>
+ <updated>2026-08-20T00:00:00.000Z</updated><category term="Guides" />
+ <summary>Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</summary>
</entry>
<entry>
<title>Launching Munder Difflin v0.3.0: Selectable Engines, Integrations &amp; Slack-Spawned Workers</title>
@@ -316,15 +316,15 @@
<link href="https://munderdiffl.in/blog/deploy-a-blog-writer-agent/" />
<id>https://munderdiffl.in/blog/deploy-a-blog-writer-agent/</id>
<published>2026-06-10T00:00:00.000Z</published>
- <updated>2026-06-10T00:00:00.000Z</updated><category term="Use Cases" />
- <summary>How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</summary>
+ <updated>2026-08-20T00:00:00.000Z</updated><category term="Use Cases" />
+ <summary>How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</summary>
</entry>
<entry>
<title>Deploy a PR Reviewer That Never Sleeps — In About One Prompt</title>
<link href="https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/" />
<id>https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/</id>
<published>2026-06-10T00:00:00.000Z</published>
- <updated>2026-06-10T00:00:00.000Z</updated><category term="Orchestration" />
+ <updated>2026-08-20T00:00:00.000Z</updated><category term="Orchestration" />
<summary>A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</summary>
</entry>
<entry>
@@ -436,8 +436,8 @@
<link href="https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/" />
<id>https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/</id>
<published>2026-06-05T00:00:00.000Z</published>
- <updated>2026-06-05T00:00:00.000Z</updated><category term="Guides" />
- <summary>Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</summary>
+ <updated>2026-08-20T00:00:00.000Z</updated><category term="Guides" />
+ <summary>Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</summary>
</entry>
<entry>
<title>MCP Tool Poisoning: How to Secure the Model Context Protocol</title>
diff --git a/docs/blog/how-the-god-orchestrator-works/index.html b/docs/blog/how-the-god-orchestrator-works/index.html
index 7f7656cf..ad22903b 100644
--- a/docs/blog/how-the-god-orchestrator-works/index.html
+++ b/docs/blog/how-the-god-orchestrator-works/index.html
@@ -350,7 +350,7 @@ to put one in charge of your floor; it’s free and open source.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/how-to-install-and-use-munder-difflin/index.html b/docs/blog/how-to-install-and-use-munder-difflin/index.html
index 31f0e36a..bb15000d 100644
--- a/docs/blog/how-to-install-and-use-munder-difflin/index.html
+++ b/docs/blog/how-to-install-and-use-munder-difflin/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>How to Install and Use Munder Difflin — Munder Difflin Blog</title>
-<meta name="description" content="Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish." />
+<meta name="description" content="Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish." />
<link rel="canonical" href="https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="How to Install and Use Munder Difflin — Munder Difflin Blog" />
-<meta property="og:description" content="Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish." />
+<meta property="og:description" content="Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish." />
<meta property="og:url" content="https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -32,7 +32,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="How to Install and Use Munder Difflin — Munder Difflin Blog" />
-<meta name="twitter:description" content="Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish." />
+<meta name="twitter:description" content="Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -46,10 +46,10 @@
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "How to Install and Use Munder Difflin",
- "description": "Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.",
+ "description": "Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.",
"image": ["https://munderdiffl.in/media/og.png"],
"datePublished": "2026-06-05T00:00:00.000Z",
- "dateModified": "2026-06-05T00:00:00.000Z",
+ "dateModified": "2026-08-20T00:00:00.000Z",
"author": { "@type": "Person", "name": "Chaitanya Giri" },
"publisher": {
"@type": "Organization",
@@ -57,7 +57,7 @@
"logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
},
"mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/" },
- "keywords": "how to install munder difflin, munder difflin download, munder difflin app, munder difflin tutorial",
+ "keywords": "how to install munder difflin, munder difflin download, munder difflin app, munder difflin tutorial, munder difflin windows",
"articleSection": "Guides",
"inLanguage": "en-US",
"url": "https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/"
@@ -80,11 +80,11 @@
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
- { "@type": "Question", "name": "Is Munder Difflin free?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Munder Difflin is free and open source under the MIT license. Download a build for macOS, Windows, or Linux, or run it from source — there's no paid tier." } },
- { "@type": "Question", "name": "Do I need Claude Code to use Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Munder Difflin coordinates real Claude Code sessions, so you bring your own Claude Code (the `claude` CLI on your PATH). Each agent runs a real `claude` process; the harness adds memory, messaging, and the GOD orchestrator on top." } },
- { "@type": "Question", "name": "Can I leave it running for hours or days?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — that's the point. With auto mode on, agents run unattended and a GOD orchestrator routes work and escalates only the critical calls to you. Give an agent a persistent Goal and it keeps working a long-horizon task across many prompts while you're away." } },
- { "@type": "Question", "name": "What platforms does it support?", "acceptedAnswer": { "@type": "Answer", "text": "macOS, Windows, and Linux. Grab the matching installer (.dmg, .exe, or .AppImage) from the latest release, or build from source with Node 18+ in two commands." } },
- { "@type": "Question", "name": "Is auto mode safe?", "acceptedAnswer": { "@type": "Answer", "text": "Auto mode spawns agents with `--permission-mode bypassPermissions`, so they don't pause for file edits or shell commands. It's the right default for the unattended control-room experience, but it's a foot-gun on production repos. Keep it on for sandboxed or disposable working copies; turn it off (or drop the flag per agent) when you want to babysit." } }
+ { "@type": "Question", "name": "Is Munder Difflin free?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Munder Difflin is free and open source under the MIT license. Download a build for macOS, Windows, or Linux, or run it from source — and once installed, the app keeps itself up to date from GitHub releases, telling you what's in each update before you restart into it." } },
+ { "@type": "Question", "name": "Do I need Claude Code to use Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "No — you need at least one supported engine, and Claude Code is the most popular of ten: Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI. Each agent runs a real CLI process; the harness adds memory, messaging, skills, and the orchestrator on top. Mixing engines on one floor is normal." } },
+ { "@type": "Question", "name": "Does it work properly on Windows?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — and if you tried before v0.4.4, try again. That release fixed the bug that silently broke agent-to-agent messaging on Windows, made first runs start their own hive services, and rebuilt dark mode. Windows is a first-class platform now, OpenCode included." } },
+ { "@type": "Question", "name": "Can I leave it running for hours or days?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — that's the point. With auto mode on, agents run unattended and Michael routes work and escalates only the critical calls to you. Give an agent a persistent Goal and it keeps working a long-horizon task across many prompts while you're away." } },
+ { "@type": "Question", "name": "Is auto mode safe?", "acceptedAnswer": { "@type": "Answer", "text": "Auto mode spawns agents without per-tool permission prompts, so they don't pause for file edits or shell commands. It's the right default for the unattended control-room experience, but it's a foot-gun on production repos. Keep it on for sandboxed or disposable working copies; turn it off (or per agent) when you want to babysit." } }
]
}
@@ -144,7 +144,7 @@
<a href="/blog/topics/guides/">Guides</a>
</nav>
<h1>How to Install and Use Munder Difflin</h1>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="byline">
<span class="av" aria-hidden="true">CG</span>
<strong>Chaitanya Giri</strong>
@@ -161,38 +161,44 @@
<div class="post-wrap wrap">
<div class="prose">
<div class="callout tldr"><span class="ic">TL;DR</span><p>Install <strong>Munder Difflin</strong> by
-downloading a build (macOS, Windows, or Linux) or running it from source with Node 18+. On first
-launch you'll pick a harness home, add your repos, and confirm auto mode. Then you talk to
-<strong>Michael</strong> — the <a href="/#how">GOD orchestrator</a> — spin up agents with a
-<strong>Goal</strong>, and let the hive work <strong>ambitious, long-horizon tasks for hours or
-days</strong> while you watch the floor.</p></div>
+downloading a build (macOS, Windows, or Linux) or running from source with Node 18+. Onboarding
+opens on the real pitch — <strong>a clone of you, working 24/7</strong> — validates your setup at
+step one, and the <strong>Prerequisites</strong> page shows live status for every tool an engine
+needs. Then you talk to <strong>Michael</strong>, spin up agents on any of <strong>ten
+engines</strong> with a <strong>Goal</strong>, hand them <strong>skills</strong>, and let the hive
+work <strong>long-horizon tasks for hours or days</strong> while you watch the floor.</p></div>
<p><em>Watch the 51-second setup walkthrough:</em>
<video controls preload="none" playsinline poster="/media/demo/setup-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;"><source src="/media/demo/setup.mp4" type="video/mp4" /></video></p>
-<p>Most tools help you run a Claude Code agent. Munder Difflin helps you run a <em>team</em> of them —
+<p>Most tools help you run one coding agent. Munder Difflin helps you run a <em>team</em> of them —
unattended, coordinated, and aimed at the big jobs: a multi-day refactor, a migration, an
-investigation that needs to grind overnight. This is the start-to-finish guide: install it, meet the
-orchestrator, and put the hive to work on something ambitious.</p>
+investigation that needs to grind overnight. This is the start-to-finish guide, current as of
+<strong>v0.4.4</strong>: install it, meet your clone, and put the hive to work on something ambitious.</p>
<h2 id="what-munder-difflin-does-best" tabindex="-1">What Munder Difflin does best <a class="anchor" href="#what-munder-difflin-does-best" aria-hidden="true">#</a></h2>
<p>Before the steps, the mental model — because it shapes how you’ll use it. Munder Difflin wraps the
-<a href="https://claude.com/claude-code">Claude Code</a> terminals you already run as full agents, gives each
-<strong>long-term memory</strong> and a <strong>mailbox</strong>, and puts a <strong>GOD orchestrator</strong> (named Michael) in charge —
-the one agent <em>you</em> talk to. You describe intent; it routes work, lets agents message each other, and
-escalates only the critical calls to you.</p>
+agent CLIs you already run as full agents, gives each <strong>long-term memory</strong> and a <strong>mailbox</strong>, and
+puts <strong>Michael</strong> in charge — a clone of you, the one agent <em>you</em> talk to. His card says <strong>BOSS</strong>:
+he’s the boss of the agents, you’re still the boss of him. You describe intent; he routes work,
+lets agents message each other, and escalates only the critical calls to you.</p>
<p>That design pays off most on <strong>long-horizon work</strong>. A single session loses steam (and context) on a
multi-hour task. A coordinated <a href="/blog/give-claude-code-long-term-memory/">hive that remembers</a> can
keep going for hours or days — the <a href="/blog/run-an-office-of-ai-agents/">overnight, while-you-sleep</a>
use case is exactly what it’s built for. Keep that in mind as you set it up.</p>
<h2 id="step-1-what-youll-need" tabindex="-1">Step 1: What you’ll need <a class="anchor" href="#step-1-what-youll-need" aria-hidden="true">#</a></h2>
<ul>
-<li><strong>Node.js 18+</strong> and npm.</li>
-<li>A <strong>C/C++ toolchain</strong> for <code>node-pty</code>’s native addon: Xcode Command Line Tools on macOS
-(<code>xcode-select --install</code>), <code>build-essential</code> on Linux, or the Visual Studio Build Tools on Windows.
-(If you download a prebuilt app instead of building from source, you don’t need the toolchain.)</li>
-<li><strong>Claude Code</strong> on your <code>PATH</code> — agents run the <code>claude</code> command by default. You bring your own
-Claude Code; Munder Difflin coordinates it.</li>
-<li><em>Optional:</em> the semantic memory index for instant cross-session recall. The app works without it —
-plain-markdown memory still functions and the index degrades gracefully.</li>
+<li><strong>At least one supported agent CLI</strong> on your <code>PATH</code>. Ten engines are first-class: <strong>Claude Code,
+Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI.</strong> Bring
+whichever subscriptions you already have — mixing engines on one floor is normal.</li>
+<li><strong>From source only:</strong> Node.js 18+ with npm, and a C/C++ toolchain for <code>node-pty</code>’s native addon
+(Xcode Command Line Tools on macOS, <code>build-essential</code> on Linux, VS Build Tools on Windows).
+Prebuilt apps need none of this.</li>
+<li><em>Optional:</em> <strong>MemPalace</strong>, the semantic memory index, for instant cross-session recall. The app
+works without it — plain-markdown memory still functions.</li>
</ul>
+<p>And here’s the v0.4.4 upgrade to this whole step: you don’t have to audit any of it by hand.
+<strong>Settings → Prerequisites</strong> shows live status for uv, git, Node, MemPalace and every engine —
+with real paths, the platform-correct install command for anything missing, and a button that
+asks Michael to fill the gaps for you.</p>
+<figure class="fig fig-inline"><img src="/blog/assets/media/how-to-install-and-use-munder-difflin/note-1.png" alt="Hand-drawn sketch from “How to Install and Use Munder Difflin”" loading="lazy" decoding="async" /><figcaption>The Prerequisites page does this checklist for you — live status, real paths, and Michael on standby to install what's missing.</figcaption></figure>
<h2 id="step-2-install-it" tabindex="-1">Step 2: Install it <a class="anchor" href="#step-2-install-it" aria-hidden="true">#</a></h2>
<p>There are two paths. Pick whichever fits you.</p>
<h3 id="option-a-download-a-build-easiest" tabindex="-1">Option A — Download a build (easiest) <a class="anchor" href="#option-a-download-a-build-easiest" aria-hidden="true">#</a></h3>
@@ -220,9 +226,14 @@ release):</p>
</tr>
</tbody>
</table>
-<p>Open the installer, launch the app, and skip to <a href="#step-3-first-launch-the-onboarding-wizard">first launch</a>.</p>
+<p>Open the installer, launch the app, and skip to <a href="#step-3-first-launch-the-onboarding-wizard">first launch</a>.
+From here the app maintains itself: updates download in the background from GitHub releases, the
+toast tells you what’s actually in them, and installation only ever happens on your click.
+(<strong>Settings → General</strong> also answers “am I on the latest?” with a single Check-for-updates button.)</p>
+<p>A word to Windows users specifically: <strong>v0.4.4 is the release that made Windows first-class.</strong>
+Agent-to-agent messaging, first-run hive services, the setup wizard, dark mode — all fixed. If an
+earlier version burned you, <a href="/blog/launching-munder-difflin-v0-4-4/">this one is owed to you</a>.</p>
<h3 id="option-b-build-from-source-two-commands" tabindex="-1">Option B — Build from source (two commands) <a class="anchor" href="#option-b-build-from-source-two-commands" aria-hidden="true">#</a></h3>
-<p>If you’d rather run the code directly (or you’re on a platform you want to build yourself):</p>
<pre class="language-bash"><code class="language-bash"><span class="token function">git</span> clone https://github.com/chaitanyagiri/munder-difflin.git
<span class="token builtin class-name">cd</span> munder-difflin
<span class="token function">npm</span> <span class="token function">install</span> <span class="token comment"># postinstall rebuilds node-pty against Electron's ABI</span>
@@ -230,148 +241,148 @@ release):</p>
<p>The <code>npm install</code> step rebuilds the native terminal addon for your machine. If <code>node-pty</code> ever fails
to load after an Electron upgrade, re-run <code>npm install</code> to rebuild it.</p>
<h2 id="step-3-first-launch-the-onboarding-wizard" tabindex="-1">Step 3: First launch — the onboarding wizard <a class="anchor" href="#step-3-first-launch-the-onboarding-wizard" aria-hidden="true">#</a></h2>
-<p>The first time you open Munder Difflin, a three-step wizard sets up your control room:</p>
+<p>First launch opens on what the product actually is — <strong>a clone of you, working 24/7</strong> — then asks
+the few questions that matter:</p>
<ol>
-<li><strong>Harness home.</strong> Pick a folder where the harness keeps its own files — agent metadata, logs, and
-any repos you create from inside the app. Something like <code>~/HarnessAgents</code> is a fine default; it’s
-created if it doesn’t exist. Think of it as the town hall: agent state is pinned here so sessions
-survive a restart.</li>
-<li><strong>Your repos.</strong> Add the existing project folders you want agents to work in. Each becomes a room on
-the floor, and multiple agents can share a repo. This is optional and you can add more later — but
-adding your main project now saves a step.</li>
-<li><strong>Auto mode.</strong> Confirm whether agents should run unattended (covered next). The default is on.</li>
+<li><strong>Your clone’s engine.</strong> Michael runs on a pluggable engine; the card names all ten. Claude
+Code is the natural default, and you can change it later.</li>
+<li><strong>Harness home.</strong> A folder where the harness keeps its own files — agent metadata, memory,
+mailboxes, logs. <code>~/HarnessAgents</code> is a fine default. The wizard validates this immediately:
+an empty or impossible folder fails at step one, not after step four.</li>
+<li><strong>Your repos.</strong> Add the project folders you want agents to work in. Each becomes a room on the
+floor; multiple agents can share a repo. Optional, and you can add more later.</li>
+<li><strong>Auto mode.</strong> Confirm whether agents run unattended (covered next). There’s also a “share
+anonymous usage stats” toggle — opt-out, governed by a
+<a href="https://github.com/chaitanyagiri/munder-difflin/blob/main/TELEMETRY.md">public contract</a>.</li>
</ol>
-<p>Finish the wizard and you land on the office floor. Michael — your orchestrator — boots into his
-office automatically; give him a few seconds to clock in.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/how-to-install-and-use-munder-difflin/note-1.png" alt="Hand-drawn sketch from “How to Install and Use Munder Difflin”" loading="lazy" decoding="async" /></figure>
-<h2 id="step-4-meet-michael-your-god-orchestrator" tabindex="-1">Step 4: Meet Michael, your GOD orchestrator <a class="anchor" href="#step-4-meet-michael-your-god-orchestrator" aria-hidden="true">#</a></h2>
-<p>Michael is the <strong>GOD agent</strong>: he runs the floor, triages requests, assigns work, and escalates only
-the critical calls to you. He’s the agent you talk to.</p>
+<p>Finish the wizard and you land on the office floor. Michael boots into his office automatically —
+and everything the hive needs (message router, hook server, mission scheduler) starts with him,
+on the very first run.</p>
+<h2 id="step-4-meet-michael-your-clone" tabindex="-1">Step 4: Meet Michael, your clone <a class="anchor" href="#step-4-meet-michael-your-clone" aria-hidden="true">#</a></h2>
+<p>Michael runs the floor: he triages requests, assigns work, and escalates only the critical calls
+to you. He’s the agent you talk to.</p>
<p>To talk to any agent (Michael included), select them on the floor to open their panel, then use the
-<strong>command bar</strong> at the bottom — type a message and hit Enter (or <em>send</em>). The bar has three modes:</p>
+<strong>command bar</strong> at the bottom — type a message and hit Enter. The bar has three modes:</p>
<ul>
<li><strong>free</strong> — plain natural-language instructions (the default).</li>
-<li><strong>/skill</strong> — invoke a Claude Code skill or slash command.</li>
+<li><strong>/skill</strong> — invoke an installed skill or slash command.</li>
<li><strong>quick</strong> — fast canned actions.</li>
</ul>
<p>Talking to Michael in plain language is how you steer the whole team: describe a goal, and he
-decomposes and routes it. That’s the <a href="/#how">orchestration model</a> in practice — you manage, he
-delegates. (New to the idea? <a href="/blog/how-to-run-multiple-claude-code-agents/">How to run multiple Claude Code
-agents</a> covers why an orchestrator beats juggling tabs.)</p>
+decomposes and routes it. You manage, he delegates. He also listens — his voice mode opens with a
+live floor snapshot and can run nearly the whole app hands-free. (New to the idea? <a href="/blog/how-to-run-multiple-claude-code-agents/">How to run
+multiple Claude Code agents</a> covers why an
+orchestrator beats juggling tabs.)</p>
<h2 id="step-5-understand-auto-mode" tabindex="-1">Step 5: Understand auto mode <a class="anchor" href="#step-5-understand-auto-mode" aria-hidden="true">#</a></h2>
-<p>Auto mode is what makes unattended runs possible. With it on, every agent is spawned with:</p>
+<p>Auto mode is what makes unattended runs possible. With it on, agents are spawned with their
+engine’s permission prompts bypassed — Claude Code, for instance, runs as:</p>
<pre class="language-text"><code class="language-text">claude --permission-mode bypassPermissions</code></pre>
-<p>That means Claude won’t stop to ask before editing files or running shell commands — essential for a
-“set it going and walk away” workflow. It’s also a loaded foot-gun on a production repo, so:</p>
+<p>That means the agent won’t stop to ask before editing files or running shell commands — essential
+for a “set it going and walk away” workflow. It’s also a loaded foot-gun on a production repo, so:</p>
<ul>
<li><strong>Keep auto mode on</strong> for sandboxed, disposable, or branch-isolated working copies — anywhere a
-mistake is cheap to undo. This is the right default for the control-room experience.</li>
-<li><strong>Turn it off</strong> (or drop the flag for a single agent in the Add Agent dialog) when you want to
-babysit a sensitive repo and approve each tool call.</li>
+mistake is cheap to undo.</li>
+<li><strong>Turn it off</strong> (or drop it for a single agent in the Add Agent dialog) when you want to babysit
+a sensitive repo and approve each tool call.</li>
</ul>
-<p>Either way, Munder Difflin keeps a <strong>human-in-the-loop approvals queue</strong>: even in auto mode, the GOD
-agent escalates genuinely critical actions (spending real money, destructive operations, big scope
-changes) for your sign-off, so unattended doesn’t mean unsupervised.</p>
+<p>Either way, Munder Difflin keeps a <strong>human-in-the-loop approvals queue</strong>: even in auto mode,
+Michael escalates genuinely critical actions (spending real money, destructive operations, big
+scope changes) for your sign-off, so unattended doesn’t mean unsupervised.</p>
<h2 id="step-6-spin-up-your-first-agent" tabindex="-1">Step 6: Spin up your first agent <a class="anchor" href="#step-6-spin-up-your-first-agent" aria-hidden="true">#</a></h2>
<p>Click <strong>Add agent</strong> to open the spawn dialog. The fields:</p>
<ul>
<li><strong>Name</strong> — the agent’s handle (picking a character fills this in for you).</li>
-<li><strong>Folder</strong> — the working directory. Pick one of your registered repos with a click, or browse to
-another.</li>
-<li><strong>Command</strong> — defaults to <code>claude</code> (plus <code>--permission-mode bypassPermissions</code> in auto mode). Pick a
-<strong>model</strong> above (Sonnet, Opus, Haiku, or CLI default) — the harness restarts the agent on the new
-model if you change it later.</li>
+<li><strong>Folder</strong> — the working directory. Pick a registered repo with a click, or browse.</li>
+<li><strong>Engine &amp; model</strong> — any of the ten engines, with a model picker per engine (Grok 4.6 landed in
+v0.4.4). The harness restarts the agent on the new model if you change it later.</li>
<li><strong>Description</strong> — a short note on what this agent is for.</li>
-<li><strong>Goal (optional)</strong> — <em>a long-running directive injected on every prompt.</em> This is the most
-important field for long tasks (more below).</li>
+<li><strong>Goal (optional)</strong> — <em>a long-running directive injected on every prompt.</em> The most important
+field for long tasks (more below).</li>
<li><strong>Character &amp; Color</strong> — pick from the office cast and an accent.</li>
-<li><strong>Git isolation (optional)</strong> — checking ‘Git isolation (own worktree)’ auto-creates a dedicated git
-checkout for this agent and tears it down when you kill it. Use this whenever two agents share the
-same repo so they work on separate branches without colliding.</li>
+<li><strong>Git isolation (optional)</strong> — auto-creates a dedicated git worktree for this agent and tears it
+down when you kill it. Use it whenever two agents share a repo.</li>
</ul>
-<p>Hit <strong>spawn</strong>. The agent appears as an avatar at a desk, provisioned in the hive with its own memory,
-mailbox, and identity. You’ll see it walk to a station and start working; envelopes fly desk-to-desk
-when agents message each other.</p>
-<h2 id="step-7-run-an-ambitious-long-horizon-task" tabindex="-1">Step 7: Run an ambitious, long-horizon task <a class="anchor" href="#step-7-run-an-ambitious-long-horizon-task" aria-hidden="true">#</a></h2>
+<p>Hit <strong>spawn</strong>. The agent appears as an avatar at a desk, provisioned in the hive with its own
+memory, mailbox, and identity. Envelopes fly desk-to-desk when agents message each other.</p>
+<figure class="fig fig-inline"><img src="/blog/assets/media/how-to-install-and-use-munder-difflin/note-2.png" alt="Hand-drawn sketch from “How to Install and Use Munder Difflin”" loading="lazy" decoding="async" /><figcaption>One dialog, one new hire: engine, model, goal, character — and a desk appears on the floor.</figcaption></figure>
+<h2 id="step-7-give-your-agents-skills" tabindex="-1">Step 7: Give your agents skills <a class="anchor" href="#step-7-give-your-agents-skills" aria-hidden="true">#</a></h2>
+<p>Before the big task, arm the team. <strong>Skills</strong> (new in v0.4.4) is a browsable catalog of hundreds
+of installable skills — search, category and publisher filters, one-click install across Claude
+Code, OpenCode and Codex, with scope precedence handled and uninstall guarded. A reviewer with a
+review checklist beats a generalist told to “review carefully”; a writer with your style guide
+beats one guessing at your voice. (<a href="/blog/mcp-and-skills-in-a-hive/">MCP and skills in a hive</a>
+covers when skills beat tools.)</p>
+<h2 id="step-8-run-an-ambitious-long-horizon-task" tabindex="-1">Step 8: Run an ambitious, long-horizon task <a class="anchor" href="#step-8-run-an-ambitious-long-horizon-task" aria-hidden="true">#</a></h2>
<p>Here’s where Munder Difflin earns its keep. To set a team working for hours or days:</p>
<ol>
<li><strong>Give agents a persistent Goal.</strong> The <em>Goal</em> field is injected into every prompt, so the agent
-keeps orienting toward the same long-running directive even as the conversation turns over. This is
-how a task survives across many cycles instead of drifting. Write it like a brief: <em>“Migrate the
-test suite from Mocha to Vitest, one directory at a time, keeping CI green after each.”</em></li>
-<li><strong>Let Michael route the rest.</strong> Tell the GOD orchestrator the high-level objective and let him
-assign sub-tasks across agents. You describe the <em>what</em>; the hive figures out the <em>who</em> and <em>when</em>.</li>
-<li><strong>Scope each agent and let them coordinate.</strong> Give each a clear role so they stay in their lane and
-hand off through mailboxes instead of colliding. Shared
-<a href="/blog/give-claude-code-long-term-memory/">long-term memory</a> means what one agent learns, the next
-one inherits — knowledge compounds over a long run.</li>
-<li><strong>Walk away.</strong> With auto mode on, the team keeps going unattended. Check the approvals queue when
-you’re back; the GOD agent only interrupts you for the critical calls.</li>
+keeps orienting toward the same directive even as the conversation turns over. Write it like a
+brief: <em>“Migrate the test suite from Mocha to Vitest, one directory at a time, keeping CI green
+after each.”</em></li>
+<li><strong>Let Michael route the rest.</strong> Tell him the high-level objective and let him assign sub-tasks.
+You describe the <em>what</em>; the hive figures out the <em>who</em> and <em>when</em>.</li>
+<li><strong>Scope each agent and let them coordinate.</strong> Clear roles, handoffs through mailboxes, and
+shared <a href="/blog/give-claude-code-long-term-memory/">long-term memory</a> so what one agent learns,
+the next inherits.</li>
+<li><strong>Walk away.</strong> With auto mode on, the team keeps going unattended. Check the approvals queue
+when you’re back; Michael only interrupts you for the critical calls.</li>
</ol>
-<p>This is the <a href="/blog/run-an-office-of-ai-agents/">run-an-office-of-agents-while-you-sleep</a> workflow, and
-the practical guardrails behind it are in <a href="/blog/claude-code-automation-while-you-sleep/">Claude Code automation while you
-sleep</a>. Be honest with yourself about scope — bounded,
+<p>This is the <a href="/blog/run-an-office-of-ai-agents/">run-an-office-while-you-sleep</a> workflow, and the
+practical guardrails are in <a href="/blog/claude-code-automation-while-you-sleep/">Claude Code automation while you
+sleep</a>. Be honest about scope — bounded,
well-specified jobs go best.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/how-to-install-and-use-munder-difflin/note-2.png" alt="Hand-drawn sketch from “How to Install and Use Munder Difflin”" loading="lazy" decoding="async" /></figure>
-<h2 id="step-8-use-michaels-command-center" tabindex="-1">Step 8: Use Michael’s Command Center <a class="anchor" href="#step-8-use-michaels-command-center" aria-hidden="true">#</a></h2>
-<p>Select Michael on the floor and open his panel — it’s not a plain terminal. It’s a control surface
-with six tabs:</p>
+<h2 id="step-9-use-michaels-command-center" tabindex="-1">Step 9: Use Michael’s Command Center <a class="anchor" href="#step-9-use-michaels-command-center" aria-hidden="true">#</a></h2>
+<p>Select Michael on the floor and open his panel — a control surface, not a plain terminal:</p>
<ul>
-<li><strong>Terminal</strong> — Michael’s live session, plus a message queue so you can park tasks while he’s working.</li>
-<li><strong>Floor</strong> — the full agent roster with per-agent model selectors, a dispatch box (send a task to one
-agent or broadcast to all), and your registered repos. The <strong>Enrich</strong> toggle routes your queued
-messages through Dwight — a background prep assistant who gathers context and rewrites the prompt
-before Michael sees it.</li>
-<li><strong>Memory</strong> — MemPalace semantic search plus full-text search across all hive files (board, tasks,
-agent memories) and a memory graph.</li>
-<li><strong>Activity</strong> — live event log, the shared board, and real token + cost telemetry per agent (read
-directly from your Claude Code transcript files).</li>
-<li><strong>Tasks</strong> — a dependency-aware kanban board. Add tasks with assignees, priorities, and <code>dependsOn</code>
-links; Michael and his team track status here.</li>
-<li><strong>Triggers</strong> — every way the office wakes itself, starting with recurring missions. Set a label, interval (1h / 6h / 24h / weekly), and a directive
-body; the harness dispatches it to the target agent automatically, no human needed.</li>
+<li><strong>Terminal</strong> — Michael’s live session, plus a message queue so you can park tasks while he works.</li>
+<li><strong>Floor</strong> — the full agent roster with per-agent model selectors, a dispatch box, and your
+registered repos. The <strong>Enrich</strong> toggle routes queued messages through a background prep
+assistant who gathers context before Michael sees them.</li>
+<li><strong>Memory</strong> — MemPalace semantic search plus full-text search across all hive files, and a
+memory graph.</li>
+<li><strong>Activity</strong> — live event log, the shared board, and real token + cost telemetry per agent.</li>
+<li><strong>Tasks</strong> — a dependency-aware kanban board Michael and his team track status on.</li>
+<li><strong>Triggers</strong> — every way the office wakes itself: recurring missions with a label, interval,
+and directive body, dispatched to the target agent automatically.</li>
</ul>
-<p>For long-running floors, the Triggers tab is the most powerful: set a ‘30-minute floor check’ mission
-pointing at Michael with a directive like ‘Are all agents making progress? Re-engage anyone idle.’ —
-and the harness keeps the team moving even when you’re away.</p>
+<p>For long-running floors, Triggers is the most powerful tab: a “30-minute floor check” mission
+pointed at Michael — <em>“Are all agents making progress? Re-engage anyone idle.”</em> — keeps the team
+moving even when you’re away.</p>
<h2 id="tips-for-best-results" tabindex="-1">Tips for best results <a class="anchor" href="#tips-for-best-results" aria-hidden="true">#</a></h2>
<ul>
-<li><strong>Scope beats ambition.</strong> A precise Goal (“do X, in this order, with this definition of done”) runs
-longer and cleaner than a vague one.</li>
-<li><strong>Use branch-isolated working copies.</strong> Auto mode plus a throwaway branch is cheap to discard — and
-the ‘Git isolation’ checkbox in Add Agent automates this: each agent gets its own worktree
-provisioned and torn down for you.</li>
-<li><strong>Register your repos.</strong> Pre-adding projects in onboarding (or later) makes spawning agents one
-click instead of a folder hunt.</li>
-<li><strong>Lean on memory.</strong> Tell agents to write durable facts to their notes; the shared semantic palace
-turns those into instant recall for the whole hive.</li>
-<li><strong>Watch the floor early.</strong> The visual office isn’t a gimmick — seeing who’s busy, idle, or blocked
-catches problems before they compound.</li>
+<li><strong>Scope beats ambition.</strong> A precise Goal runs longer and cleaner than a vague one.</li>
+<li><strong>Use git isolation.</strong> Auto mode plus per-agent worktrees means mistakes are cheap and agents
+never collide on branches.</li>
+<li><strong>Register your repos.</strong> Pre-adding projects makes spawning agents one click.</li>
+<li><strong>Lean on memory.</strong> Tell agents to write durable facts to their notes; the shared semantic
+palace turns those into instant recall for the whole hive.</li>
+<li><strong>Watch the floor early.</strong> Seeing who’s busy, idle, or blocked catches problems before they
+compound — fullscreen roster cards even show each agent’s live context gauge.</li>
</ul>
<h2 id="troubleshooting" tabindex="-1">Troubleshooting <a class="anchor" href="#troubleshooting" aria-hidden="true">#</a></h2>
<ul>
-<li><strong><code>node-pty</code> fails to load after an update</strong> → re-run <code>npm install</code> (the postinstall rebuilds the
-native addon against the current Electron ABI).</li>
-<li><strong>Agents won’t start / “claude: command not found”</strong> → make sure Claude Code is installed and on the
-<code>PATH</code> of the shell that launched the app.</li>
-<li><strong>Native build errors on <code>npm install</code></strong> → install your platform’s C/C++ toolchain (Xcode Command
-Line Tools, <code>build-essential</code>, or VS Build Tools), then reinstall.</li>
-<li><strong>No instant recall</strong> → the semantic memory index is optional; without it, markdown memory still
-works, just without the fast semantic search.</li>
+<li><strong><code>node-pty</code> fails to load after an update</strong> (source builds) → re-run <code>npm install</code>.</li>
+<li><strong>Agents won’t start / “command not found”</strong> → open <strong>Settings → Prerequisites</strong>; it shows
+which engine binaries the app can actually see, with install commands for the missing ones.</li>
+<li><strong>Native build errors on <code>npm install</code></strong> → install your platform’s C/C++ toolchain, reinstall.</li>
+<li><strong>No instant recall</strong> → MemPalace is optional; without it, markdown memory still works, just
+without fast semantic search.</li>
+<li><strong>On Windows and something’s off?</strong> Make sure you’re on v0.4.4 or later — it’s the release
+that fixed agent messaging, first-run services, and the wizard on Windows.</li>
</ul>
<h2 id="where-to-go-next" tabindex="-1">Where to go next <a class="anchor" href="#where-to-go-next" aria-hidden="true">#</a></h2>
<ul>
-<li><a href="/blog/how-to-run-multiple-claude-code-agents/">How to run multiple Claude Code agents</a> — the habits
-that keep a team from colliding.</li>
-<li><a href="/blog/run-an-office-of-ai-agents/">Run an office of AI agents while you sleep</a> — the long-horizon
-vision, with guardrails.</li>
-<li><a href="/blog/what-is-a-multi-agent-harness/">What is a multi-agent harness?</a> — the concept underneath it
-all.</li>
+<li><a href="/blog/your-first-hour-with-munder-difflin/">Your first hour with Munder Difflin</a> — the
+minute-by-minute version of everything above.</li>
+<li><a href="/blog/how-to-run-multiple-claude-code-agents/">How to run multiple Claude Code agents</a> — the
+habits that keep a team from colliding.</li>
+<li><a href="/blog/run-an-office-of-ai-agents/">Run an office of AI agents while you sleep</a> — the
+long-horizon vision, with guardrails.</li>
</ul>
<hr>
-<p>That’s the whole path from zero to a working hive. <a href="/#install">Download Munder Difflin</a> — it’s free,
-open source, and local-first on macOS, Windows, and Linux — and put a team of agents on your next big
-task.</p>
+<p>That’s the whole path from zero to a working hive. <a href="/#install">Download Munder Difflin</a> — free,
+open source, and local-first on macOS, Windows, and Linux — and put a team of agents on your next
+big task.</p>
@@ -380,27 +391,27 @@ task.</p>
<div class="qa">
<p class="q">Is Munder Difflin free?</p>
- <p class="a">Yes. Munder Difflin is free and open source under the MIT license. Download a build for macOS, Windows, or Linux, or run it from source — there&#39;s no paid tier.</p>
+ <p class="a">Yes. Munder Difflin is free and open source under the MIT license. Download a build for macOS, Windows, or Linux, or run it from source — and once installed, the app keeps itself up to date from GitHub releases, telling you what&#39;s in each update before you restart into it.</p>
</div>
<div class="qa">
<p class="q">Do I need Claude Code to use Munder Difflin?</p>
- <p class="a">Yes. Munder Difflin coordinates real Claude Code sessions, so you bring your own Claude Code (the `claude` CLI on your PATH). Each agent runs a real `claude` process; the harness adds memory, messaging, and the GOD orchestrator on top.</p>
+ <p class="a">No — you need at least one supported engine, and Claude Code is the most popular of ten: Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI. Each agent runs a real CLI process; the harness adds memory, messaging, skills, and the orchestrator on top. Mixing engines on one floor is normal.</p>
</div>
<div class="qa">
- <p class="q">Can I leave it running for hours or days?</p>
- <p class="a">Yes — that&#39;s the point. With auto mode on, agents run unattended and a GOD orchestrator routes work and escalates only the critical calls to you. Give an agent a persistent Goal and it keeps working a long-horizon task across many prompts while you&#39;re away.</p>
+ <p class="q">Does it work properly on Windows?</p>
+ <p class="a">Yes — and if you tried before v0.4.4, try again. That release fixed the bug that silently broke agent-to-agent messaging on Windows, made first runs start their own hive services, and rebuilt dark mode. Windows is a first-class platform now, OpenCode included.</p>
</div>
<div class="qa">
- <p class="q">What platforms does it support?</p>
- <p class="a">macOS, Windows, and Linux. Grab the matching installer (.dmg, .exe, or .AppImage) from the latest release, or build from source with Node 18+ in two commands.</p>
+ <p class="q">Can I leave it running for hours or days?</p>
+ <p class="a">Yes — that&#39;s the point. With auto mode on, agents run unattended and Michael routes work and escalates only the critical calls to you. Give an agent a persistent Goal and it keeps working a long-horizon task across many prompts while you&#39;re away.</p>
</div>
<div class="qa">
<p class="q">Is auto mode safe?</p>
- <p class="a">Auto mode spawns agents with `--permission-mode bypassPermissions`, so they don&#39;t pause for file edits or shell commands. It&#39;s the right default for the unattended control-room experience, but it&#39;s a foot-gun on production repos. Keep it on for sandboxed or disposable working copies; turn it off (or drop the flag per agent) when you want to babysit.</p>
+ <p class="a">Auto mode spawns agents without per-tool permission prompts, so they don&#39;t pause for file edits or shell commands. It&#39;s the right default for the unattended control-room experience, but it&#39;s a foot-gun on production repos. Keep it on for sandboxed or disposable working copies; turn it off (or per agent) when you want to babysit.</p>
</div>
</section>
@@ -419,7 +430,7 @@ task.</p>
<aside class="toc-rail" aria-label="Table of contents">
<div class="tt">On this page</div>
<ol>
- <li class="lvl-2"><a href="#what-munder-difflin-does-best">What Munder Difflin does best</a></li><li class="lvl-2"><a href="#step-1-what-youll-need">Step 1: What you’ll need</a></li><li class="lvl-2"><a href="#step-2-install-it">Step 2: Install it</a></li><li class="lvl-3"><a href="#option-a-download-a-build-easiest">Option A — Download a build (easiest)</a></li><li class="lvl-3"><a href="#option-b-build-from-source-two-commands">Option B — Build from source (two commands)</a></li><li class="lvl-2"><a href="#step-3-first-launch-the-onboarding-wizard">Step 3: First launch — the onboarding wizard</a></li><li class="lvl-2"><a href="#step-4-meet-michael-your-god-orchestrator">Step 4: Meet Michael, your GOD orchestrator</a></li><li class="lvl-2"><a href="#step-5-understand-auto-mode">Step 5: Understand auto mode</a></li><li class="lvl-2"><a href="#step-6-spin-up-your-first-agent">Step 6: Spin up your first agent</a></li><li class="lvl-2"><a href="#step-7-run-an-ambitious-long-horizon-task">Step 7: Run an ambitious, long-horizon task</a></li><li class="lvl-2"><a href="#step-8-use-michaels-command-center">Step 8: Use Michael’s Command Center</a></li><li class="lvl-2"><a href="#tips-for-best-results">Tips for best results</a></li><li class="lvl-2"><a href="#troubleshooting">Troubleshooting</a></li><li class="lvl-2"><a href="#where-to-go-next">Where to go next</a></li>
+ <li class="lvl-2"><a href="#what-munder-difflin-does-best">What Munder Difflin does best</a></li><li class="lvl-2"><a href="#step-1-what-youll-need">Step 1: What you’ll need</a></li><li class="lvl-2"><a href="#step-2-install-it">Step 2: Install it</a></li><li class="lvl-3"><a href="#option-a-download-a-build-easiest">Option A — Download a build (easiest)</a></li><li class="lvl-3"><a href="#option-b-build-from-source-two-commands">Option B — Build from source (two commands)</a></li><li class="lvl-2"><a href="#step-3-first-launch-the-onboarding-wizard">Step 3: First launch — the onboarding wizard</a></li><li class="lvl-2"><a href="#step-4-meet-michael-your-clone">Step 4: Meet Michael, your clone</a></li><li class="lvl-2"><a href="#step-5-understand-auto-mode">Step 5: Understand auto mode</a></li><li class="lvl-2"><a href="#step-6-spin-up-your-first-agent">Step 6: Spin up your first agent</a></li><li class="lvl-2"><a href="#step-7-give-your-agents-skills">Step 7: Give your agents skills</a></li><li class="lvl-2"><a href="#step-8-run-an-ambitious-long-horizon-task">Step 8: Run an ambitious, long-horizon task</a></li><li class="lvl-2"><a href="#step-9-use-michaels-command-center">Step 9: Use Michael’s Command Center</a></li><li class="lvl-2"><a href="#tips-for-best-results">Tips for best results</a></li><li class="lvl-2"><a href="#troubleshooting">Troubleshooting</a></li><li class="lvl-2"><a href="#where-to-go-next">Where to go next</a></li>
</ol>
</aside>
diff --git a/docs/blog/human-in-the-loop-ai-agents/index.html b/docs/blog/human-in-the-loop-ai-agents/index.html
index 982aa966..0363df42 100644
--- a/docs/blog/human-in-the-loop-ai-agents/index.html
+++ b/docs/blog/human-in-the-loop-ai-agents/index.html
@@ -310,7 +310,7 @@ and ask only when they should; it’s free and open source.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/index.html b/docs/blog/index.html
index 4582f2cd..84c9b57b 100644
--- a/docs/blog/index.html
+++ b/docs/blog/index.html
@@ -621,10 +621,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
@@ -672,7 +672,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
@@ -752,7 +752,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
@@ -765,7 +765,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
@@ -992,7 +992,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/local-first-ai-agent-orchestration/index.html b/docs/blog/local-first-ai-agent-orchestration/index.html
index 5aaf1d1d..a365e13d 100644
--- a/docs/blog/local-first-ai-agent-orchestration/index.html
+++ b/docs/blog/local-first-ai-agent-orchestration/index.html
@@ -317,7 +317,7 @@ loop; it’s free and open source.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/multi-agent-orchestration-patterns/index.html b/docs/blog/multi-agent-orchestration-patterns/index.html
index 204852e9..d0f219a1 100644
--- a/docs/blog/multi-agent-orchestration-patterns/index.html
+++ b/docs/blog/multi-agent-orchestration-patterns/index.html
@@ -315,7 +315,7 @@ across a team you can actually see? You can <a href="/#install">download Munder
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/run-munder-difflin-on-open-models/index.html b/docs/blog/run-munder-difflin-on-open-models/index.html
index 581149d6..eb9a8a6f 100644
--- a/docs/blog/run-munder-difflin-on-open-models/index.html
+++ b/docs/blog/run-munder-difflin-on-open-models/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines." />
+<meta name="description" content="Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4." />
<link rel="canonical" href="https://munderdiffl.in/blog/run-munder-difflin-on-open-models/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines." />
+<meta property="og:description" content="Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4." />
<meta property="og:url" content="https://munderdiffl.in/blog/run-munder-difflin-on-open-models/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -31,7 +31,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines." />
+<meta name="twitter:description" content="Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -45,10 +45,10 @@
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider",
- "description": "Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.",
+ "description": "Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker's own CLI. Here's the wiring, current as of v0.4.4.",
"image": ["https://munderdiffl.in/media/og.png"],
"datePublished": "2026-06-22T00:00:00.000Z",
- "dateModified": "2026-06-22T00:00:00.000Z",
+ "dateModified": "2026-08-20T00:00:00.000Z",
"author": { "@type": "Person", "name": "Chaitanya Giri" },
"publisher": {
"@type": "Organization",
@@ -56,7 +56,7 @@
"logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
},
"mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/run-munder-difflin-on-open-models/" },
- "keywords": "run ai agents on open source models, local llm coding agent, ollama coding agent, openrouter coding agent, gpt-oss, byok open models, opencode crush pi",
+ "keywords": "run ai agents on open source models, local llm coding agent, ollama coding agent, openrouter coding agent, gpt-oss, byok open models, opencode crush pi, qwen cli agent",
"articleSection": "Guides",
"inLanguage": "en-US",
"url": "https://munderdiffl.in/blog/run-munder-difflin-on-open-models/"
@@ -79,10 +79,10 @@
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
- { "@type": "Question", "name": "Can Munder Difflin run entirely on open-source models?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. As of v0.3.1 the OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models. You can run every agent — workers and the god orchestrator — on open-weight models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi, either fully local on your own hardware or through a third-party OSS provider with your own API key." } },
+ { "@type": "Question", "name": "Can Munder Difflin run entirely on open-source models?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models, and the Qwen and Kimi CLIs are first-class engines whose flagship models are open-weight. You can run every agent — workers and Michael himself — on open models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi: fully local on your own hardware, or through a third-party OSS provider with your own API key." } },
{ "@type": "Question", "name": "What's the difference between running local and using a third-party provider?", "acceptedAnswer": { "@type": "Answer", "text": "Local (Ollama, LM Studio, vLLM) runs the weights on your own machine — fully private, no per-token bill, but bounded by your RAM and GPU. A third-party OSS provider (OpenRouter, Groq, Together, Fireworks, DeepInfra) hosts the same open weights on their hardware and you pay per token with your own key — no local hardware limit, so you can reach the 100B–1T-parameter frontier models a laptop can't hold." } },
- { "@type": "Question", "name": "Which open model should I pick for the god orchestrator?", "acceptedAnswer": { "@type": "Answer", "text": "The god seat does the reasoning and long-context coordination, so give it a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration." } },
- { "@type": "Question", "name": "Do I need a different model id for each engine?", "acceptedAnswer": { "@type": "Answer", "text": "No — the upstream model id is the same. All three engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/<id> while Crush and pi use ollama/<id>." } }
+ { "@type": "Question", "name": "Which open model should I pick for the orchestrator seat?", "acceptedAnswer": { "@type": "Answer", "text": "Michael does the reasoning and long-context coordination, so give him a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration." } },
+ { "@type": "Question", "name": "Do I need a different model id for each engine?", "acceptedAnswer": { "@type": "Answer", "text": "No — the upstream model id is the same. All three BYOK engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/<id> while Crush uses ollama/<id>." } }
]
}
@@ -142,7 +142,7 @@
<a href="/blog/topics/guides/">Guides</a>
</nav>
<h1>Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</h1>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="byline">
<span class="av" aria-hidden="true">CG</span>
<strong>Chaitanya Giri</strong>
@@ -158,9 +158,9 @@
<div class="post-wrap wrap">
<div class="prose">
- <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin v0.3.1 runs entirely on open models.</strong> The three new engines — <strong>OpenCode</strong>, <strong>Crush</strong>, and <strong>pi</strong> — all support bring-your-own-key and local LLMs, for workers <em>and</em> the god orchestrator. Two routes: <strong>fully local</strong> (Ollama / LM Studio / vLLM on your own machine — private, no per-token bill, bounded by RAM) or a <strong>third-party OSS provider</strong> (OpenRouter, Groq, Together, Fireworks, DeepInfra — their hardware, your key, reaching frontier 100B–1T models a laptop can't hold). Every engine uses a <code>provider/model</code> slug; you set keys and local base-URLs in <strong>Settings → AI Engines</strong>, then pick the model in the Add-Agent modal.</p></div>
-<p>Munder Difflin started as a harness for the closed frontier CLIs — Claude Code, Codex, Antigravity. Useful, but it tied your agent floor to a handful of vendors and their pricing. <strong>v0.3.1 breaks that open.</strong> It adds three engines that were built, from the start, to point at <em>any</em> model: <a href="https://opencode.ai">OpenCode</a>, <a href="https://charm.land">Crush</a>, and <a href="https://pi.dev">pi</a>. All three speak the open-weight ecosystem — and that means you can run an entire office of agents on models whose weights are public.</p>
-<p>There are two honest ways to do that, and they trade off differently. This guide walks both, then shows the exact wiring for each engine. (For the why-bother, see <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters for AI agents</a> and <a href="/blog/why-cli-agents-are-powerful/">why CLI agents are so powerful</a>.)</p>
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin runs entirely on open models.</strong> Three routes: <strong>fully local</strong> (Ollama / LM Studio / vLLM on your own machine — private, no per-token bill, bounded by RAM), a <strong>third-party OSS provider</strong> (OpenRouter, Groq, Together, Fireworks, DeepInfra — their hardware, your key, reaching frontier 100B–1T models a laptop can't hold), or the <strong>model-maker's own CLI</strong> — the Qwen and Kimi engines are first-class hires whose flagship models are open-weight. The BYOK engines (<strong>OpenCode</strong>, <strong>Crush</strong>, <strong>pi</strong>) all use a <code>provider/model</code> slug; keys and local base-URLs live in <strong>Settings → AI Engines</strong>, and <strong>Settings → Prerequisites</strong> tells you which engine binaries the app can actually see.</p></div>
+<p>Munder Difflin started as a harness for the closed frontier CLIs — Claude Code, Codex, Antigravity. Useful, but it tied your agent floor to a handful of vendors and their pricing. That’s long since broken open: of the <strong>ten engines</strong> the app now ships — Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI — three (<a href="https://opencode.ai">OpenCode</a>, <a href="https://charm.land">Crush</a>, <a href="https://pi.dev">pi</a>) were built from the start to point at <em>any</em> model, and two more (Qwen, Kimi) are the model-makers’ own CLIs for families whose weights are public.</p>
+<p>That means you can run an entire office of agents on models anyone can download. There are two honest ways to do it, and they trade off differently. This guide walks both, then shows the exact wiring for each engine — current as of <strong>v0.4.4</strong>. (For the why-bother, see <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters for AI agents</a> and <a href="/blog/why-cli-agents-are-powerful/">why CLI agents are so powerful</a>.)</p>
<h2 id="two-routes-your-hardware-or-someone-elses" tabindex="-1">Two routes: your hardware, or someone else’s <a class="anchor" href="#two-routes-your-hardware-or-someone-elses" aria-hidden="true">#</a></h2>
<p>“Open source models” is one phrase covering two very different setups. Pick by what you’re optimizing for.</p>
<table>
@@ -204,11 +204,12 @@
</tr>
</tbody>
</table>
-<p>You don’t have to choose globally — Munder Difflin sets the engine and model <em>per agent</em>. A common pattern: a strong provider-hosted model in the god seat for orchestration, and cheap local workers for the routine majority. That’s exactly the <a href="/blog/do-more-with-less-model-routing/">capability-routing</a> idea, now with open weights on both ends.</p>
-<h2 id="how-the-three-engines-name-a-model" tabindex="-1">How the three engines name a model <a class="anchor" href="#how-the-three-engines-name-a-model" aria-hidden="true">#</a></h2>
-<p>One thing to internalize before any wiring: <strong>all three engines use the same <code>provider/model</code> slug form.</strong> The <em>model</em> part is just the upstream’s id (e.g. <code>openai/gpt-oss-120b</code>, <code>qwen3:30b-a3b</code>). The <em>provider</em> prefix resolves one of two ways:</p>
+<p>You don’t have to choose globally — Munder Difflin sets the engine and model <em>per agent</em>. A common pattern: a strong provider-hosted model in the orchestrator seat, and cheap local workers for the routine majority. That’s exactly the <a href="/blog/do-more-with-less-model-routing/">capability-routing</a> idea, now with open weights on both ends.</p>
+<p>And route three, for the least wiring of all: <strong>hire the model-maker’s own CLI.</strong> The Qwen and Kimi engines are first-class in the Add-Agent dialog — their vendor CLIs, their auth, no slug to compose — and Qwen3 and Kimi K2.6 are open-weight families. If all you want is “an open-model worker on my floor, now,” that’s one dropdown.</p>
+<h2 id="how-the-three-byok-engines-name-a-model" tabindex="-1">How the three BYOK engines name a model <a class="anchor" href="#how-the-three-byok-engines-name-a-model" aria-hidden="true">#</a></h2>
+<p>One thing to internalize before any wiring: <strong>OpenCode, Crush, and pi all use the same <code>provider/model</code> slug form.</strong> The <em>model</em> part is just the upstream’s id (e.g. <code>openai/gpt-oss-120b</code>, <code>qwen3:30b-a3b</code>). The <em>provider</em> prefix resolves one of two ways:</p>
<ul>
-<li><strong>A built-in provider</strong> the engine already knows — supply the matching API-key env var and you’re done. OpenCode (via the AI-SDK / models.dev registry), Crush, and pi each ship a list of recognized providers: <code>openrouter</code>, <code>openai</code>, <code>anthropic</code>, <code>groq</code>, <code>deepseek</code>, <code>mistral</code>, and the local ones.</li>
+<li><strong>A built-in provider</strong> the engine already knows — supply the matching API-key env var and you’re done: <code>openrouter</code>, <code>openai</code>, <code>anthropic</code>, <code>groq</code>, <code>deepseek</code>, <code>mistral</code>, and the local ones.</li>
<li><strong>A custom OpenAI-compatible provider</strong> you define once (a <code>base_url</code> + key block) for any host that isn’t built in — Together, Fireworks, DeepInfra, Novita, <a href="http://Z.ai">Z.ai</a>, Moonshot. Then the slug is <code>&lt;your-name&gt;/&lt;model-id&gt;</code>.</li>
</ul>
<p>The <em>local</em> route differs slightly by engine — same id, different prefix and wiring:</p>
@@ -216,7 +217,7 @@
<thead>
<tr>
<th>Engine</th>
-<th>How v0.3.1 wires local</th>
+<th>How the app wires local</th>
<th>Local slug</th>
</tr>
</thead>
@@ -233,13 +234,13 @@
</tr>
<tr>
<td><strong>pi</strong></td>
-<td>Not wired in v0.3.1 — the local base-URL field is <strong>reserved</strong> (file-based <code>models.json</code> is a fast-follow). Run open models on pi via a third-party provider key for now (see Path B).</td>
+<td>Still <strong>reserved</strong> as of v0.4.4 — the harness doesn’t yet write pi a <code>models.json</code>. Run open models on pi via a provider key (Path B).</td>
<td>—</td>
</tr>
</tbody>
</table>
<p>Default endpoints are the usual ones: Ollama <code>http://localhost:11434/v1</code>, LM Studio <code>http://127.0.0.1:1234/v1</code>, vLLM whatever you exposed (often <code>:8000/v1</code>). You set these in the app — no shell exports required.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/run-munder-difflin-on-open-models/note-1.png" alt="Hand-drawn sketch from “Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider”" loading="lazy" decoding="async" /></figure>
+<figure class="fig fig-inline"><img src="/blog/assets/media/run-munder-difflin-on-open-models/note-1.png" alt="Hand-drawn sketch from “Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider”" loading="lazy" decoding="async" /><figcaption>Same model id everywhere — only the prefix changes: local/ on OpenCode, ollama/ on Crush, provider/ for BYOK.</figcaption></figure>
<h2 id="path-a-fully-local-ollama-lm-studio-vllm" tabindex="-1">Path A — fully local (Ollama / LM Studio / vLLM) <a class="anchor" href="#path-a-fully-local-ollama-lm-studio-vllm" aria-hidden="true">#</a></h2>
<p>Three steps: pull a model, tell Munder Difflin where it lives, pick it for an agent.</p>
<p><strong>1. Pull a model.</strong> With <a href="https://ollama.com">Ollama</a> installed, grab one sized to your RAM:</p>
@@ -248,7 +249,7 @@ ollama pull qwen3:30b-a3b <span class="token comment"># 19 GB — fast MoE
ollama pull deepseek-r1:32b <span class="token comment"># 20 GB — strong reasoning, 32 GB</span>
ollama serve <span class="token comment"># exposes the OpenAI-compatible API on :11434</span></code></pre>
<p>(LM Studio works the same way — load the model in the app and it serves on <code>:1234</code>. vLLM and llama.cpp expose their own OpenAI-compatible endpoint.)</p>
-<p><strong>2. Point the engine at it.</strong> Open <strong>Settings → AI Engines</strong>, find the engine you’ll use (<strong>OpenCode</strong> or <strong>Crush</strong>), and set its <strong>local base-URL</strong> field to your endpoint — e.g. <code>http://localhost:11434/v1</code> for Ollama. This is the per-CLI local field v0.3.1 added; the harness uses it to inject the right provider config when it spawns the agent. No API key needed for local. (pi’s local base-URL field is <strong>reserved</strong> in v0.3.1 — the harness doesn’t yet write it a <code>models.json</code> — so to run open models on pi today, use a third-party provider key via Path B below.)</p>
+<p><strong>2. Point the engine at it.</strong> Open <strong>Settings → AI Engines</strong>, find the engine you’ll use (<strong>OpenCode</strong> or <strong>Crush</strong>), and set its <strong>local base-URL</strong> field to your endpoint — e.g. <code>http://localhost:11434/v1</code> for Ollama. The harness uses it to inject the right provider config when it spawns the agent. No API key needed for local.</p>
<p><strong>3. Hire an agent on that model.</strong> In the <strong>Add-Agent</strong> modal, choose the engine, then pick the local model. The picker offers the open-model quick-picks; the slug it sends is <code>local/gpt-oss:20b</code> on OpenCode, or <code>ollama/gpt-oss:20b</code> on Crush (keep the colon in the tag). That agent now runs fully on your hardware.</p>
<p>Which local model? Match it to your machine. These picks are from the project’s open-model catalog, by RAM tier:</p>
<table>
@@ -311,10 +312,10 @@ ollama serve <span class="token comment"># exposes the OpenAI-
</tr>
</tbody>
</table>
-<p>A note on what <em>won’t</em> fit: the headline frontier open models — DeepSeek-V4 (1.6T / 284B), Kimi K2.6 (~1T), GLM-5.2 (744B), Qwen3-235B — are server-class. The Ollama tags exist, but no consumer Mac holds them. For those, you want Path B. (Choosing a local model by RAM is the whole subject of the companion <a href="/blog/run-munder-difflin-on-a-mac-mini/">Mac Mini setup guide</a>.)</p>
+<p>A note on what <em>won’t</em> fit: the headline frontier open models — DeepSeek-V4, Kimi K2.6, GLM-5.2, Qwen3-235B — are server-class. The Ollama tags exist, but no consumer Mac holds them. For those, you want Path B. (Choosing a local model by RAM is the whole subject of the companion <a href="/blog/run-munder-difflin-on-a-mac-mini/">Mac Mini setup guide</a>.)</p>
<h2 id="path-b-a-third-party-oss-provider-byok" tabindex="-1">Path B — a third-party OSS provider (BYOK) <a class="anchor" href="#path-b-a-third-party-oss-provider-byok" aria-hidden="true">#</a></h2>
<p>Same open weights, hosted on someone else’s GPUs, billed to your own key. This is how you reach the big models, and it’s a two-field setup.</p>
-<p><strong>1. Get a key.</strong> Sign up with a provider and copy an API key. <a href="https://openrouter.ai">OpenRouter</a> is the easiest start — one key, the widest catalog (it fronts most of the others). <a href="https://groq.com">Groq</a> is the fastest for the models it carries. Together, Fireworks, and DeepInfra host the heavyweights.</p>
+<p><strong>1. Get a key.</strong> Sign up with a provider and copy an API key. <a href="https://openrouter.ai">OpenRouter</a> is the easiest start — one key, the widest catalog. <a href="https://groq.com">Groq</a> is the fastest for the models it carries. Together, Fireworks, and DeepInfra host the heavyweights.</p>
<p><strong>2. Paste it into the app.</strong> In <strong>Settings → AI Engines</strong>, enter the key in the matching field. Keys are stored <strong>write-only through the broker</strong> — the renderer can set a key but never read it back; only the main process injects it as the right env var (<code>OPENROUTER_API_KEY</code>, <code>GROQ_API_KEY</code>, …) when an agent spawns, and only for the provider that agent actually uses. Nothing lands in plaintext config.</p>
<p><strong>3. Pick a model.</strong> In Add-Agent, select the engine and a provider-hosted model. The slug carries the provider prefix — e.g. <code>openrouter/deepseek/deepseek-v4-flash</code> or <code>groq/openai/gpt-oss-120b</code>. The recommended BYOK quick-picks:</p>
<table>
@@ -371,19 +372,21 @@ ollama serve <span class="token comment"># exposes the OpenAI-
</tr>
</tbody>
</table>
-<p>Prefer a model maker’s own API? Those work too: DeepSeek (<code>deepseek/deepseek-v4-flash</code>, <code>DEEPSEEK_API_KEY</code>), Mistral (<code>mistral/...</code>, <code>MISTRAL_API_KEY</code>), <a href="http://Z.ai">Z.ai</a> for GLM, Moonshot for Kimi. A couple of moving targets worth knowing as of mid-2026: DeepSeek’s <code>deepseek-chat</code> / <code>deepseek-reasoner</code> aliases retire on 2026-07-24 (wire <code>deepseek-v4-flash</code> directly), and Groq is sunsetting Llama 4 — so on Groq stick to gpt-oss and <code>llama-3.3-70b-versatile</code>. The full slug-by-slug table, with citations and verify-live caveats, lives in the project’s open-model catalog (the single source of truth this post and the Mac Mini guide both cite).</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/run-munder-difflin-on-open-models/note-2.png" alt="Hand-drawn sketch from “Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider”" loading="lazy" decoding="async" /></figure>
+<p>Prefer a model maker’s own API? Those work too: DeepSeek (<code>deepseek/deepseek-v4-flash</code>, <code>DEEPSEEK_API_KEY</code>), Mistral (<code>mistral/...</code>, <code>MISTRAL_API_KEY</code>), <a href="http://Z.ai">Z.ai</a> for GLM, Moonshot for Kimi. On Groq, stick to gpt-oss and <code>llama-3.3-70b-versatile</code>. The full slug-by-slug table, with citations, lives in the project’s open-model catalog (the single source of truth this post and the Mac Mini guide both cite).</p>
+<p>One honest fix from v0.4.4 worth knowing: OpenCode used to preselect a BYOK slug <strong>and silently fall back</strong> to a different model when the key was absent — while every surface kept reporting the model it had asked for. That’s gone. If a key is missing now, you find out; you never unknowingly run a model you didn’t pick.</p>
+<figure class="fig fig-inline"><img src="/blog/assets/media/run-munder-difflin-on-open-models/note-2.png" alt="Hand-drawn sketch from “Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider”" loading="lazy" decoding="async" /><figcaption>One key, the whole frontier: paste it once in Settings, and the write-only broker injects it per spawn — never into plaintext config.</figcaption></figure>
<h2 id="per-engine-cheat-sheet" tabindex="-1">Per-engine cheat-sheet <a class="anchor" href="#per-engine-cheat-sheet" aria-hidden="true">#</a></h2>
<p>You rarely touch these directly — the AI Engines panel writes them — but here’s what each engine does under the hood, so the model field makes sense.</p>
<p><strong>OpenCode</strong> is OpenAI-SDK native and knows most providers out of the box. BYOK is just the env var; local is a custom provider named <code>local</code>. Slugs: <code>openrouter/openai/gpt-oss-120b</code>, <code>local/qwen3:30b-a3b</code>.</p>
<p><strong>Crush</strong> reads BYOK env vars for its built-in providers and uses a written config block for anything custom or local. For local Ollama it’s literally:</p>
<pre class="language-json"><code class="language-json"><span class="token punctuation">{</span> <span class="token property">"providers"</span><span class="token operator">:</span> <span class="token punctuation">{</span> <span class="token property">"ollama"</span><span class="token operator">:</span> <span class="token punctuation">{</span> <span class="token property">"type"</span><span class="token operator">:</span> <span class="token string">"ollama"</span><span class="token punctuation">,</span> <span class="token property">"base_url"</span><span class="token operator">:</span> <span class="token string">"http://localhost:11434/v1"</span> <span class="token punctuation">}</span> <span class="token punctuation">}</span> <span class="token punctuation">}</span></code></pre>
<p>then select <code>ollama/qwen3:30b-a3b</code>. For a host like Together, it’s an <code>openai-compat</code> block with that provider’s <code>base_url</code> and your key.</p>
-<p><strong>pi</strong> (the Pi Coding Agent) ships 15+ built-in providers, so BYOK is just the provider key. Slugs look like <code>groq/llama-3.3-70b-versatile</code> or <code>openrouter/qwen/qwen3-coder</code>. Its local base-URL field is <strong>reserved</strong> in v0.3.1 — Munder Difflin doesn’t yet write pi a <code>models.json</code> — so for now run open models on pi through a third-party provider key rather than a local endpoint; local-via-base-URL is a fast-follow.</p>
-<p>All three are god-eligible in v0.3.1, so you can put an open model in the orchestrator seat, not just the workers. For the god seat, give it a strong one — <code>gpt-oss:120b</code> or <code>llama3.3:70b</code> locally (64–96 GB), or a frontier provider model like <code>openrouter/deepseek/deepseek-v4-flash</code>. Sub-8B models are great workers but thin for orchestration.</p>
+<p><strong>pi</strong> ships 15+ built-in providers, so BYOK is just the provider key. Slugs look like <code>groq/llama-3.3-70b-versatile</code> or <code>openrouter/qwen/qwen3-coder</code>. Its local base-URL field remains <strong>reserved</strong> as of v0.4.4 — run open models on pi through a provider key rather than a local endpoint.</p>
+<p><strong>Qwen and Kimi</strong> are the zero-wiring route: vendor CLIs as first-class engines. Sign in the way each CLI wants and hire away — no slugs, no base-URLs.</p>
+<p>All the BYOK engines are orchestrator-eligible, so you can put an open model in Michael’s seat, not just the workers’. Give the seat a strong one — <code>gpt-oss:120b</code> or <code>llama3.3:70b</code> locally (64–96 GB), or a frontier provider model like <code>openrouter/deepseek/deepseek-v4-flash</code>. Sub-8B models are great workers but thin for orchestration.</p>
<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>
-<p>Open weights turn Munder Difflin from “a harness for three vendors’ CLIs” into “a harness for the whole open ecosystem.” Run it <strong>fully local</strong> when privacy and fixed cost matter and your RAM can hold the model; run it on a <strong>third-party provider</strong> when you want frontier quality or no local hardware at all — and mix the two across your floor, agent by agent. The setup is two fields in <strong>Settings → AI Engines</strong> and a pick in Add-Agent; the open-model slugs are curated in the project catalog so you don’t have to guess.</p>
-<p>That’s the promise kept: a virtual office of CLI agents on your own computer, now running on models whose weights anyone can read. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> — it’s free, open source, and local-first. Then point your favorite open model at it. (On a Mac and want the hardware-by-RAM walkthrough? Read the <a href="/blog/run-munder-difflin-on-a-mac-mini/">Mac Mini setup guide</a>.)</p>
+<p>Open weights turn Munder Difflin from “a harness for three vendors’ CLIs” into “a harness for the whole open ecosystem.” Run it <strong>fully local</strong> when privacy and fixed cost matter and your RAM can hold the model; run it on a <strong>third-party provider</strong> when you want frontier quality or no local hardware at all; hire the <strong>vendor CLI</strong> when you want zero wiring — and mix all three across your floor, agent by agent. The setup is two fields in <strong>Settings → AI Engines</strong> and a pick in Add-Agent, with <strong>Settings → Prerequisites</strong> confirming every engine binary the app can see.</p>
+<p>That’s the promise kept: a virtual office of CLI agents on your own computer, running on models whose weights anyone can read. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> — free, open source, local-first — and point your favorite open model at it. (On a Mac and want the hardware-by-RAM walkthrough? Read the <a href="/blog/run-munder-difflin-on-a-mac-mini/">Mac Mini setup guide</a>.)</p>
@@ -392,7 +395,7 @@ ollama serve <span class="token comment"># exposes the OpenAI-
<div class="qa">
<p class="q">Can Munder Difflin run entirely on open-source models?</p>
- <p class="a">Yes. As of v0.3.1 the OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models. You can run every agent — workers and the god orchestrator — on open-weight models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi, either fully local on your own hardware or through a third-party OSS provider with your own API key.</p>
+ <p class="a">Yes. The OpenCode, Crush, and pi engines all support bring-your-own-key (BYOK) and local models, and the Qwen and Kimi CLIs are first-class engines whose flagship models are open-weight. You can run every agent — workers and Michael himself — on open models like gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, or Kimi: fully local on your own hardware, or through a third-party OSS provider with your own API key.</p>
</div>
<div class="qa">
@@ -401,13 +404,13 @@ ollama serve <span class="token comment"># exposes the OpenAI-
</div>
<div class="qa">
- <p class="q">Which open model should I pick for the god orchestrator?</p>
- <p class="a">The god seat does the reasoning and long-context coordination, so give it a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration.</p>
+ <p class="q">Which open model should I pick for the orchestrator seat?</p>
+ <p class="a">Michael does the reasoning and long-context coordination, so give him a strong model: locally, gpt-oss-120b or Llama 3.3 70B on a 64–96 GB machine; via a provider, DeepSeek-V4-Flash, GLM-4.6, or Kimi-K2.6 on OpenRouter. Small local models (8B and under) are fine for routine workers but underpowered for orchestration.</p>
</div>
<div class="qa">
<p class="q">Do I need a different model id for each engine?</p>
- <p class="a">No — the upstream model id is the same. All three engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/&lt;id&gt; while Crush and pi use ollama/&lt;id&gt;.</p>
+ <p class="a">No — the upstream model id is the same. All three BYOK engines use a provider/model slug; only the provider prefix and how the key or base-URL is wired differ. For local models, OpenCode uses local/&lt;id&gt; while Crush uses ollama/&lt;id&gt;.</p>
</div>
</section>
@@ -426,7 +429,7 @@ ollama serve <span class="token comment"># exposes the OpenAI-
<aside class="toc-rail" aria-label="Table of contents">
<div class="tt">On this page</div>
<ol>
- <li class="lvl-2"><a href="#two-routes-your-hardware-or-someone-elses">Two routes: your hardware, or someone else’s</a></li><li class="lvl-2"><a href="#how-the-three-engines-name-a-model">How the three engines name a model</a></li><li class="lvl-2"><a href="#path-a-fully-local-ollama-lm-studio-vllm">Path A — fully local (Ollama / LM Studio / vLLM)</a></li><li class="lvl-2"><a href="#path-b-a-third-party-oss-provider-byok">Path B — a third-party OSS provider (BYOK)</a></li><li class="lvl-2"><a href="#per-engine-cheat-sheet">Per-engine cheat-sheet</a></li><li class="lvl-2"><a href="#the-bottom-line">The bottom line</a></li>
+ <li class="lvl-2"><a href="#two-routes-your-hardware-or-someone-elses">Two routes: your hardware, or someone else’s</a></li><li class="lvl-2"><a href="#how-the-three-byok-engines-name-a-model">How the three BYOK engines name a model</a></li><li class="lvl-2"><a href="#path-a-fully-local-ollama-lm-studio-vllm">Path A — fully local (Ollama / LM Studio / vLLM)</a></li><li class="lvl-2"><a href="#path-b-a-third-party-oss-provider-byok">Path B — a third-party OSS provider (BYOK)</a></li><li class="lvl-2"><a href="#per-engine-cheat-sheet">Per-engine cheat-sheet</a></li><li class="lvl-2"><a href="#the-bottom-line">The bottom line</a></li>
</ol>
</aside>
diff --git a/docs/blog/scheduling-autonomous-agent-missions/index.html b/docs/blog/scheduling-autonomous-agent-missions/index.html
index b470bab1..24445f70 100644
--- a/docs/blog/scheduling-autonomous-agent-missions/index.html
+++ b/docs/blog/scheduling-autonomous-agent-missions/index.html
@@ -328,7 +328,7 @@ mission and watch the floor wake itself up; it’s free and open source.</p>
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/tags/automation/index.html b/docs/blog/tags/automation/index.html
index 4e3aa392..b45e1ad4 100644
--- a/docs/blog/tags/automation/index.html
+++ b/docs/blog/tags/automation/index.html
@@ -109,7 +109,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
@@ -122,7 +122,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
@@ -189,7 +189,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/tags/claude-code/index.html b/docs/blog/tags/claude-code/index.html
index 363817ab..6de2634b 100644
--- a/docs/blog/tags/claude-code/index.html
+++ b/docs/blog/tags/claude-code/index.html
@@ -237,7 +237,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/tags/cli-agents/index.html b/docs/blog/tags/cli-agents/index.html
index b80e258f..53786aa9 100644
--- a/docs/blog/tags/cli-agents/index.html
+++ b/docs/blog/tags/cli-agents/index.html
@@ -125,7 +125,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
diff --git a/docs/blog/tags/code-review/index.html b/docs/blog/tags/code-review/index.html
index db6107b3..eb4e7204 100644
--- a/docs/blog/tags/code-review/index.html
+++ b/docs/blog/tags/code-review/index.html
@@ -106,7 +106,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/tags/content/index.html b/docs/blog/tags/content/index.html
index ac80014f..c32e5b9c 100644
--- a/docs/blog/tags/content/index.html
+++ b/docs/blog/tags/content/index.html
@@ -93,7 +93,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
diff --git a/docs/blog/tags/getting-started/index.html b/docs/blog/tags/getting-started/index.html
index f201ec17..dd680de4 100644
--- a/docs/blog/tags/getting-started/index.html
+++ b/docs/blog/tags/getting-started/index.html
@@ -106,10 +106,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
@@ -125,7 +125,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/tags/guides/index.html b/docs/blog/tags/guides/index.html
index 785b3bd7..eaa14d30 100644
--- a/docs/blog/tags/guides/index.html
+++ b/docs/blog/tags/guides/index.html
@@ -186,10 +186,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
@@ -221,7 +221,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
@@ -285,7 +285,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/tags/hive/index.html b/docs/blog/tags/hive/index.html
index b7708fcd..4bdf0f53 100644
--- a/docs/blog/tags/hive/index.html
+++ b/docs/blog/tags/hive/index.html
@@ -90,7 +90,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/tags/local-first/index.html b/docs/blog/tags/local-first/index.html
index 679468f4..8902db9a 100644
--- a/docs/blog/tags/local-first/index.html
+++ b/docs/blog/tags/local-first/index.html
@@ -138,10 +138,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
@@ -173,7 +173,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
diff --git a/docs/blog/tags/multi-agent/index.html b/docs/blog/tags/multi-agent/index.html
index 7ca26a59..07af42ac 100644
--- a/docs/blog/tags/multi-agent/index.html
+++ b/docs/blog/tags/multi-agent/index.html
@@ -394,10 +394,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
@@ -477,7 +477,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
diff --git a/docs/blog/tags/onboarding/index.html b/docs/blog/tags/onboarding/index.html
index 125a38d7..c34c9eed 100644
--- a/docs/blog/tags/onboarding/index.html
+++ b/docs/blog/tags/onboarding/index.html
@@ -90,10 +90,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
diff --git a/docs/blog/tags/open-source/index.html b/docs/blog/tags/open-source/index.html
index 4b18598b..a7780eee 100644
--- a/docs/blog/tags/open-source/index.html
+++ b/docs/blog/tags/open-source/index.html
@@ -269,7 +269,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
@@ -333,7 +333,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
@@ -346,7 +346,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/tags/orchestration/index.html b/docs/blog/tags/orchestration/index.html
index b0696db7..fa0942f6 100644
--- a/docs/blog/tags/orchestration/index.html
+++ b/docs/blog/tags/orchestration/index.html
@@ -138,7 +138,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/tags/tutorial/index.html b/docs/blog/tags/tutorial/index.html
index b92b980b..fc3c5606 100644
--- a/docs/blog/tags/tutorial/index.html
+++ b/docs/blog/tags/tutorial/index.html
@@ -93,7 +93,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
@@ -109,7 +109,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/tags/use-cases/index.html b/docs/blog/tags/use-cases/index.html
index bc05319c..3414b7d3 100644
--- a/docs/blog/tags/use-cases/index.html
+++ b/docs/blog/tags/use-cases/index.html
@@ -157,7 +157,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
diff --git a/docs/blog/tags/video/index.html b/docs/blog/tags/video/index.html
index a4b3397d..8f810d1c 100644
--- a/docs/blog/tags/video/index.html
+++ b/docs/blog/tags/video/index.html
@@ -93,7 +93,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/topics/comparisons/index.html b/docs/blog/topics/comparisons/index.html
index 8172fda3..b4f36815 100644
--- a/docs/blog/topics/comparisons/index.html
+++ b/docs/blog/topics/comparisons/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>comparisons — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on comparisons — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on comparisons — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/comparisons/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="comparisons — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on comparisons — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on comparisons — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/comparisons/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="comparisons — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on comparisons — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on comparisons — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>comparisons</h1>
- <p class="lead">17 posts in this cluster.</p>
+ <h1>comparisons</h1><p class="lead">Honest side-by-sides with the other ways to run many coding agents, trade-offs included.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.html
index 290d1a35..7d7a76e4 100644
--- a/docs/blog/topics/concepts/index.html
+++ b/docs/blog/topics/concepts/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>concepts — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on concepts — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on concepts — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/concepts/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="concepts — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on concepts — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on concepts — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/concepts/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="concepts — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on concepts — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on concepts — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>concepts</h1>
- <p class="lead">21 posts in this cluster.</p>
+ <h1>concepts</h1><p class="lead">The ideas underneath the product — harnesses, hives, memory, orchestration — explained without the hand-waving.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
diff --git a/docs/blog/topics/guides/index.html b/docs/blog/topics/guides/index.html
index 7e421581..65dd5dca 100644
--- a/docs/blog/topics/guides/index.html
+++ b/docs/blog/topics/guides/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>guides — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on guides — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on guides — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/guides/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="guides — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on guides — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on guides — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/guides/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="guides — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on guides — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on guides — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>guides</h1>
- <p class="lead">34 posts in this cluster.</p>
+ <h1>guides</h1><p class="lead">Step-by-step walkthroughs you can follow today — install the app, meet your clone, hire agents on any of ten engines, and leave real work running overnight.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
@@ -213,10 +212,10 @@
<div class="meta">
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
<h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>
@@ -248,7 +247,7 @@
<span>8 min</span>
</div>
<h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>
- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here&#39;s how to wire each across the OpenCode, Crush, and pi engines.</p>
+ <p class="dek">Munder Difflin runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — fully local (Ollama/LM Studio/vLLM), through a third-party OSS provider, or on the model-maker&#39;s own CLI. Here&#39;s the wiring, current as of v0.4.4.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>
@@ -328,7 +327,7 @@
<span>9 min</span>
</div>
<h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>
- <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>
+ <p class="dek">Install Munder Difflin v0.4.4 on macOS, Windows, or Linux and put a hive of coding agents — on any of ten engines — to work on ambitious, long-horizon tasks, start to finish.</p>
<div class="foot">
<span class="tag kind">Guides</span>
<a class="more" href="/blog/how-to-install-and-use-munder-difflin/" aria-label="Read: How to Install and Use Munder Difflin">Read →</a>
diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.html
index 07df611c..64c91d24 100644
--- a/docs/blog/topics/internals/index.html
+++ b/docs/blog/topics/internals/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>internals — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on internals — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on internals — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/internals/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="internals — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on internals — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on internals — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/internals/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="internals — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on internals — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on internals — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>internals</h1>
- <p class="lead">18 posts in this cluster.</p>
+ <h1>internals</h1><p class="lead">How the machine actually works: postmortems, architecture decisions, and the bugs we document instead of burying.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.html
index 700b8e12..8acbd347 100644
--- a/docs/blog/topics/memory/index.html
+++ b/docs/blog/topics/memory/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>memory — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on memory — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on memory — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/memory/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="memory — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on memory — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on memory — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/memory/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="memory — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on memory — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on memory — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>memory</h1>
- <p class="lead">5 posts in this cluster.</p>
+ <h1>memory</h1><p class="lead">How agents remember across sessions — and how a whole team shares what any one of them learned.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.html
index 672edd11..4bb7cb8b 100644
--- a/docs/blog/topics/orchestration/index.html
+++ b/docs/blog/topics/orchestration/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>orchestration — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on orchestration — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on orchestration — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/orchestration/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="orchestration — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on orchestration — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on orchestration — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/orchestration/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="orchestration — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on orchestration — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on orchestration — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>orchestration</h1>
- <p class="lead">9 posts in this cluster.</p>
+ <h1>orchestration</h1><p class="lead">Patterns for making one boss agent run a floor of workers without you in the middle.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
@@ -117,7 +116,7 @@
<div class="meta">
<time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
<h3><a href="/blog/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
<p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.html
index f375271f..7e0dd460 100644
--- a/docs/blog/topics/story/index.html
+++ b/docs/blog/topics/story/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>story — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on story — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on story — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/story/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="story — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on story — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on story — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/story/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="story — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on story — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on story — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>story</h1>
- <p class="lead">16 posts in this cluster.</p>
+ <h1>story</h1><p class="lead">Launches, releases, and the occasional confession — the running diary of building this thing in the open.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.html
index e0723eb9..e1249cac 100644
--- a/docs/blog/topics/use-cases/index.html
+++ b/docs/blog/topics/use-cases/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>use-cases — Munder Difflin Blog</title>
-<meta name="description" content="Munder Difflin blog posts on use-cases — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="description" content="Munder Difflin blog posts on use-cases — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<link rel="canonical" href="https://munderdiffl.in/blog/topics/use-cases/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="website" />
<meta property="og:title" content="use-cases — Munder Difflin Blog" />
-<meta property="og:description" content="Munder Difflin blog posts on use-cases — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta property="og:description" content="Munder Difflin blog posts on use-cases — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta property="og:url" content="https://munderdiffl.in/blog/topics/use-cases/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -24,7 +24,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="use-cases — Munder Difflin Blog" />
-<meta name="twitter:description" content="Munder Difflin blog posts on use-cases — agentic coding with Claude Code, the hive, GOD orchestrator, and long-term memory." />
+<meta name="twitter:description" content="Munder Difflin blog posts on use-cases — running a hive of coding agents with Michael the orchestrator, shared memory, skills, and the office floor." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -84,8 +84,7 @@
<a href="/blog/topics/" style="color:var(--ink-dim)">Topics</a>
</nav>
<p class="eyebrow">Topic</p>
- <h1>use-cases</h1>
- <p class="lead">9 posts in this cluster.</p>
+ <h1>use-cases</h1><p class="lead">Real workflows the hive actually runs — writing this blog, reviewing PRs, mining launch feedback, shipping releases — each one a recipe you can point at your own work.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
@@ -184,7 +183,7 @@
<span>6 min</span>
</div>
<h3><a href="/blog/deploy-a-blog-writer-agent/">Deploy a Blog-Writer Agent: The One That Wrote This Post</a></h3>
- <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy. Build your own.</p>
+ <p class="dek">How Munder Difflin&#39;s blog is written by an automated writer agent in the hive — drafts in a worktree, single-committer integration, Eleventy build, human-gated deploy, and now hand-drawn illustrations from the same office. Build your own.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
<a class="more" href="/blog/deploy-a-blog-writer-agent/" aria-label="Read: Deploy a Blog-Writer Agent: The One That Wrote This Post">Read →</a>
diff --git a/docs/blog/your-first-hour-with-munder-difflin/index.html b/docs/blog/your-first-hour-with-munder-difflin/index.html
index d7d32d1e..8f0d9977 100644
--- a/docs/blog/your-first-hour-with-munder-difflin/index.html
+++ b/docs/blog/your-first-hour-with-munder-difflin/index.html
@@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Your First Hour With Munder Difflin — Munder Difflin Blog</title>
-<meta name="description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />
+<meta name="description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />
<link rel="canonical" href="https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
@@ -15,7 +15,7 @@
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="Your First Hour With Munder Difflin — Munder Difflin Blog" />
-<meta property="og:description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />
+<meta property="og:description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />
<meta property="og:url" content="https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" />
<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
<meta property="og:locale" content="en_US" />
@@ -31,7 +31,7 @@
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Your First Hour With Munder Difflin — Munder Difflin Blog" />
-<meta name="twitter:description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />
+<meta name="twitter:description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />
<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
@@ -45,10 +45,10 @@
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Your First Hour With Munder Difflin",
- "description": "A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.",
+ "description": "A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.",
"image": ["https://munderdiffl.in/media/og.png"],
"datePublished": "2026-07-03T00:00:00.000Z",
- "dateModified": "2026-07-03T00:00:00.000Z",
+ "dateModified": "2026-08-20T00:00:00.000Z",
"author": { "@type": "Person", "name": "Chaitanya Giri" },
"publisher": {
"@type": "Organization",
@@ -56,7 +56,7 @@
"logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
},
"mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" },
- "keywords": "munder difflin onboarding, getting started with munder difflin, multi-agent harness tutorial, first hour with a multi-agent harness, god orchestrator first brief, ai agent approval queue, scheduled agent missions",
+ "keywords": "munder difflin onboarding, getting started with munder difflin, multi-agent harness tutorial, first hour with a multi-agent harness, ai agent approval queue, scheduled agent missions, munder difflin skills",
"articleSection": "Guides",
"inLanguage": "en-US",
"url": "https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/"
@@ -79,12 +79,12 @@
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
- { "@type": "Question", "name": "How long does it take to get Munder Difflin running?", "acceptedAnswer": { "@type": "Answer", "text": "About five minutes if you already have Node.js 18+ and one supported agent CLI installed. You clone the repo, run npm install and npm run dev, and the onboarding wizard walks you through the rest: harness home, registered repos, default command, and auto-mode. Signed macOS, Windows, and Linux builds are also available on the releases page." } },
- { "@type": "Question", "name": "What do I need before installing Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "Node.js 18+ with npm, a C/C++ toolchain for node-pty's native addon (Xcode Command Line Tools on macOS), and at least one supported terminal-agent CLI on your PATH — Claude Code, Antigravity, OpenAI Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. If a chosen engine's binary is missing, the harness runs its installer in the terminal and restarts into it automatically." } },
- { "@type": "Question", "name": "Who is Michael and how do I give him work?", "acceptedAnswer": { "@type": "Answer", "text": "Michael is the GOD orchestrator — the one agent you talk to. You type a brief into his terminal (or use the Talk voice channel with your own OpenAI Realtime key) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in Michael's office automatically on first launch." } },
- { "@type": "Question", "name": "Do I have to approve everything the agents do?", "acceptedAnswer": { "@type": "Answer", "text": "No. The GOD orchestrator resolves routine requests itself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest." } },
- { "@type": "Question", "name": "How do I review what an agent actually changed?", "acceptedAnswer": { "@type": "Answer", "text": "Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD — the VS Code editor engine, fully self-hosted, with all filesystem and git access brokered through the main process. There's also a per-agent git tab with status, log, and commit graph." } },
- { "@type": "Question", "name": "Can Munder Difflin keep working after I walk away?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — that's the point. The Triggers tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs 24/7 on hardware you already own." } }
+ { "@type": "Question", "name": "How long does it take to get Munder Difflin running?", "acceptedAnswer": { "@type": "Answer", "text": "About five minutes. Grab the signed build for macOS, Windows, or Linux from the releases page, or run from source with Node.js 18+. Onboarding validates your setup at the very first step — as of v0.4.4 it checks your home folder immediately instead of failing four steps later, and the Prerequisites page in Settings shows live status for every tool an engine needs, with a button that asks Michael to install what's missing." } },
+ { "@type": "Question", "name": "What do I need before installing Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "At least one supported agent CLI — Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, or GitHub Copilot CLI. If you're missing one (or git, Node, uv, MemPalace), Settings → Prerequisites shows exactly what's absent with the platform-correct install command, and can hand the whole job to Michael." } },
+ { "@type": "Question", "name": "Who is Michael and how do I give him work?", "acceptedAnswer": { "@type": "Answer", "text": "Michael is a clone of you — the boss of the agents, while you stay the boss of him. You type a brief into his terminal (or talk to him by voice) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in his office automatically on first launch." } },
+ { "@type": "Question", "name": "Do I have to approve everything the agents do?", "acceptedAnswer": { "@type": "Answer", "text": "No. Michael resolves routine requests himself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest." } },
+ { "@type": "Question", "name": "How do I review what an agent actually changed?", "acceptedAnswer": { "@type": "Answer", "text": "Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD. There's a per-agent git tab with status, log, and commit graph — and since v0.4.4 the IDE previews images too, so a design change is as reviewable as a code change." } },
+ { "@type": "Question", "name": "Can Munder Difflin keep working after I walk away?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — that's the point. The Triggers tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs on hardware you already own — and the app keeps itself current, telling you exactly what's in each update before you restart into it." } }
]
}
@@ -144,14 +144,14 @@
<a href="/blog/topics/guides/">Guides</a>
</nav>
<h1>Your First Hour With Munder Difflin</h1>
- <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin v0.4.4: install, the clone-of-you onboarding, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>
<div class="byline">
<span class="av" aria-hidden="true">CG</span>
<strong>Chaitanya Giri</strong>
<span class="dot" aria-hidden="true">·</span>
<time datetime="2026-07-03">Jul 3, 2026</time>
<span class="dot" aria-hidden="true">·</span>
- <span>4 min read</span>
+ <span>6 min read</span>
<span class="tag kind">Guides</span>
</div>
</header>
@@ -160,44 +160,46 @@
<div class="post-wrap wrap">
<div class="prose">
- <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>You can go from zero to a running AI office in one hour.</strong> Minute 0: install. Minute 5: the <strong>onboarding wizard</strong> (harness home, repos, auto-mode, orchestrator engine). Minute 10: your <strong>first brief to Michael</strong>, the GOD orchestrator. Minute 20: watch avatars work the floor and open a real desk terminal. Minute 40: your <strong>first approval</strong> and a side-by-side diff in the built-in <strong>Monaco IDE</strong>. Minute 60: set a <strong>schedule</strong> and walk away — the office keeps working.</p></div>
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>You can go from zero to a running AI office in one hour.</strong> Minute 0: install. Minute 5: onboarding — it opens on the honest pitch, <strong>a clone of you, working 24/7</strong>, and validates your setup at step one. Minute 10: your <strong>first brief to Michael</strong>. Minute 20: watch avatars work the floor and open a real desk terminal. Minute 40: your <strong>first approval</strong> and a side-by-side diff in the built-in <strong>Monaco IDE</strong>. Minute 60: set a <strong>schedule</strong> and walk away — the office keeps working.</p></div>
<video controls preload="none" playsinline poster="/media/demo/intro-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">
<source src="/media/demo/intro.mp4" type="video/mp4" />
</video>
-<p>Most tools ask you to learn them before they do anything. Munder Difflin is the other kind: within an hour you’ve briefed an orchestrator, watched agents work, approved a real change, and left the office running without you. Here’s that hour, minute by minute.</p>
+<p>Most tools ask you to learn them before they do anything. Munder Difflin is the other kind: within an hour you’ve briefed an orchestrator, watched agents work, approved a real change, and left the office running without you. Here’s that hour, minute by minute — current as of v0.4.4.</p>
<div class="yt yt-placeholder" role="img" aria-label="Video coming soon: Your first hour with Munder Difflin — full walkthrough">
<div class="ph-art"><span class="yt-badge" aria-hidden="true"><svg viewBox="0 0 24 24" width="26" height="26" fill="currentColor" aria-hidden="true"><path d="M8 5.5v13l11-6.5z"/></svg></span><span class="ph-note">video on its way</span><span class="yt-ph-title">Your first hour with Munder Difflin — full walkthrough</span></div>
</div>
<h2 id="minute-0-install" tabindex="-1">Minute 0 — Install <a class="anchor" href="#minute-0-install" aria-hidden="true">#</a></h2>
-<p>Two paths: grab a signed build (macOS, Windows, Linux) from the <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">releases page</a>, or clone and run from source with <code>npm install &amp;&amp; npm run dev</code>. You need Node.js 18+, a C/C++ toolchain for <code>node-pty</code>, and at least one supported agent CLI on your <code>PATH</code> — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI.</p>
-<p>I won’t repeat the details here; the <a href="/blog/how-to-install-and-use-munder-difflin/">install and usage guide</a> covers prerequisites, troubleshooting, and the <code>node-pty</code> rebuild gotcha. Budget five minutes.</p>
-<h2 id="minute-5-the-onboarding-wizard" tabindex="-1">Minute 5 — The onboarding wizard <a class="anchor" href="#minute-5-the-onboarding-wizard" aria-hidden="true">#</a></h2>
-<p>First launch drops you into a short wizard, and the four choices it asks for are the actual shape of the product:</p>
+<p>Two paths: grab a signed build (macOS, Windows, Linux) from the <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">releases page</a>, or clone and run from source with <code>npm install &amp;&amp; npm run dev</code>. You’ll want at least one supported agent CLI on your <code>PATH</code> — the engine card now honestly names all ten: Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, and GitHub Copilot CLI.</p>
+<p>Missing something? You no longer have to find out the hard way. <strong>Settings → Prerequisites</strong> shows live status for git, Node, uv, MemPalace and every engine — real paths, platform-correct install commands, and a button that simply asks Michael to fill the gaps for you. The <a href="/blog/how-to-install-and-use-munder-difflin/">install and usage guide</a> covers the deeper details. Budget five minutes.</p>
+<figure class="fig fig-inline"><img src="/blog/assets/media/your-first-hour-with-munder-difflin/note-1.png" alt="Hand-drawn sketch from “Your First Hour With Munder Difflin”" loading="lazy" decoding="async" /><figcaption>Prerequisites, before they become surprises: live status for every tool, and a button that hands the gaps to Michael.</figcaption></figure>
+<h2 id="minute-5-onboarding-meet-your-clone" tabindex="-1">Minute 5 — Onboarding: meet your clone <a class="anchor" href="#minute-5-onboarding-meet-your-clone" aria-hidden="true">#</a></h2>
+<p>First launch opens on the pitch the whole product keeps: <strong>a clone of you, working 24/7.</strong> The wizard’s few questions are the actual shape of the product:</p>
<ul>
-<li><strong>Harness home</strong> — the folder where the hive lives: per-agent memory, mailboxes, the blackboard, the event log. Plain files in a local git repo, relocatable later.</li>
-<li><strong>Registered repos</strong> — the codebases your agents will work on. This is what feeds GitHub issue ingestion and the CI watcher later.</li>
-<li><strong>Default command / auto-mode</strong> — which agent CLI new hires run by default, and whether the floor runs in auto-mode (agents proceed without per-tool prompts; the approval gate still catches critical items).</li>
-<li><strong>Orchestrator engine</strong> — Michael himself runs on a pluggable engine. Claude Code is the natural default, but the wizard lets you pick, and you can change it later.</li>
+<li><strong>Your clone’s engine</strong> — Michael runs on a pluggable engine; pick from the ten, change it later.</li>
+<li><strong>Harness home</strong> — the folder where the hive lives: per-agent memory, mailboxes, the blackboard, the event log. Plain files in a local git repo. The wizard validates this at step one — an empty or impossible folder fails immediately, not after step four.</li>
+<li><strong>Registered repos</strong> — the codebases your agents will work on.</li>
+<li><strong>Auto-mode</strong> — whether agents proceed without per-tool prompts (the approval gate still catches critical items).</li>
</ul>
-<p>Finish the wizard and you land on the floor: a pixel-art office, empty except for Michael, who seats himself in his office automatically.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/your-first-hour-with-munder-difflin/note-1.png" alt="Hand-drawn sketch from “Your First Hour With Munder Difflin”" loading="lazy" decoding="async" /></figure>
+<p>Finish the wizard and you land on the floor: a pixel-art office, empty except for Michael, who seats himself in his office automatically — with a <strong>BOSS</strong> tag on his card, because he’s the boss of the agents while you stay the boss of him. Everything the hive needs starts with him: as of v0.4.4 a brand-new install boots its message router, hook server and mission scheduler on the very first run.</p>
<h2 id="minute-10-your-first-brief-to-michael" tabindex="-1">Minute 10 — Your first brief to Michael <a class="anchor" href="#minute-10-your-first-brief-to-michael" aria-hidden="true">#</a></h2>
-<p>You don’t manage the workers. You talk to one agent — the GOD orchestrator — and he runs the floor. Click into Michael’s terminal and type a brief the way you’d brief a colleague: what you want, which repo, what “done” looks like.</p>
-<p>Michael adjudicates. He creates tasks on the kanban, assigns them, and routes messages between agent inboxes. Workers you hire via <strong>Add agent</strong> each get a real CLI process in its own pseudo-terminal and, with the git-isolation toggle, their own worktree — so nobody collides on branches. How he decides what to route, resolve, or escalate is its own post: <a href="/blog/how-the-god-orchestrator-works/">how the GOD orchestrator works</a>.</p>
+<p>You don’t manage the workers. You talk to your clone, and he runs the floor. Click into Michael’s terminal and type a brief the way you’d brief a colleague: what you want, which repo, what “done” looks like. Prefer talking? His voice mode opens with a live snapshot of the floor and can run nearly the whole app.</p>
+<p>Michael adjudicates. He creates tasks on the kanban, assigns them, and routes messages between agent inboxes. Workers you hire via <strong>Add agent</strong> each get a real CLI process in its own pseudo-terminal and, with the git-isolation toggle, their own worktree — so nobody collides on branches. How he decides what to route, resolve, or escalate is its own post: <a href="/blog/how-the-god-orchestrator-works/">how the orchestrator works</a>.</p>
<p>A good first brief is small and self-contained: “read this repo and write a <a href="http://REPORT.md">REPORT.md</a> summarizing the architecture” beats “refactor everything” for hour one.</p>
<h2 id="minute-20-watch-the-floor-then-open-a-desk" tabindex="-1">Minute 20 — Watch the floor, then open a desk <a class="anchor" href="#minute-20-watch-the-floor-then-open-a-desk" aria-hidden="true">#</a></h2>
<p>Now the part that makes the product legible: the floor is not a decoration, it’s the state of the system. Avatars walk to stations as they work. When the hive routes a message, an envelope flies from sender to recipient; escalations fly to the door. The cast is an affectionate parody of The Office, and every movement maps to a real event.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/your-first-hour-with-munder-difflin/floor-view.png" alt="The office floor: suited agents at desks, one carrying a sticky note to the kanban wall" loading="lazy" decoding="async" /><figcaption>The floor mid-task: every movement maps to a real event.</figcaption></figure>
-<p>Click any agent and you get their desk: the live terminal (you can type back into it), a sandboxed file browser, and a git tab with status, log, and commit graph. This is the moment the abstraction clicks — that avatar is a real <code>claude</code> process, and you’re reading its actual stdout.</p>
-<figure class="fig fig-inline"><img src="/blog/assets/media/your-first-hour-with-munder-difflin/note-2.png" alt="Hand-drawn sketch from “Your First Hour With Munder Difflin”" loading="lazy" decoding="async" /></figure>
+<p>Click any agent and you get their desk: the live terminal (you can type back into it), a sandboxed file browser, and a git tab with status, log, and commit graph. Go fullscreen and the roster cards show each agent’s model, project, and a live context gauge — the fuel dial for every worker at a glance. This is the moment the abstraction clicks: that avatar is a real CLI process, and you’re reading its actual stdout.</p>
+<figure class="fig fig-inline"><img src="/blog/assets/media/your-first-hour-with-munder-difflin/note-2.png" alt="Hand-drawn sketch from “Your First Hour With Munder Difflin”" loading="lazy" decoding="async" /><figcaption>Every desk is real: a live terminal, a file browser, a git tab — and a context gauge telling you how much runway the agent has left.</figcaption></figure>
<h2 id="minute-40-your-first-approval-and-the-diff" tabindex="-1">Minute 40 — Your first approval, and the diff <a class="anchor" href="#minute-40-your-first-approval-and-the-diff" aria-hidden="true">#</a></h2>
<p>Sometime in the first hour, something lands in the approvals queue — a spend threshold, a destructive operation, a scope change. This is by design: Michael resolves routine requests himself and escalates only critical items, so the queue stays short and every item in it deserves your attention. (The philosophy behind that gate: <a href="/blog/human-in-the-loop-approving-ai-agents/">approving AI agents without babysitting them</a>.)</p>
-<p>Before you click approve, look at the work. Hit the title-bar <strong>IDE</strong> button and the built-in Monaco editor — the VS Code editor engine, fully self-hosted — opens over the floor. The git CHANGES rail lists what changed; click a file for a read-only side-by-side diff against HEAD. Read the diff, approve the item, watch the envelope fly.</p>
+<p>Before you click approve, look at the work. Hit the title-bar <strong>IDE</strong> button and the built-in Monaco editor — the VS Code editor engine, fully self-hosted — opens over the floor. The git CHANGES rail lists what changed; click a file for a read-only side-by-side diff against HEAD. Images preview right in the IDE now, so a screenshot or SVG an agent produced is one click to inspect. Read the diff, approve the item, watch the envelope fly.</p>
+<h2 id="minute-50-give-an-agent-a-skill" tabindex="-1">Minute 50 — Give an agent a skill <a class="anchor" href="#minute-50-give-an-agent-a-skill" aria-hidden="true">#</a></h2>
+<p>New in v0.4.4 and worth five minutes of your first hour: <strong>Skills.</strong> A browsable catalog of hundreds of skills — search, category and publisher filters — installable across Claude Code, OpenCode and Codex with scope precedence handled for you. Give your reviewer a review checklist, your writer a style guide, your researcher a source-citing discipline. It’s the difference between hiring generalists and hiring people who’ve read the manual. (Background: <a href="/blog/mcp-and-skills-in-a-hive/">MCP and skills in a hive</a>.)</p>
<h2 id="minute-60-leave-it-running" tabindex="-1">Minute 60 — Leave it running <a class="anchor" href="#minute-60-leave-it-running" aria-hidden="true">#</a></h2>
<p>The last move of the hour is the one that changes your relationship with the tool: schedule something. The Command Center’s <strong>Triggers</strong> tab takes a label, an interval, a target agent, and a mission body — “every morning, triage new GitHub issues,” say — and a heartbeat re-engages the floor if it goes quiet. Last-fired and next-fired times are right there in the tab.</p>
-<p>Close the laptop. It’s local-first, so tomorrow the office is exactly where you left it — probably with mail in your queue. For patterns on what’s worth automating, see <a href="/blog/scheduling-autonomous-agent-missions/">scheduling autonomous agent missions</a>.</p>
+<p>Close the laptop. It’s local-first, so tomorrow the office is exactly where you left it — probably with mail in your queue. And when the next release ships, the app tells you itself: the update toast says what’s actually inside before you restart into it. For patterns on what’s worth automating, see <a href="/blog/scheduling-autonomous-agent-missions/">scheduling autonomous agent missions</a>.</p>
<h2 id="the-hour-in-one-line" tabindex="-1">The hour, in one line <a class="anchor" href="#the-hour-in-one-line" aria-hidden="true">#</a></h2>
-<p>Install, answer four wizard questions, brief one agent, watch the floor, read one diff, set one schedule — and you’ve gone from “a CLI in a terminal” to “an office that works while you don’t.”</p>
+<p>Install, meet your clone, brief him once, watch the floor, read one diff, install one skill, set one schedule — and you’ve gone from “a CLI in a terminal” to “an office that works while you don’t.”</p>
<p><a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Download Munder Difflin</a> — free, MIT-licensed, local-first — and if the first hour earns it, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>
@@ -207,32 +209,32 @@
<div class="qa">
<p class="q">How long does it take to get Munder Difflin running?</p>
- <p class="a">About five minutes if you already have Node.js 18+ and one supported agent CLI installed. You clone the repo, run npm install and npm run dev, and the onboarding wizard walks you through the rest: harness home, registered repos, default command, and auto-mode. Signed macOS, Windows, and Linux builds are also available on the releases page.</p>
+ <p class="a">About five minutes. Grab the signed build for macOS, Windows, or Linux from the releases page, or run from source with Node.js 18+. Onboarding validates your setup at the very first step — as of v0.4.4 it checks your home folder immediately instead of failing four steps later, and the Prerequisites page in Settings shows live status for every tool an engine needs, with a button that asks Michael to install what&#39;s missing.</p>
</div>
<div class="qa">
<p class="q">What do I need before installing Munder Difflin?</p>
- <p class="a">Node.js 18+ with npm, a C/C++ toolchain for node-pty&#39;s native addon (Xcode Command Line Tools on macOS), and at least one supported terminal-agent CLI on your PATH — Claude Code, Antigravity, OpenAI Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. If a chosen engine&#39;s binary is missing, the harness runs its installer in the terminal and restarts into it automatically.</p>
+ <p class="a">At least one supported agent CLI — Claude Code, Antigravity, Codex, Grok, Kimi, Qwen, OpenCode, Crush, pi, or GitHub Copilot CLI. If you&#39;re missing one (or git, Node, uv, MemPalace), Settings → Prerequisites shows exactly what&#39;s absent with the platform-correct install command, and can hand the whole job to Michael.</p>
</div>
<div class="qa">
<p class="q">Who is Michael and how do I give him work?</p>
- <p class="a">Michael is the GOD orchestrator — the one agent you talk to. You type a brief into his terminal (or use the Talk voice channel with your own OpenAI Realtime key) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in Michael&#39;s office automatically on first launch.</p>
+ <p class="a">Michael is a clone of you — the boss of the agents, while you stay the boss of him. You type a brief into his terminal (or talk to him by voice) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in his office automatically on first launch.</p>
</div>
<div class="qa">
<p class="q">Do I have to approve everything the agents do?</p>
- <p class="a">No. The GOD orchestrator resolves routine requests itself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest.</p>
+ <p class="a">No. Michael resolves routine requests himself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest.</p>
</div>
<div class="qa">
<p class="q">How do I review what an agent actually changed?</p>
- <p class="a">Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD — the VS Code editor engine, fully self-hosted, with all filesystem and git access brokered through the main process. There&#39;s also a per-agent git tab with status, log, and commit graph.</p>
+ <p class="a">Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD. There&#39;s a per-agent git tab with status, log, and commit graph — and since v0.4.4 the IDE previews images too, so a design change is as reviewable as a code change.</p>
</div>
<div class="qa">
<p class="q">Can Munder Difflin keep working after I walk away?</p>
- <p class="a">Yes — that&#39;s the point. The Triggers tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It&#39;s local-first, so the office runs 24/7 on hardware you already own.</p>
+ <p class="a">Yes — that&#39;s the point. The Triggers tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It&#39;s local-first, so the office runs on hardware you already own — and the app keeps itself current, telling you exactly what&#39;s in each update before you restart into it.</p>
</div>
</section>
@@ -251,7 +253,7 @@
<aside class="toc-rail" aria-label="Table of contents">
<div class="tt">On this page</div>
<ol>
- <li class="lvl-2"><a href="#minute-0-install">Minute 0 — Install</a></li><li class="lvl-2"><a href="#minute-5-the-onboarding-wizard">Minute 5 — The onboarding wizard</a></li><li class="lvl-2"><a href="#minute-10-your-first-brief-to-michael">Minute 10 — Your first brief to Michael</a></li><li class="lvl-2"><a href="#minute-20-watch-the-floor-then-open-a-desk">Minute 20 — Watch the floor, then open a desk</a></li><li class="lvl-2"><a href="#minute-40-your-first-approval-and-the-diff">Minute 40 — Your first approval, and the diff</a></li><li class="lvl-2"><a href="#minute-60-leave-it-running">Minute 60 — Leave it running</a></li><li class="lvl-2"><a href="#the-hour-in-one-line">The hour, in one line</a></li>
+ <li class="lvl-2"><a href="#minute-0-install">Minute 0 — Install</a></li><li class="lvl-2"><a href="#minute-5-onboarding-meet-your-clone">Minute 5 — Onboarding: meet your clone</a></li><li class="lvl-2"><a href="#minute-10-your-first-brief-to-michael">Minute 10 — Your first brief to Michael</a></li><li class="lvl-2"><a href="#minute-20-watch-the-floor-then-open-a-desk">Minute 20 — Watch the floor, then open a desk</a></li><li class="lvl-2"><a href="#minute-40-your-first-approval-and-the-diff">Minute 40 — Your first approval, and the diff</a></li><li class="lvl-2"><a href="#minute-50-give-an-agent-a-skill">Minute 50 — Give an agent a skill</a></li><li class="lvl-2"><a href="#minute-60-leave-it-running">Minute 60 — Leave it running</a></li><li class="lvl-2"><a href="#the-hour-in-one-line">The hour, in one line</a></li>
</ol>
</aside>
diff --git a/docs/sitemap.xml b/docs/sitemap.xml
index de5d1b64..735bc633 100644
--- a/docs/sitemap.xml
+++ b/docs/sitemap.xml
@@ -202,7 +202,7 @@
</url>
<url>
<loc>https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/</loc>
- <lastmod>2026-07-03</lastmod>
+ <lastmod>2026-08-20</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
@@ -220,7 +220,7 @@
</url>
<url>
<loc>https://munderdiffl.in/blog/run-munder-difflin-on-open-models/</loc>
- <lastmod>2026-06-22</lastmod>
+ <lastmod>2026-08-20</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
@@ -250,13 +250,13 @@
</url>
<url>
<loc>https://munderdiffl.in/blog/deploy-a-blog-writer-agent/</loc>
- <lastmod>2026-06-10</lastmod>
+ <lastmod>2026-08-20</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
<url>
<loc>https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/</loc>
- <lastmod>2026-06-10</lastmod>
+ <lastmod>2026-08-20</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
@@ -340,7 +340,7 @@
</url>
<url>
<loc>https://munderdiffl.in/blog/how-to-install-and-use-munder-difflin/</loc>
- <lastmod>2026-06-05</lastmod>
+ <lastmod>2026-08-20</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>