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

content(blog): integrate 6 finished drafts and rebuild site

Chaitanya Giri70cdfe9bf030
diff --git a/blog/package-lock.json b/blog/package-lock.json
index 93f48866..0a83c49f 100644
--- a/blog/package-lock.json
+++ b/blog/package-lock.json
@@ -10,7 +10,6 @@
"license": "MIT",
"devDependencies": {
"@11ty/eleventy": "^3.0.0",
- "@11ty/eleventy-plugin-rss": "^2.0.2",
"@11ty/eleventy-plugin-syntaxhighlight": "^5.0.0",
"luxon": "^3.5.0",
"markdown-it": "^14.1.0",
@@ -143,23 +142,6 @@
"url": "https://opencollective.com/11ty"
}
},
- "node_modules/@11ty/eleventy-plugin-rss": {
- "version": "2.0.4",
- "resolved": "https://registry.npmjs.org/@11ty/eleventy-plugin-rss/-/eleventy-plugin-rss-2.0.4.tgz",
- "integrity": "sha512-LF60sGVlxGTryQe3hTifuzrwF8R7XbrNsM2xfcDcNMSliLN4kmB+7zvoLRySRx0AQDjqhPTAeeeT0ra6/9zHUQ==",
- "dev": true,
- "license": "MIT",
- "dependencies": {
- "@11ty/eleventy-utils": "^2.0.0",
- "@11ty/posthtml-urls": "^1.0.1",
- "debug": "^4.4.0",
- "posthtml": "^0.16.6"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/11ty"
- }
- },
"node_modules/@11ty/eleventy-plugin-syntaxhighlight": {
"version": "5.0.2",
"resolved": "https://registry.npmjs.org/@11ty/eleventy-plugin-syntaxhighlight/-/eleventy-plugin-syntaxhighlight-5.0.2.tgz",
diff --git a/blog/src/posts/deploy-a-blog-writer-agent.md b/blog/src/posts/deploy-a-blog-writer-agent.md
new file mode 100644
index 00000000..fb83b1ca
--- /dev/null
+++ b/blog/src/posts/deploy-a-blog-writer-agent.md
@@ -0,0 +1,160 @@
+---
+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."
+date: 2026-06-10
+category: use-cases
+categoryLabel: Use Cases
+type: Non-technical
+primaryKeyword: "automated blog writer agent"
+secondaryKeywords: ["ai blog automation", "content agent", "multi-agent blogging", "automated content pipeline"]
+tags: ["Use Cases", "Automation", "Content", "Multi-Agent", "Open Source"]
+author:
+ name: Chaitanya Giri
+ 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."
+ - 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."
+ - 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
+<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>
+
+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
+**writer agent** in the Munder Difflin hive takes a brief, drafts a full post, and hands it down a pipeline
+that ends — after one human nod — on the live site.
+
+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.
+
+## The outcome first: so many blogs about us
+
+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:
+
+- **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
+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.
+
+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.
+
+## The pipeline, end to end
+
+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:
+
+### 1. Draft — in an isolated worktree
+
+The writer agent gets a **brief** (a topic + intent, usually straight from our SEO backlog) and a
+**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/).)
+
+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
+`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 [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.
+
+### 3. Build — Eleventy turns markdown into a site
+
+A static [Eleventy](https://www.11ty.dev/) build compiles `blog/src/posts` → `docs/blog`. Dropping one
+markdown file is the entire authoring action: the build auto-adds the post to the index, its topic page,
+each tag page, the sitemap, and the RSS feed — plus the SEO that's already wired (canonical URLs, OpenGraph,
+`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.
+
+### 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
+GitHub Pages at **munderdiffl.in/blog**. Before that goes live, a person reviews the diff and approves the
+deploy. The orchestrator [escalates exactly this kind of "publish to the world"
+action](/blog/how-the-god-orchestrator-works/) to the human-approval queue rather than shipping it itself.
+
+The split is the lesson: **drafting and integration are autonomous; publishing is human-gated.** 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.
+
+## 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.
+
+**1. Give it a brief.** One topic, the search intent, and the angle. Pull it from a keyword backlog so the
+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."
+
+**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.
+
+**4. Review before publish.** Have a reviewer agent or your orchestrator check the draft against the brief,
+then put the **deploy** behind a human approval. Draft and integrate automatically; publish on a click.
+
+**5. Make it recurring.** The real unlock is a scheduled mission: fire the writer on a cadence, feeding it
+the next backlog item each time. One prompt to the orchestrator stood up [an hourly PR
+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.
+
+## 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.
+
+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.
+
+---
+
+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.
+[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
new file mode 100644
index 00000000..d575de14
--- /dev/null
+++ b/blog/src/posts/deploy-automated-pr-reviewer-agent.md
@@ -0,0 +1,102 @@
+---
+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
+category: orchestration
+categoryLabel: Orchestration
+type: Technical
+primaryKeyword: "automated pr reviewer agent"
+secondaryKeywords: ["deploy pr review bot", "coderabbit alternative self-hosted", "ai github issue triage", "local pr review agent"]
+tags: ["Orchestration", "Automation", "Code Review", "Open Source", "Hive"]
+author:
+ name: Chaitanya Giri
+ 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."
+ - 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."
+ - 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?"
+ a: "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."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>You can stand up a <strong>fully automated PR-reviewing agent</strong> in Munder Difflin in about one prompt: give it an objective, point it at your repo and open PRs, and let it review against the <em>real source</em>, post comments, and escalate only what matters. Ours recently triaged <strong>5 new bug reports against the v0.2.4 release, consolidated 22 duplicate breaker firings into clean signal</strong>, and surfaced a HIGH-severity Windows-terminal regression plus a 3-issue lifecycle bug cluster sharing one root cause — all verified against source, with fixes specified and a human pinged. That triage became the v0.2.5 patch queue. Here's how to deploy your own.</p></div>
+
+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 *description*, charge per seat, and don't understand the rest of your backlog.
+
+We built ours differently, and we run it on ourselves. This is a how-to for deploying the same thing: a **PR Reviewer agent** 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.
+
+## 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.
+
+That framing matters because of what it unlocks:
+
+- **It reads the real source, not the summary.** 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.
+- **It sees the whole backlog at once.** Reading the full set of open issues plus shared hive memory, it can notice that issues #41, #43, and #47 are three faces of the same bug — rather than reviewing each in a vacuum.
+- **It escalates through the same inbox you use.** A serious finding becomes a message to you, routed like any other hive mail. No separate alerting system.
+
+## 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:
+
+> *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.*
+
+That single instruction is doing three jobs, and the orchestrator decomposes them:
+
+1. **Spin up a dedicated agent.** The orchestrator creates a `pr-reviewer` worker scoped to this objective — a specialist that does one thing well, instead of a general agent context-switching between code review and everything else.
+2. **Run the first pass now.** It reviews the current open PRs and issues immediately, against the checked-out source, and posts comments.
+3. **Make it recurring.** It registers a [scheduled mission](/blog/scheduling-autonomous-agent-missions/) — a small persisted record with an interval and a target agent — that re-fires the reviewer every hour. New PRs get reviewed on the next tick without you touching a keyboard.
+
+The whole job description was the prompt. There's no workflow file, no webhook to register, no CI secret to wire. (If you've seen our [one-prompt dogfooding story](/blog/one-prompt-automated-pr-review/), this is the same mechanism, pointed at a tougher problem.)
+
+### The three knobs worth setting explicitly
+
+The default behavior is good, but three things are worth naming in your brief so the agent's judgment matches yours:
+
+- **The objective.** "Review for correctness and regressions against the released source" produces sharper reviews than "review the PRs." Tell it what *good* means for your repo.
+- **The escalation bar.** Say what earns a human ping — "HIGH severity or anything touching data loss." Everything below the bar gets a posted comment and nothing more. This is what keeps it from becoming a notification firehose.
+- **The de-dupe instruction.** "Consolidate duplicate reports into one finding" turns a pile of redundant issues into signal. Without it, you get one review per issue; with it, you get one review per *bug*.
+
+## Case study: a messy day, triaged
+
+Here's what that deployment looked like on a real run against our own repo, right after the v0.2.4 release.
+
+Five new user bug reports had come in. On the surface that's five reviews. Underneath, the issue tracker was a mess: **22 separate breaker and duplicate firings** — the same crashes and complaints reported multiple times, in slightly different words, by different users hitting the same code paths. A human triaging that by hand burns an afternoon just figuring out what's actually distinct.
+
+The PR Reviewer agent did the figuring. It read all five reports plus the surrounding issues against the v0.2.4 source, and **consolidated the 22 firings down to two real findings**:
+
+- **A HIGH-severity Windows-terminal regression.** Verified directly against the released source — not inferred from the report. The agent traced the failing path, confirmed the regression was real and recent, specified the fix, and **escalated it to the human** because it crossed the severity bar.
+- **A 3-issue agent-lifecycle bug cluster sharing one root cause.** Three separately-filed issues that all bottomed out in the same lifecycle bug. The agent named the shared root cause, specified the fix once, and grouped the three issues under it — so what looked like three problems was correctly understood as one.
+
+For each, it **posted a review comment on the relevant issues/PRs**, and pinged me only for the parts that mattered. The rest — the seventeen-odd duplicates — got folded into the two findings instead of generating seventeen more notifications.
+
+That triage *became the v0.2.5 patch queue.* I didn't assemble it. I read two clear findings with fixes already specified, against source I trusted because the agent had read it too.
+
+### Why the consolidation is the real win
+
+It's tempting to frame this as "it reviewed PRs fast." But the load-bearing part is the **de-noising**: 22 → 2. A reviewer that comments on everything just moves the triage burden into your inbox. A reviewer that reads the whole backlog, verifies against source, and collapses duplicates into root causes does the part of code review that's actually hard — deciding *what's true and what's distinct* — and hands you the short list.
+
+That's the difference between an automated commenter and an automated *reviewer*.
+
+## What to be honest about
+
+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.
+
+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.
+
+## Deploy yours
+
+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.
+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/run-ai-agent-hive-from-slack-setup.md b/blog/src/posts/run-ai-agent-hive-from-slack-setup.md
new file mode 100644
index 00000000..16f9fc05
--- /dev/null
+++ b/blog/src/posts/run-ai-agent-hive-from-slack-setup.md
@@ -0,0 +1,202 @@
+---
+title: "Run Your AI Agent Hive from Slack: The Complete Setup"
+description: "Step-by-step setup for driving Munder Difflin's AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread."
+date: 2026-06-10
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "slack ai agent setup"
+secondaryKeywords: ["slack bot ai agents", "slack events api webhook", "trigger agents from slack", "slack app mention bot"]
+tags: ["Guides", "Automation", "Slack", "Hive", "Setup"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "How do I connect Slack to Munder Difflin?"
+ a: "Create a Slack app at api.slack.com/apps, grant the bot the chat:write, channels:history, and groups:history scopes, install it, then paste the Signing Secret and Bot User OAuth Token into Munder Difflin's Settings. Enable Slack, copy the public tunnel Request URL the app gives you into Slack's Event Subscriptions, and subscribe to app_mention plus message events. @mention the bot in a channel to start work."
+ - q: "Which Slack scopes does the hive need?"
+ a: "Three Bot Token Scopes: chat:write (so the bot can post done-summaries back in-thread), channels:history and groups:history (so Slack delivers the message and thread-reply events the hive listens to). The Signing Secret authenticates every inbound request; the xoxb- Bot User OAuth Token authorizes the bot's replies."
+ - q: "Why did Slack stop triggering my agents?"
+ a: "The public Request URL comes from a local tunnel that is ephemeral — it rotates every time you stop and start the app. If triggers go quiet, restart Munder Difflin, copy the new tunnel URL, and re-paste it into Slack's Event Subscriptions → Request URL. Slack re-verifies and triggers resume."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>This is the full, working setup for driving your
+<strong>Munder Difflin</strong> hive from Slack. Create a Slack app, add three bot scopes
+(<code>chat:write</code>, <code>channels:history</code>, <code>groups:history</code>), paste the
+<strong>Signing Secret</strong> and <strong>Bot User OAuth Token</strong> into Settings, then drop the
+app's public <strong>tunnel Request URL</strong> into Slack's Event Subscriptions and subscribe to
+<code>app_mention</code> + <code>message</code> events. <strong>@mention the bot</strong> to kick off
+work; the office replies in-thread, ingests file attachments, and posts a done-summary when the task
+finishes. One quirk to remember: that tunnel URL rotates on restart.</p></div>
+
+Munder Difflin runs a virtual office of AI agents on your own machine. Most days you drive that office
+from the desktop app. But the request often starts somewhere else — a teammate asks in a channel, or
+you're away from your desk and want to kick off a run from your phone. The Slack integration closes that
+gap: **@mention your bot in Slack, and the message becomes work for your hive.** When the task finishes,
+a summary posts straight back into the same thread.
+
+This is a complete how-to for the setup that's live right now. It has two halves: the Slack app side
+(api.slack.com), and the Munder Difflin side (Settings). Do them in order and you'll be triggering
+agents from chat in about ten minutes.
+
+## What you're building
+
+A message that @mentions your bot in a connected Slack channel becomes a task in
+[the orchestrator's](/blog/how-the-god-orchestrator-works/) queue — exactly like a task you'd type into
+the app yourself. GOD then triages it and routes it to the right agent. Two things make this feel
+conversational rather than fire-and-forget:
+
+- **Thread activation.** The first @mention in a thread "activates" it. After that, you can keep replying
+ in that same thread *without* re-mentioning the bot, and the hive keeps listening. It's a real
+ back-and-forth, not a one-shot command.
+- **Done-summaries.** When the work lands, the office posts a summary reply **in the same thread** via
+ Slack's `chat.postMessage`. You see the result where you asked the question.
+
+It also reads **file and image attachments** — drop a screenshot or a log file alongside your @mention
+and the hive ingests it.
+
+Under the hood there's no `@slack/bolt`, no framework, and nothing hosted in the cloud. A tiny
+`node:http` server inside the app implements just the slice of Slack's **Events API** it needs, and a
+local tunnel gives Slack a public doorbell to ring. Your agents, their memory, and your code never leave
+your machine.
+
+## Part 1 — Create the Slack app
+
+Head to [api.slack.com/apps](https://api.slack.com/apps) and create a new app **from scratch**, in the
+workspace you want the bot to live in.
+
+You'll collect two secrets and set three scopes. Here's exactly where each lives.
+
+### Signing Secret
+
+In your app's left nav, open **Basic Information** and find **App Credentials**. Copy the **Signing
+Secret**. This is what Munder Difflin uses to verify that every inbound request is genuinely from Slack —
+it never leaves your machine and is never logged.
+
+### Bot Token Scopes
+
+Open **OAuth & Permissions → Scopes → Bot Token Scopes** and add these three:
+
+- **`chat:write`** — lets the bot post replies, including the done-summary, back into the thread.
+- **`channels:history`** — lets Slack deliver message and thread-reply events from **public** channels.
+- **`groups:history`** — the same, for **private** channels.
+
+You don't need anything beyond these three. The hive learns its own bot user id automatically from each
+event, so there's no extra scope just to detect mentions.
+
+### Install and grab the Bot User OAuth Token
+
+Still on **OAuth & Permissions**, click **Install to Workspace** and approve. Slack then shows a **Bot
+User OAuth Token** that starts with **`xoxb-`** — copy it. That token authorizes the bot's replies; like
+the signing secret, it stays in the app's main process and is never logged.
+
+> Keep both values handy. You'll paste them into Munder Difflin next, then come back to finish Event
+> Subscriptions.
+
+## Part 2 — Configure Munder Difflin
+
+Open Munder Difflin and go to **Settings**. In the Slack section:
+
+1. **Enable Slack.**
+2. Paste the **Signing Secret**.
+3. Paste the **Bot User OAuth Token** (`xoxb-…`).
+4. *(Optional)* Set a **Channel ID** to restrict ingestion to a single channel. Leave it blank to accept
+ any channel the bot is in. This is the cleanest way to keep a noisy workspace from turning into a
+ noisy hive.
+5. *(Optional)* Change the **port** if `3847` (the default) is already taken on your machine.
+
+Start it. The app binds the local webhook server and opens a public tunnel, then shows you a **Request
+URL** — the public address Slack will call. Copy that URL; you need it for the last step.
+
+If the tunnel can't start, the app surfaces a real error rather than handing you a dead URL. The local
+handler is the security boundary, so it stays up regardless — but you do need a working tunnel URL for
+Slack to reach it.
+
+## Part 3 — Point Slack at your Request URL
+
+Back in your Slack app, open **Event Subscriptions** and toggle **Enable Events** on.
+
+Paste the **Request URL** from Munder Difflin into the **Request URL** field. Slack immediately fires a
+one-time `url_verification` handshake at it; the app answers the challenge and Slack shows a green
+**Verified**. (If it doesn't verify, jump to the troubleshooting note below — it's almost always the
+tunnel.)
+
+Now scroll to **Subscribe to bot events** and add:
+
+- **`app_mention`** — fires when someone @mentions the bot. This is the primary trigger.
+- **`message.channels`** — message events in public channels (for **thread replies** in an activated
+ thread, and **file_share** uploads).
+- **`message.groups`** — the same, for private channels.
+
+**Save changes.** Slack may prompt you to reinstall the app to apply the new event subscriptions — do it.
+
+That's the whole loop. The hive triggers on:
+
+- a direct **@mention** of the bot in a connected channel,
+- any **reply inside a thread** the bot was already mentioned in (no re-mention needed),
+- a **file or image upload** that @mentions the bot.
+
+It deliberately ignores the bot's own posts, edits, channel-join notices, and every other message
+subtype — so it never talks to itself and never reacts to channel noise.
+
+## Try it
+
+In a channel where the bot is a member, type something like:
+
+> @YourBot summarize the open PRs in the api repo and flag anything stale
+
+The message lands in the queue, GOD routes it, and an agent picks it up. Keep the conversation going by
+replying in that same thread — the hive is still listening. When the task is done, a summary appears
+right there in the thread.
+
+## Troubleshooting: the Request URL rotates on restart
+
+Here's the one quirk worth tattooing on the back of your hand. **The public Request URL comes from an
+ephemeral tunnel, and it changes every time the app restarts.** So if Slack suddenly stops triggering
+your agents — verification was green yesterday, silence today — it's almost always because the app was
+restarted and the old URL went stale.
+
+The fix is quick:
+
+1. **Stop and Start** Munder Difflin's Slack integration (or just relaunch the app).
+2. Copy the **new Request URL** it shows you.
+3. Paste it back into Slack's **Event Subscriptions → Request URL** and let it re-verify.
+
+Triggers resume the moment Slack shows **Verified** again. If you find yourself doing this a lot, get
+into the habit of re-checking the Request URL whenever you restart — it's the single most common reason
+Slack triggering "breaks."
+
+## Why it's built this way
+
+It would have been easier to host this in a cloud function. Doing it as a **local** webhook is the
+point. Every request is HMAC-verified against your signing secret in constant time, with a five-minute
+replay guard and a size cap checked first — anything suspicious gets a flat 403. The secrets stay on
+your box. Slack is only a thin remote surface for *starting and watching* work; the office itself —
+agents, memory, git history — never leaves your machine. It's the same
+[local-first philosophy](/blog/local-first-ai-agent-orchestration/) behind everything Munder Difflin
+does: keep the control plane on your computer, and let the outside world knock politely at the door.
+
+Pair it with [scheduled missions](/blog/scheduling-autonomous-agent-missions/) and the picture rounds
+out: timers put recurring work into the queue, Slack puts ad-hoc work into the queue, and your office
+runs both — whether or not you're watching.
+
+## FAQ
+
+**How do I connect Slack to Munder Difflin?** Create a Slack app, add the `chat:write`,
+`channels:history`, and `groups:history` bot scopes, install it, then paste the Signing Secret and
+`xoxb-` Bot User OAuth Token into Settings. Copy the app's Request URL into Slack's Event Subscriptions,
+subscribe to `app_mention` + message events, and @mention the bot to start work.
+
+**Which scopes does it need?** Just three: `chat:write` for replies and done-summaries,
+`channels:history` and `groups:history` so Slack delivers the message and thread-reply events the hive
+listens to.
+
+**Why did Slack stop triggering?** The Request URL is from an ephemeral tunnel that rotates on restart.
+Relaunch the app, copy the new URL, and re-paste it into Event Subscriptions.
+
+---
+
+Munder Difflin turns a Slack thread into a remote control for an AI office that still lives entirely on
+your machine — [orchestrated by GOD](https://munderdiffl.in/#how), verified at the edge, and queued like
+any other task. [Download Munder Difflin](https://munderdiffl.in/#install) to run your hive from chat;
+it's free and open source.
diff --git a/blog/src/posts/the-clone-army-trap-mixed-swarm-vs-identical-agents.md b/blog/src/posts/the-clone-army-trap-mixed-swarm-vs-identical-agents.md
new file mode 100644
index 00000000..a6cd4f98
--- /dev/null
+++ b/blog/src/posts/the-clone-army-trap-mixed-swarm-vs-identical-agents.md
@@ -0,0 +1,163 @@
+---
+title: "The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents"
+description: "Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality."
+date: 2026-06-10
+category: concepts
+categoryLabel: Concepts
+type: Non-technical
+primaryKeyword: "mixed-capability agent swarm"
+secondaryKeywords: ["multi-agent token efficiency", "agent specialization", "orchestrator delegation", "identical vs mixed agents"]
+tags: ["Multi-Agent", "Cost", "Orchestration", "Model Routing"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Why not just run tens of identical top-tier agents on a problem?"
+ a: "Because most tasks are a mix of cheap and hard subtasks, and identical premium agents pay frontier prices for the cheap majority too. You also pay a hidden tax: identical agents with no shared state each re-derive the same context, and without an owner they duplicate work and collide. You get a big bill for redundant effort, not more capability."
+ - q: "Is a mixed-capability swarm actually as capable as an all-premium fleet?"
+ a: "On most real workloads, yes — and sometimes more, because specialization and a clean division of labor beat raw horsepower applied uniformly. The frontier model still does the hard reasoning; it just isn't wasted on formatting and lookups. Quality only drops if you route a genuinely hard task to a model that can't handle it, which is a routing mistake, not a swarm one."
+ - q: "What makes a swarm token-efficient rather than just cheaper per agent?"
+ a: "Three structural things: an orchestrator that routes each subtask to the right capability tier, shared memory so no agent re-derives context that another already established, and scoped contracts so each agent carries only what its task needs. Specialization plus delegation plus shared state is the lever — not the per-token price of any one model."
+ - q: "Doesn't an orchestrator add overhead that eats the savings?"
+ a: "It adds a little — one premium agent reasoning about the whole job — but it removes far more: the redundant re-derivation, the colliding work, and the frontier-priced busywork that a leaderless clone army generates. The orchestrator's cost is a fixed overhead; the savings scale with every routine subtask it routes away from the expensive tier."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>Throwing <strong>tens of identical
+top-tier CLI agents</strong> at a problem feels like brute-forcing your way to a great answer. It's
+mostly brute-forcing your way to a big bill. Real tasks are a <strong>mix</strong> of cheap and hard
+subtasks, and a clone army pays frontier prices for the cheap majority — while quietly re-deriving the
+same context N times and colliding with itself because no one owns the plan. A <strong>mixed-capability
+swarm</strong> — an orchestrator routing each subtask to the right tier, <strong>shared memory</strong>
+so nobody re-derives context, scoped contracts, and real parallelism — gets comparable or better results
+at a <strong>fraction of the tokens</strong>. The lever is specialization, delegation, and shared state —
+not horsepower applied uniformly.</p></div>
+
+There's a seductive move when a problem looks big: spin up *more of the best agent*. Ten identical
+top-tier CLI agents, all on the frontier model, all pointed at the same repo. It looks like a force
+multiplier. It feels safe — every agent is maximally capable, so surely the swarm is too.
+
+It's a trap. Not because the agents are bad, but because the *shape of the work* doesn't reward
+sameness. We've argued before that [a hive shouldn't all run the biggest
+model](/blog/do-more-with-less-model-routing/) and laid out the [five levers that cut a fleet's
+bill](/blog/the-multi-agent-cost-playbook/). This post is the head-to-head those posts imply: **the
+clone army versus the mixed swarm** — why uniform top-tier agents burn tokens on work a cheaper agent
+could do, and why a swarm of mixed-capability agents is both leaner *and*, surprisingly often, better.
+
+## Most tasks are not uniform — they're lumpy
+
+Pick any real job an agent team gets handed. "Add this feature." "Audit this codebase." "Triage these
+issues." Now look inside it. You'll find a handful of genuinely hard subtasks — the architecture call,
+the subtle bug, the ambiguous spec that needs judgment — surrounded by a *much larger* pile of routine
+ones: reading files, reformatting, renaming, classifying, summarizing logs, writing boilerplate tests,
+checking a convention.
+
+That lumpiness is the whole game. The hard subtasks genuinely reward a frontier model. The routine ones
+don't — a small, fast model does them just as well. So when you run *every* agent on the top tier, you're
+not buying ten units of capability. You're buying one unit of capability you needed and nine units you're
+paying frontier prices for routine work you'd have gotten for a tenth the cost. The capability you bought
+on the easy subtasks was never the bottleneck.
+
+## The clone army's three hidden taxes
+
+The per-token waste is the obvious cost. The structural ones are worse.
+
+**Tax 1 — Re-derivation.** Ten identical agents with no shared state each rebuild the same understanding
+from scratch. Each one reads the same files, re-infers the same architecture, re-discovers the same
+constraint that "auth lives in the middleware layer." That context-building is real tokens, paid N times,
+to arrive at knowledge one agent already had. Without [shared memory](/blog/markdown-first-agent-memory/),
+the swarm is N strangers who refuse to talk.
+
+**Tax 2 — Collision.** Identical agents with no owner have no division of labor. Two of them pick the
+same subtask; a third refactors a file a fourth is mid-edit on; their outputs contradict and someone (you)
+has to reconcile them. A leaderless clone army doesn't parallelize a problem — it parallelizes *confusion*,
+and then you pay again to merge it. This is exactly the [coordinate-without-colliding
+problem](/blog/coordinating-ai-coding-agents/), made worse by sameness: when every agent is interchangeable,
+nothing tells them who does what.
+
+**Tax 3 — No escalation ceiling, no floor.** Because every agent is already maxed out, there's nowhere to
+*escalate* a truly nasty subtask (everyone's already on the best model) and nowhere to *de-escalate* the
+easy follow-ups (everyone stays expensive). You've flattened the one dimension that lets a team be
+efficient: the ability to spend big where it matters and small where it doesn't.
+
+So the clone army's bill isn't "10× one agent." It's 10× *plus* re-derivation *plus* collision-cleanup —
+for a result that a smaller, better-organized team would have produced with less drama.
+
+## What a mixed swarm does differently
+
+A mixed-capability swarm isn't "the same idea, but cheaper agents." It's a different *structure*, and the
+structure is where the wins come from.
+
+- **An orchestrator that routes by tier.** Instead of ten peers, you have one lead that sees the whole job,
+ decomposes it, and sends each subtask to the [right capability tier](/blog/do-more-with-less-model-routing/):
+ routine work to fast cheap workers, the hard reasoning to a frontier worker, and itself reserved for
+ planning and integration. The expensive model still does the expensive thinking — it just stops doing the
+ cheap thinking.
+- **Shared memory so nobody re-derives.** The context one agent establishes — the architecture, the
+ decision, the gotcha — is written once to a shared board and read by everyone. Re-derivation tax: gone.
+ This is why a hive leans on [compact, markdown-first memory and semantic
+ recall](/blog/how-agents-remember-semantic-memory/) instead of stuffing the whole world into ten separate
+ context windows.
+- **Scoped contracts.** Each worker gets a *narrow* assignment with a clear input and expected output — not
+ the whole problem. Narrow scope means a small model can handle it, the context window stays tiny (so the
+ [per-turn cost you pay N times](/blog/the-multi-agent-cost-playbook/) stays small), and there's no ambiguity
+ about who owns what. Collision tax: gone.
+- **Real parallelism, not redundant parallelism.** The independent subtasks run at once because the
+ orchestrator knows they're independent — a genuine [fan-out](/blog/multi-agent-orchestration-patterns/),
+ not ten agents racing to do the same thing.
+
+Specialization, delegation, shared state. That's the lever. Each one removes a tax the clone army pays.
+
+## "But is it as *capable*?"
+
+Here's the part that surprises people: the mixed swarm often produces *better* output, not just cheaper.
+
+Two reasons. First, a clean division of labor beats raw horsepower applied uniformly — the same reason a
+real team doesn't put its most senior engineer on every ticket. A frontier agent that's *only* doing hard
+reasoning, with the routine noise handled elsewhere, is a frontier agent that isn't drowning the hard
+problem in busywork. You concentrate capability where it changes the outcome.
+
+Second, the structure adds a quality dimension the clone army lacks: you can route risky output through a
+[maker-checker pass](/blog/how-ai-agents-verify-their-own-work/) — a cheap worker produces, a stronger
+agent verifies — which catches more than ten parallel agents independently being confident. Capability
+isn't just the model; it's the *organization* around the model.
+
+The honest caveat — and we [keep this one honest](/blog/multi-agent-orchestration-patterns/) — is that
+quality drops the moment you route a genuinely hard subtask to a model that can't handle it. But that's a
+*routing* mistake, not a swarm one. Default lean, escalate the hard minority on signal, and the capability
+gap to an all-premium fleet closes to roughly nothing — at a fraction of the tokens.
+
+## What "fraction of the tokens" actually means
+
+We won't fabricate a benchmark number, but the direction is not subtle, and it comes from three
+multiplying sources. The price gap between a small and a frontier model is large per token. The routine
+subtasks vastly outnumber the hard ones in most workloads. And shared memory plus scoped contracts erase
+the re-derivation and collision the clone army pays on top. Multiply those together and the mixed swarm
+isn't a little cheaper — it's *categorically* cheaper, for output that holds up. The real denominator is
+**cost per completed task**, and a leaderless clone army that needs a human to merge its contradictions
+isn't cheap on that measure at all.
+
+## How Munder Difflin is built around this
+
+This isn't just a thesis — it's the architecture of the product. [Munder Difflin](https://munderdiffl.in)
+runs a virtual office where a [god orchestrator](/blog/how-the-god-orchestrator-works/) decomposes your
+intent and delegates to Office-themed worker agents of *varying* capability. The cheap workers handle the
+routine; the orchestrator and any escalated workers handle the hard reasoning — [per-agent model
+selection](/blog/the-multi-agent-cost-playbook/) is a real setting, not advice. A shared board, inboxes,
+and memory mean no agent re-derives what another already established. And a token budget with a *steward*
+model keeps the whole swarm inside a spend ceiling you set — so the structure that makes it efficient is
+also the structure that makes the cost predictable. It supports Claude Code, Codex, and Antigravity CLIs,
+runs [local-first](/blog/why-local-first-matters-for-ai-agents/), and you can [watch every agent
+work](/blog/observability-for-agent-fleets/).
+
+## The bottom line
+
+The clone army feels powerful because every soldier is elite. But a problem isn't won by ten identical
+elites re-deriving the same context and stepping on each other — it's won by the *right* capability on
+each subtask, a shared brain so nobody repeats anyone, and a lead who owns the plan. A mixed-capability
+swarm is leaner because it stops paying frontier prices for routine work, and it's often *better* because
+specialization and delegation beat undifferentiated horsepower. Don't buy more of the best agent. Build a
+team out of the right ones.
+
+Want to run a swarm that routes by capability instead of brute-forcing with clones? [Download Munder
+Difflin](https://munderdiffl.in/#install) — a local, 24/7 virtual office of AI agents. It's free and open
+source.
diff --git a/blog/src/posts/trigger-ai-agents-from-github-webhook.md b/blog/src/posts/trigger-ai-agents-from-github-webhook.md
new file mode 100644
index 00000000..e242b3c5
--- /dev/null
+++ b/blog/src/posts/trigger-ai-agents-from-github-webhook.md
@@ -0,0 +1,200 @@
+---
+title: "How to Trigger Your AI Agent Hive from a GitHub Webhook"
+description: "Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host."
+date: 2026-06-10
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "github webhook ai agent"
+secondaryKeywords: ["trigger ai agents from github", "github webhook automation", "webhook to ai orchestrator", "ci ai agent trigger"]
+tags: ["Guides", "Automation", "GitHub", "Webhooks", "Hive"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Can you trigger an AI agent from a GitHub webhook?"
+ a: "Yes. Munder Difflin runs a small, opt-in local webhook that turns an inbound POST into a task. Point a GitHub webhook (or a one-line curl from a GitHub Action) at the public URL with the shared secret in an x-md-webhook-secret header and a JSON body of { message, title? }, and the GOD orchestrator picks it up, files a kanban card, and routes it to an agent."
+ - q: "Is the Munder Difflin webhook secure?"
+ a: "It's built to be. Every POST must carry your shared secret in x-md-webhook-secret, compared in constant time, and the secret is verified before the body is even buffered. A 1 MB body cap and a fixed-window rate limit (120 requests/minute) bound abuse ahead of any parsing. The response hands back a 192-bit capability token; a GET reveals only that one task's status — no listing, no enumeration."
+ - q: "Do I need to host a public server to receive GitHub webhooks?"
+ a: "No. The endpoint runs on your own machine inside the desktop app. A best-effort local tunnel (tunnelmole) gives GitHub a public URL to reach your local port, so there's nothing to deploy. If the tunnel can't start, the local handler still runs — the tunnel is a doorbell, not the security boundary."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>Munder Difflin can <strong>turn a GitHub
+webhook into a task for your hive</strong>. Flip on the webhook trigger, copy the public URL it opens via
+a local tunnel, and have GitHub (or a GitHub Action) <strong>POST <code>{ message, title? }</code></strong>
+with your shared secret in an <code>x-md-webhook-secret</code> header. The GOD orchestrator files a kanban
+card, routes it to an agent, and hands back a <strong>capability token</strong> you can poll for status.
+The endpoint lives <em>on your machine</em>; the tunnel is just a doorbell. Off by default until you switch
+it on.</p></div>
+
+Most of the time you brief your agents from the app. But a lot of work *starts* in GitHub — a PR opens, an
+issue gets a label, a release tag lands. Munder Difflin's webhook trigger lets you bridge that gap: a GitHub
+event becomes a task in your hive's queue, triaged and routed by [the GOD
+orchestrator](/blog/how-the-god-orchestrator-works/) like any other piece of work. This is a hands-on
+walkthrough using GitHub as the concrete example, but the same endpoint accepts a POST from anything that
+can speak HTTP.
+
+## What the webhook trigger actually does
+
+The contract is small and worth stating exactly, because everything downstream depends on it.
+
+- **`POST`** to the endpoint with an `x-md-webhook-secret: <your-secret>` header and a JSON body of
+ `{ message, title? }`. On success the message is routed to god/Michael, a stamped kanban card is created,
+ and you get back `{ ok: true, token, taskId }`.
+- **`GET`** the endpoint with `x-md-webhook-token: <token>` (or `?token=<token>`) and you get back
+ `{ ok, status, title, result }` — **only** for that one token's task.
+
+That's the whole surface. `message` is the work to do (a required, non-empty string); `title` is an optional
+label for the card. Note what is *not* in that body: the secret. It's verified at the door and never forwarded
+into the routed message, the card, or the response — so it can't leak downstream.
+
+This is **inbound** automation — the outside world asking your hive to *do* something. It's the mirror of
+[human-in-the-loop approvals](/blog/human-in-the-loop-approving-ai-agents/), where an agent reaches *out* to a
+person mid-run. One starts work remotely; the other checks with you. Together they let a hive run while you're
+not at the keyboard.
+
+## Step 1 — Enable the webhook trigger and get the public URL
+
+In Munder Difflin, switch on the webhook trigger and set a **shared secret** (treat it like a password — long
+and random). When it starts, two things happen:
+
+1. A bare HTTP server binds to a local port inside the app's main process. This is the security boundary, and
+ it's live the instant the port is bound.
+2. The app opens a **best-effort local tunnel** (via `tunnelmole`) and hands you a **public URL** that forwards
+ to that local port. That's the URL you give GitHub.
+
+The tunnel is non-fatal by design. If it can't be established, the local handler keeps running and the app
+reports the tunnel error without a URL — so you're never in a half-broken state where the endpoint is exposed
+but unguarded. The tunnel is a doorbell; it is not what keeps strangers out.
+
+Copy the public URL. You'll paste it into GitHub next.
+
+## Step 2 — Point GitHub at it
+
+You have two clean ways to do this, depending on how literal you want to be.
+
+**Option A — A GitHub Action (recommended).** GitHub's native webhooks send GitHub's *own* payload shape, but
+our endpoint wants `{ message, title? }`. The simplest, most accurate bridge is a one-step workflow that POSTs
+exactly the body the endpoint expects. Drop this in `.github/workflows/notify-hive.yml`:
+
+```yaml
+name: Notify Hive
+on:
+ pull_request:
+ types: [opened, reopened]
+jobs:
+ ping:
+ runs-on: ubuntu-latest
+ steps:
+ - name: POST to Munder Difflin
+ run: |
+ curl -sS -X POST "$HIVE_URL" \
+ -H "x-md-webhook-secret: $HIVE_SECRET" \
+ -H "content-type: application/json" \
+ -d "{\"message\": \"Review PR #${{ github.event.number }}: ${{ github.event.pull_request.title }} — ${{ github.event.pull_request.html_url }}\", \"title\": \"PR #${{ github.event.number }}\"}"
+ env:
+ HIVE_URL: ${{ secrets.HIVE_URL }}
+ HIVE_SECRET: ${{ secrets.HIVE_SECRET }}
+```
+
+Store the public URL as the `HIVE_URL` repo secret and your shared secret as `HIVE_SECRET` (Settings →
+Secrets and variables → Actions). Now every opened or reopened PR composes a one-sentence brief and posts it
+to your hive. Because *you* author the `message`, you control exactly what the orchestrator is asked to do.
+
+**Option B — A raw repository webhook.** If you'd rather use Settings → Webhooks, you can — but be aware GitHub
+controls the payload there, and our endpoint reads only the top-level `message` and `title` strings. GitHub's
+event payload doesn't contain those keys, so a raw webhook won't produce a usable task on its own. Use the
+Action approach when you want the hive to receive a clean, purposeful instruction rather than a raw event dump.
+
+> Tip: GitHub webhooks have their own `secret` field that signs the body with HMAC. That's GitHub's scheme,
+> not ours — our endpoint authenticates on the `x-md-webhook-secret` *header*, which the Action sets
+> explicitly. Don't confuse the two.
+
+## Step 3 — Confirm a triggering POST works
+
+Before wiring CI, prove the round trip with `curl`:
+
+```bash
+curl -sS -X POST "https://your-tunnel-url.example" \
+ -H "x-md-webhook-secret: YOUR_SECRET" \
+ -H "content-type: application/json" \
+ -d '{"message": "Triage the newest open issue and draft a first response.", "title": "Issue triage"}'
+```
+
+A good response looks like:
+
+```json
+{ "ok": true, "token": "…192-bit token…", "taskId": "…card id…" }
+```
+
+Hang onto that `token`. To check what the hive did with it, `GET` the same endpoint:
+
+```bash
+curl -sS "https://your-tunnel-url.example" -H "x-md-webhook-token: YOUR_TOKEN"
+# → { "ok": true, "status": "…", "title": "Issue triage", "result": "…" }
+```
+
+The token is the *only* key to that task. A `GET` returns only the status, title, and result for the one task
+it maps to — it can't list or enumerate any other work. An unknown token gets the same `404` as a malformed
+one, so a probe can't tell "valid but unknown" from "wrong shape."
+
+## What the hive does with it
+
+Once a POST passes the secret check, the handler hands `{ message, title }` to the app, which **routes the
+message to god/Michael** — the orchestrator's inbox — and **files a stamped kanban card**. From there it's
+just another task: the orchestrator reads it, decides who should handle it, and dispatches to the right agent,
+exactly like work that arrives through [the hive's normal message
+routing](/blog/coordinating-ai-coding-agents/). A reviewer agent might read the PR; a writer might draft the
+issue response. The webhook doesn't pick the agent — it just gets the work onto the board.
+
+## Security, in one breath
+
+A public endpoint that can enqueue work for autonomous agents is exactly what you don't want strangers poking,
+so the handler treats every request as hostile until proven otherwise:
+
+- **Secret-gated, constant-time.** A POST must carry the exact secret in `x-md-webhook-secret`, compared in
+ constant time. A length mismatch fails immediately.
+- **Authenticate before buffering.** The secret is checked *before* the request body is read, so an
+ unauthenticated peer can't make the server buffer anything (within the cap).
+- **Bounded before any work.** A **1 MB body cap** and a **fixed-window rate limit** (120 requests/minute,
+ globally — the remote IP is the tunnel's, so per-IP would be meaningless) reject abuse ahead of any parse
+ or crypto.
+- **Capability tokens, not listings.** The 192-bit token a POST returns is unguessable, and a GET scoped to
+ it reveals only that single task.
+
+The secret stays local and is never logged, echoed, or forwarded. The principle is the one every trust
+boundary should follow: authenticate at the edge, fail closed, keep verification cheap and constant-time.
+
+## Why this fits a local-first hive
+
+It would've been easier to host this as a cloud function. Doing it as a **local** endpoint is the point. Your
+agents, their memory, and your git history never leave your machine — GitHub is only a *trigger*, a thin remote
+surface for starting and watching work. Nothing to deploy, nothing to pay for, no third party sitting between
+a repo event and your code. It's the same philosophy behind [local-first
+orchestration](/blog/local-first-ai-agent-orchestration/): keep the control plane on your box, and let the
+outside world knock politely at the door.
+
+Pair it with [scheduled missions](/blog/scheduling-autonomous-agent-missions/) and the picture rounds out:
+timers put recurring work in the queue, GitHub puts event-driven work in the queue, and the orchestrator runs
+both — whether or not you're watching.
+
+## FAQ
+
+**Can you trigger an AI agent from GitHub?** Yes — point a GitHub Action's curl (or any HTTP client) at the
+webhook URL with your secret in `x-md-webhook-secret` and a `{ message, title? }` body, and the orchestrator
+files a card and routes it to an agent.
+
+**Is it secure?** The secret is checked in constant time before the body is buffered, a 1 MB cap and a
+120/minute rate limit bound abuse first, and the POST returns a 192-bit capability token whose GET reveals only
+that one task. The secret is never logged or forwarded.
+
+**Do I need a public server?** No. The endpoint runs locally; a best-effort tunnel gives GitHub a URL to reach
+it, and the handler runs even if the tunnel doesn't.
+
+---
+
+Munder Difflin turns a GitHub event into a remote control for a hive that still lives entirely on your machine
+— [orchestrated by GOD](https://munderdiffl.in/#how), verified at the edge, queued like any other task.
+[Download Munder Difflin](https://munderdiffl.in/#install) to wire your repo into your agents; it's free and
+open source.
diff --git a/blog/src/posts/why-cli-agents-are-powerful.md b/blog/src/posts/why-cli-agents-are-powerful.md
new file mode 100644
index 00000000..db9d32bd
--- /dev/null
+++ b/blog/src/posts/why-cli-agents-are-powerful.md
@@ -0,0 +1,170 @@
+---
+title: "Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work"
+description: "CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it."
+date: 2026-06-10
+category: concepts
+categoryLabel: Concepts
+type: Technical
+primaryKeyword: "cli agents"
+secondaryKeywords: ["why cli agents are powerful", "terminal-level ai agents", "reduce agent token consumption", "local-first ai agents", "shared agent memory"]
+tags: ["Concepts", "Multi-Agent", "Local-First", "Cost", "CLI Agents"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Why are CLI agents more powerful than chat-only assistants?"
+ a: "Because a CLI agent has terminal-level access to the machine it runs on. It can read and write real files, run the build, run the tests, use git, and call any tool you have installed — then read the actual output and react to it. A chat assistant can only suggest a change; a CLI agent makes the change and proves it works by executing it. That closes the loop between proposing and verifying, which is the whole game in autonomous work."
+ - q: "Why does running CLI agents locally matter?"
+ a: "Local execution is what makes the terminal-level access real. The agent operates on your actual filesystem, your installed toolchain, and your git history — no upload, no sandbox copy, no round-trip to a vendor's environment. You also get privacy (code and data never leave the machine), and the agents can run 24/7 on hardware you already own instead of metered cloud compute."
+ - q: "How does Munder Difflin reduce token consumption?"
+ a: "Four structural levers. A shared memory layer and board so agents read context once instead of re-deriving it per turn. Scoped task contracts so each agent only loads what its job needs, not the whole project. A token-budget steward that paces and caps spend across the hive. And capability routing — sending routine work to a cheaper-tier agent and reserving the expensive orchestrator for reasoning — instead of one giant always-on context carrying everything."
+ - q: "Does a shared memory layer actually save tokens?"
+ a: "Yes, because the expensive part of an agent isn't the model — it's the context it re-reads every turn, multiplied across a whole team. When agents share a board and a memory layer, the project's facts, decisions, and state are derived once and recalled compactly, instead of each agent re-discovering them by re-reading files into its own window. In a fleet you pay context N times, so removing redundant re-derivation compounds."
+ - q: "Is Munder Difflin local-first and open source?"
+ a: "Yes. Munder Difflin is a local, 24/7 multi-agent CLI harness that runs as an Electron desktop app on your own computer. It drives the CLIs you already have — Claude Code, Codex, Antigravity — so there's no API key and no per-seat platform tax on top of model tokens. It's free and open source."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>CLI agents are powerful for one
+reason: terminal-level access.</strong> They don't just <em>suggest</em> edits — they read and write
+real files, run builds and tests, use git, call any installed tool, and <strong>verify their own work by
+actually executing it</strong>. Running them <strong>locally</strong> (as Munder Difflin does) is what
+makes that access real: your filesystem, your toolchain, your git history, private and on 24/7. And
+because a whole hive of these agents could get expensive, Munder Difflin cuts token consumption with four
+structural levers: a <strong>shared memory layer + board</strong>, <strong>scoped task contracts</strong>,
+a <strong>token-budget steward</strong>, and <strong>capability routing</strong> — so agents stop
+re-deriving context and stop paying frontier prices for routine work.</p></div>
+
+There's a quiet line that separates a *chat assistant* from an *agent*, and almost everyone draws it in
+the wrong place. It's not "how smart is the model." It's a much more boring question: **can the thing
+actually touch the machine?**
+
+A chat assistant lives behind a glass wall. You describe a problem, it describes a solution, and the
+handoff back to reality — applying the diff, running the build, reading the error, trying again — is
+*your* job. A CLI agent lives on the other side of that wall. It has a terminal. And a terminal changes
+everything.
+
+## The whole argument: terminal-level access closes the loop
+
+Give an AI a terminal on a real machine and a short, specific list of unlocks falls out:
+
+- **It reads and writes real files** — not a pasted snippet, the actual file on disk, in the actual
+ project, with the actual surrounding code.
+- **It runs the build and the tests** — and then *reads the output*. A failing test isn't a
+ hypothetical; it's a stack trace the agent can see and respond to.
+- **It uses git** — branches, diffs, commits, blame. It can inspect history to understand *why* code is
+ the way it is, and leave an audit trail of what it changed.
+- **It calls any tool you have installed** — your linter, your formatter, your package manager, your
+ deploy script, `curl`, `jq`, the CLI for your database. If it's on your `PATH`, it's in the agent's
+ hands.
+
+Each bullet is useful on its own. Together they do something a chat assistant structurally cannot:
+**they close the loop between proposing a change and verifying it.**
+
+This is the part worth slowing down on. A language model is extremely good at producing a *plausible*
+answer — "this should fix it, the build will pass now." Plausible is cheap. Plausible is also, often,
+wrong. The difference between a toy and a tool is whether the system can *check itself*, and checking
+requires execution. You can't verify a build is green by reasoning about it; you verify it by running it
+and reading the output. A CLI agent can do that. A chat assistant can only assert it. (We wrote a whole
+piece on this discipline: [how AI agents verify their own work before saying
+"done."](/blog/how-ai-agents-verify-their-own-work/))
+
+So the headline isn't "CLI agents can type commands." It's that **a terminal turns a generator into a
+worker** — something that can act, observe the consequence, and correct, in a tight loop, without a human
+shuttling output back and forth across the glass.
+
+## Local is what makes the access *real*
+
+Here's the catch people miss. Terminal-level access is only as powerful as the machine the terminal is
+attached to. And there's a real difference between an agent running in some vendor's ephemeral container
+and an agent running **on your own computer.**
+
+Run it locally and the access stops being a sandbox approximation and becomes the genuine article:
+
+- **Real filesystem.** The agent works on *your* repo, in place — not an uploaded copy, not a snapshot
+ that drifts out of sync. The file it edits is the file you ship.
+- **Real toolchain.** It uses the exact versions of the exact tools you have installed. The build that
+ passes for the agent is the build that passes for you, because it's the same build.
+- **Privacy.** Your code, your data, and your secrets never leave the machine to make this work. For a
+ lot of teams that's not a nice-to-have; it's the difference between "allowed" and "not allowed."
+- **24/7 on hardware you already own.** A local agent doesn't clock out and doesn't bill you for idle
+ compute. Close the lid, open it tomorrow, and the floor is still there.
+
+This is the bet **Munder Difflin** makes. It's a local, 24/7 multi-agent CLI harness — an Electron
+desktop app that runs a whole *virtual office* of Office-themed agents on your computer, collaborating
+through a shared board, inboxes, and memory. It doesn't replace your CLI agents; it **drives the ones you
+already have** — Claude Code, Codex, Antigravity — so the terminal-level access is real, local, and
+private by construction. (For the deeper case, see [why local-first matters for AI
+agents](/blog/why-local-first-matters-for-ai-agents/).)
+
+## But a hive of agents could get expensive — so here's how Munder Difflin doesn't
+
+Everything above is the upside. The honest downside of "run a whole office of agents" is the obvious one:
+**N agents, each running a powerful model, each carrying its own context, is N times the token bill.**
+Power that you can't afford isn't power.
+
+The naive design — one giant, always-on context that every agent shares and everyone re-reads on every
+turn — is exactly the design that bankrupts you. Munder Difflin is built the other way, around four
+structural levers that cut token consumption without dumbing the agents down. None of these are
+benchmark claims; they're architectural choices, and you can reason about why each one bends the curve.
+
+**1. A shared memory layer and board — so agents don't re-derive context.** The expensive part of an
+agent isn't the model call; it's the *context* it re-reads every turn, paid again for every agent in the
+fleet. When the hive shares a board and a [memory layer](/blog/markdown-first-agent-memory/), the
+project's facts, decisions, and current state are derived **once** and recalled compactly — instead of
+each agent independently re-discovering them by dragging files back into its own window. Redundant
+re-derivation is the single biggest avoidable cost in a multi-agent system, and shared memory is the
+direct fix.
+
+**2. Scoped task contracts — so each agent loads only what its job needs.** Instead of handing every
+agent the whole project and hoping it stays focused, work arrives as a *scoped contract*: here's the
+task, here's the slice of context that's relevant, here's what "done" looks like. The agent's window
+stays small because its job is small. This is [context discipline](/blog/context-engineering-for-ai-agents/)
+made structural — the harness scopes the context for you rather than relying on the model to ignore the
+parts it doesn't need (it won't, and you'd pay for them anyway).
+
+**3. A token-budget steward — so spend is paced and capped, not unbounded.** Autonomy without a budget is
+how you wake up to a surprise bill. Munder Difflin runs the hive against a token budget: a steward that
+paces work and caps consumption across the floor, so a long-running mission grinds along *within a
+ceiling* instead of sprinting until the meter screams. Predictable, attributable cost is part of what
+makes 24/7 operation safe to leave running.
+
+**4. Capability routing — so the right agent does the work, not the most expensive one.** The price
+spread between a small model and a frontier one is large, and most agent work is routine. So you route:
+the cheap-tier worker handles the routine majority, and the expensive orchestrator is reserved for the
+reasoning that actually needs it. One always-on giant context paying frontier rates for file-shuffling is
+pure waste; [routing work to the right-capability agent](/blog/do-more-with-less-model-routing/) is how a
+fleet costs *less* than the single over-powered agent it replaces.
+
+These compound. Shared memory removes the re-derivation, scoped contracts shrink each window, the steward
+caps the total, and routing keeps frontier prices off routine work. (For the full unified treatment, see
+[the multi-agent cost playbook](/blog/the-multi-agent-cost-playbook/).) The point isn't a magic discount
+— it's that a hive is only worth running if it's *engineered* to be affordable, and these are the
+mechanics that make it so.
+
+## The bottom line
+
+CLI agents are powerful because a terminal turns a model from a thing that *talks about* work into a
+thing that *does* work — reading files, running builds, using git, calling your tools, and verifying
+itself by execution. Local-first is what makes that access real, private, and always-on. And a
+shared-memory, scoped-contract, budgeted, capability-routed hive is what makes a *floor* of those agents
+something you can actually afford to leave running.
+
+That's Munder Difflin: a virtual office of CLI agents on your own computer — real access, real
+verification, fewer tokens. [Download it](https://munderdiffl.in/#install) — it's free, open source, and
+local-first.
+
+## FAQ
+
+**Why are CLI agents more powerful than chat-only assistants?** Terminal-level access. A CLI agent makes
+the change and proves it works by running it; a chat assistant can only suggest one. Execution closes the
+loop between proposing and verifying.
+
+**Why run them locally?** Local execution is what makes the access real — your actual filesystem,
+toolchain, and git history — plus privacy and 24/7 operation on hardware you own.
+
+**How does Munder Difflin cut token use?** Shared memory and a board (don't re-derive context), scoped
+task contracts (load only what the job needs), a token-budget steward (pace and cap spend), and
+capability routing (right agent, not the priciest one).
+
+Sources: [Anthropic — Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching);
+[Anthropic — Pricing](https://platform.claude.com/docs/en/about-claude/pricing).
diff --git a/docs/blog/agent-security-and-sandboxing/index.html b/docs/blog/agent-security-and-sandboxing/index.html
index ac40f30f..f0645703 100644
--- a/docs/blog/agent-security-and-sandboxing/index.html
+++ b/docs/blog/agent-security-and-sandboxing/index.html
@@ -272,56 +272,56 @@ git, lifecycle hooks, and an audit trail — so safe-by-default is the path of l
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/agents-rule-of-two/index.html b/docs/blog/agents-rule-of-two/index.html
index 83afcd5b..d8542b45 100644
--- a/docs/blog/agents-rule-of-two/index.html
+++ b/docs/blog/agents-rule-of-two/index.html
@@ -276,56 +276,56 @@ open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <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/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/do-more-with-less-model-routing/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
- <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/do-more-with-less-model-routing/" aria-label="Read: Do More With Less: Smart Model Routing Across Agents">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/ai-agent-glossary/index.html b/docs/blog/ai-agent-glossary/index.html
index 387f941c..a250e8e8 100644
--- a/docs/blog/ai-agent-glossary/index.html
+++ b/docs/blog/ai-agent-glossary/index.html
@@ -248,56 +248,56 @@ Munder Difflin</a> to see the glossary come to life — free and open source.</p
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/building-reliable-ai-agents/index.html b/docs/blog/building-reliable-ai-agents/index.html
index 285c9e26..1b894371 100644
--- a/docs/blog/building-reliable-ai-agents/index.html
+++ b/docs/blog/building-reliable-ai-agents/index.html
@@ -303,56 +303,56 @@ by design; it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/can-claude-code-agents-talk-to-each-other/index.html b/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
index a14a6331..7ad8d0e1 100644
--- a/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
+++ b/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
@@ -286,56 +286,56 @@ other; it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/do-more-with-less-model-routing/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
- <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/do-more-with-less-model-routing/" aria-label="Read: Do More With Less: Smart Model Routing Across Agents">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-automation-while-you-sleep/index.html b/docs/blog/claude-code-automation-while-you-sleep/index.html
index 8aa454c5..028dff92 100644
--- a/docs/blog/claude-code-automation-while-you-sleep/index.html
+++ b/docs/blog/claude-code-automation-while-you-sleep/index.html
@@ -291,56 +291,56 @@ while you sleep; it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
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 b99c1bd3..78e5a2a4 100644
--- a/docs/blog/claude-code-git-worktrees-vs-hive/index.html
+++ b/docs/blog/claude-code-git-worktrees-vs-hive/index.html
@@ -291,56 +291,56 @@ team; it’s free and open source.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>
- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free.</p>
+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>
+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-multi-agent-setup-tutorial/index.html b/docs/blog/claude-code-multi-agent-setup-tutorial/index.html
index 568212e0..1b57a896 100644
--- a/docs/blog/claude-code-multi-agent-setup-tutorial/index.html
+++ b/docs/blog/claude-code-multi-agent-setup-tutorial/index.html
@@ -280,56 +280,56 @@ coordinated team of Claude Code agents — it’s free, local, and open source.<
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-orchestration-guide/index.html b/docs/blog/claude-code-orchestration-guide/index.html
index d7214968..88386c00 100644
--- a/docs/blog/claude-code-orchestration-guide/index.html
+++ b/docs/blog/claude-code-orchestration-guide/index.html
@@ -289,43 +289,43 @@ agents; it’s free and open source.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
@@ -334,11 +334,11 @@ agents; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html b/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html
index 27c0de35..d972b64e 100644
--- a/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html
+++ b/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html
@@ -320,56 +320,56 @@ open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/context-engineering-for-ai-agents/index.html b/docs/blog/context-engineering-for-ai-agents/index.html
index 30554e1b..be8def57 100644
--- a/docs/blog/context-engineering-for-ai-agents/index.html
+++ b/docs/blog/context-engineering-for-ai-agents/index.html
@@ -308,56 +308,56 @@ it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/coordinating-ai-coding-agents/index.html b/docs/blog/coordinating-ai-coding-agents/index.html
index 12903820..572ee5f9 100644
--- a/docs/blog/coordinating-ai-coding-agents/index.html
+++ b/docs/blog/coordinating-ai-coding-agents/index.html
@@ -276,43 +276,43 @@ your own team of Claude Code agents.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
@@ -321,11 +321,11 @@ your own team of Claude Code agents.</p>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/debugging-multi-agent-systems/index.html b/docs/blog/debugging-multi-agent-systems/index.html
index 20da030c..3fbd7521 100644
--- a/docs/blog/debugging-multi-agent-systems/index.html
+++ b/docs/blog/debugging-multi-agent-systems/index.html
@@ -271,56 +271,56 @@ to run agents you can actually trace; it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/deploy-a-blog-writer-agent/index.html b/docs/blog/deploy-a-blog-writer-agent/index.html
new file mode 100644
index 00000000..40106fe7
--- /dev/null
+++ b/docs/blog/deploy-a-blog-writer-agent/index.html
@@ -0,0 +1,392 @@
+<!doctype html>
+<html lang="en">
+<head>
+<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." />
+<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" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<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: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" />
+<meta property="article:published_time" content="2026-06-10T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Use Cases" />
+<meta property="article:tag" content="Automation" />
+<meta property="article:tag" content="Content" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Open Source" />
+
+
+<!-- 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: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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@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.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-06-10T00:00:00.000Z",
+ "author": { "@type": "Person", "name": "Chaitanya Giri" },
+ "publisher": {
+ "@type": "Organization",
+ "name": "Munder Difflin",
+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
+ },
+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/deploy-a-blog-writer-agent/" },
+ "keywords": "automated blog writer agent, ai blog automation, content agent, multi-agent blogging, automated content pipeline",
+ "articleSection": "Use Cases",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/deploy-a-blog-writer-agent/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "Deploy a Blog-Writer Agent: The One That Wrote This Post", "item": "https://munderdiffl.in/blog/deploy-a-blog-writer-agent/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@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": "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": "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." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <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>
+ <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-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>6 min read</span>
+ <span class="tag kind">Use Cases</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <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
+<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>
+<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
+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
+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
+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>
+<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>
+<h3 id="1-draft-in-an-isolated-worktree" tabindex="-1">1. Draft — in an isolated worktree <a class="anchor" href="#1-draft-in-an-isolated-worktree" aria-hidden="true">#</a></h3>
+<p>The writer agent gets a <strong>brief</strong> (a topic + intent, usually straight from our SEO backlog) and a
+<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
+<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
+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>
+<h3 id="3-build-eleventy-turns-markdown-into-a-site" tabindex="-1">3. Build — Eleventy turns markdown into a site <a class="anchor" href="#3-build-eleventy-turns-markdown-into-a-site" aria-hidden="true">#</a></h3>
+<p>A static <a href="https://www.11ty.dev/">Eleventy</a> build compiles <code>blog/src/posts</code> → <code>docs/blog</code>. Dropping one
+markdown file is the entire authoring action: the build auto-adds the post to the index, its topic page,
+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>
+<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
+deploy. The orchestrator <a href="/blog/how-the-god-orchestrator-works/">escalates exactly this kind of “publish to the world”
+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>
+<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>
+<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,
+then put the <strong>deploy</strong> behind a human approval. Draft and integrate automatically; publish on a click.</p>
+<p><strong>5. Make it recurring.</strong> The real unlock is a scheduled mission: fire the writer on a cadence, feeding it
+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>
+<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>
+<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>
+<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.
+<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>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <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>
+ </div>
+
+ <div class="qa">
+ <p class="q">Is the blog-writer agent fully autonomous?</p>
+ <p class="a">Almost — it&#39;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.</p>
+ </div>
+
+ <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>
+ </div>
+
+ <div class="qa">
+ <p class="q">Why use a multi-agent hive instead of one prompt to write blog posts?</p>
+ <p class="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.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/use-cases/">Use Cases</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/content/">Content</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/open-source/">Open Source</a>
+ </div>
+
+ </div>
+
+
+ <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>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/deploy-automated-pr-reviewer-agent/"><span class="k">← Older</span><span class="t">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</span></a>
+ <span></span>
+ </div>
+ <section class="related">
+ <h2>Related in Use Cases</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-04">Jun 4, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
+ <div class="foot">
+ <span class="tag kind">Use Cases</span>
+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-02">Jun 2, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>3 min</span>
+ </div>
+ <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
+ <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
+ <div class="foot">
+ <span class="tag kind">Use Cases</span>
+ <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-02">Jun 2, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>3 min</span>
+ </div>
+ <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>
+ <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>
+ <div class="foot">
+ <span class="tag kind">Use Cases</span>
+ <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/deploy-automated-pr-reviewer-agent/index.html b/docs/blog/deploy-automated-pr-reviewer-agent/index.html
new file mode 100644
index 00000000..a3ff2caa
--- /dev/null
+++ b/docs/blog/deploy-automated-pr-reviewer-agent/index.html
@@ -0,0 +1,348 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Deploy a PR Reviewer That Never Sleeps — In About One Prompt — Munder Difflin Blog</title>
+<meta name="description" content="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." />
+<link rel="canonical" href="https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="Deploy a PR Reviewer That Never Sleeps — In About One Prompt — Munder Difflin Blog" />
+<meta property="og:description" content="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." />
+<meta property="og:url" content="https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+<meta property="article:published_time" content="2026-06-10T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Orchestration" />
+<meta property="article:tag" content="Automation" />
+<meta property="article:tag" content="Code Review" />
+<meta property="article:tag" content="Open Source" />
+<meta property="article:tag" content="Hive" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Deploy a PR Reviewer That Never Sleeps — In About One Prompt — Munder Difflin Blog" />
+<meta name="twitter:description" content="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." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "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.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-06-10T00:00:00.000Z",
+ "author": { "@type": "Person", "name": "Chaitanya Giri" },
+ "publisher": {
+ "@type": "Organization",
+ "name": "Munder Difflin",
+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
+ },
+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/" },
+ "keywords": "automated pr reviewer agent, deploy pr review bot, coderabbit alternative self-hosted, ai github issue triage, local pr review agent",
+ "articleSection": "Orchestration",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "Deploy a PR Reviewer That Never Sleeps — In About One Prompt", "item": "https://munderdiffl.in/blog/deploy-automated-pr-reviewer-agent/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@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": "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." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/orchestration/">Orchestration</a>
+ </nav>
+ <h1>Deploy a PR Reviewer That Never Sleeps — In About One Prompt</h1>
+ <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>
+ <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-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>6 min read</span>
+ <span class="tag kind">Orchestration</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>You can stand up a <strong>fully automated PR-reviewing agent</strong> in Munder Difflin in about one prompt: give it an objective, point it at your repo and open PRs, and let it review against the <em>real source</em>, post comments, and escalate only what matters. Ours recently triaged <strong>5 new bug reports against the v0.2.4 release, consolidated 22 duplicate breaker firings into clean signal</strong>, and surfaced a HIGH-severity Windows-terminal regression plus a 3-issue lifecycle bug cluster sharing one root cause — all verified against source, with fixes specified and a human pinged. That triage became the v0.2.5 patch queue. Here's how to deploy your own.</p></div>
+<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>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>
+<li><strong>It sees the whole backlog at once.</strong> Reading the full set of open issues plus shared hive memory, it can notice that issues #41, #43, and #47 are three faces of the same bug — rather than reviewing each in a vacuum.</li>
+<li><strong>It escalates through the same inbox you use.</strong> A serious finding becomes a message to you, routed like any other hive mail. No separate alerting system.</li>
+</ul>
+<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>
+<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>
+<p>That single instruction is doing three jobs, and the orchestrator decomposes them:</p>
+<ol>
+<li><strong>Spin up a dedicated agent.</strong> The orchestrator creates a <code>pr-reviewer</code> worker scoped to this objective — a specialist that does one thing well, instead of a general agent context-switching between code review and everything else.</li>
+<li><strong>Run the first pass now.</strong> It reviews the current open PRs and issues immediately, against the checked-out source, and posts comments.</li>
+<li><strong>Make it recurring.</strong> It registers a <a href="/blog/scheduling-autonomous-agent-missions/">scheduled mission</a> — a small persisted record with an interval and a target agent — that re-fires the reviewer every hour. New PRs get reviewed on the next tick without you touching a keyboard.</li>
+</ol>
+<p>The whole job description was the prompt. There’s no workflow file, no webhook to register, no CI secret to wire. (If you’ve seen our <a href="/blog/one-prompt-automated-pr-review/">one-prompt dogfooding story</a>, this is the same mechanism, pointed at a tougher problem.)</p>
+<h3 id="the-three-knobs-worth-setting-explicitly" tabindex="-1">The three knobs worth setting explicitly <a class="anchor" href="#the-three-knobs-worth-setting-explicitly" aria-hidden="true">#</a></h3>
+<p>The default behavior is good, but three things are worth naming in your brief so the agent’s judgment matches yours:</p>
+<ul>
+<li><strong>The objective.</strong> “Review for correctness and regressions against the released source” produces sharper reviews than “review the PRs.” Tell it what <em>good</em> means for your repo.</li>
+<li><strong>The escalation bar.</strong> Say what earns a human ping — “HIGH severity or anything touching data loss.” Everything below the bar gets a posted comment and nothing more. This is what keeps it from becoming a notification firehose.</li>
+<li><strong>The de-dupe instruction.</strong> “Consolidate duplicate reports into one finding” turns a pile of redundant issues into signal. Without it, you get one review per issue; with it, you get one review per <em>bug</em>.</li>
+</ul>
+<h2 id="case-study-a-messy-day-triaged" tabindex="-1">Case study: a messy day, triaged <a class="anchor" href="#case-study-a-messy-day-triaged" aria-hidden="true">#</a></h2>
+<p>Here’s what that deployment looked like on a real run against our own repo, right after the v0.2.4 release.</p>
+<p>Five new user bug reports had come in. On the surface that’s five reviews. Underneath, the issue tracker was a mess: <strong>22 separate breaker and duplicate firings</strong> — the same crashes and complaints reported multiple times, in slightly different words, by different users hitting the same code paths. A human triaging that by hand burns an afternoon just figuring out what’s actually distinct.</p>
+<p>The PR Reviewer agent did the figuring. It read all five reports plus the surrounding issues against the v0.2.4 source, and <strong>consolidated the 22 firings down to two real findings</strong>:</p>
+<ul>
+<li><strong>A HIGH-severity Windows-terminal regression.</strong> Verified directly against the released source — not inferred from the report. The agent traced the failing path, confirmed the regression was real and recent, specified the fix, and <strong>escalated it to the human</strong> because it crossed the severity bar.</li>
+<li><strong>A 3-issue agent-lifecycle bug cluster sharing one root cause.</strong> Three separately-filed issues that all bottomed out in the same lifecycle bug. The agent named the shared root cause, specified the fix once, and grouped the three issues under it — so what looked like three problems was correctly understood as one.</li>
+</ul>
+<p>For each, it <strong>posted a review comment on the relevant issues/PRs</strong>, and pinged me only for the parts that mattered. The rest — the seventeen-odd duplicates — got folded into the two findings instead of generating seventeen more notifications.</p>
+<p>That triage <em>became the v0.2.5 patch queue.</em> I didn’t assemble it. I read two clear findings with fixes already specified, against source I trusted because the agent had read it too.</p>
+<h3 id="why-the-consolidation-is-the-real-win" tabindex="-1">Why the consolidation is the real win <a class="anchor" href="#why-the-consolidation-is-the-real-win" aria-hidden="true">#</a></h3>
+<p>It’s tempting to frame this as “it reviewed PRs fast.” But the load-bearing part is the <strong>de-noising</strong>: 22 → 2. A reviewer that comments on everything just moves the triage burden into your inbox. A reviewer that reads the whole backlog, verifies against source, and collapses duplicates into root causes does the part of code review that’s actually hard — deciding <em>what’s true and what’s distinct</em> — and hands you the short list.</p>
+<p>That’s the difference between an automated commenter and an automated <em>reviewer</em>.</p>
+<h2 id="what-to-be-honest-about" tabindex="-1">What to be honest about <a class="anchor" href="#what-to-be-honest-about" aria-hidden="true">#</a></h2>
+<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>
+</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>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>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <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>
+ </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>
+ </div>
+
+ <div class="qa">
+ <p class="q">Will it spam every PR with low-value comments?</p>
+ <p class="a">It doesn&#39;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.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Is this a cloud service?</p>
+ <p class="a">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.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/code-review/">Code Review</a><a class="tag" href="/blog/tags/open-source/">Open Source</a><a class="tag" href="/blog/tags/hive/">Hive</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#what-pr-reviewer-agent-actually-means-here">What “PR Reviewer agent” actually means here</a></li><li class="lvl-2"><a href="#deploying-it-the-one-prompt-version">Deploying it: the one-prompt version</a></li><li class="lvl-3"><a href="#the-three-knobs-worth-setting-explicitly">The three knobs worth setting explicitly</a></li><li class="lvl-2"><a href="#case-study-a-messy-day-triaged">Case study: a messy day, triaged</a></li><li class="lvl-3"><a href="#why-the-consolidation-is-the-real-win">Why the consolidation is the real win</a></li><li class="lvl-2"><a href="#what-to-be-honest-about">What to be honest about</a></li><li class="lvl-2"><a href="#deploy-yours">Deploy yours</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/run-ai-agent-hive-from-slack-setup/"><span class="k">← Older</span><span class="t">Run Your AI Agent Hive from Slack: The Complete Setup</span></a>
+ <a class="pn next" href="/blog/deploy-a-blog-writer-agent/"><span class="k">Newer →</span><span class="t">Deploy a Blog-Writer Agent: The One That Wrote This Post</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Orchestration</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-05">Jun 5, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-04">Jun 4, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-04">Jun 4, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/do-more-with-less-model-routing/index.html b/docs/blog/do-more-with-less-model-routing/index.html
index eb145070..bb7a78dc 100644
--- a/docs/blog/do-more-with-less-model-routing/index.html
+++ b/docs/blog/do-more-with-less-model-routing/index.html
@@ -275,56 +275,56 @@ agent team that does more with less — it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/index.html b/docs/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/index.html
index 1fb99d80..b871d95b 100644
--- a/docs/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/index.html
+++ b/docs/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/index.html
@@ -266,56 +266,56 @@ rides your existing Claude subscription. Local-first, on your own plan, no surpr
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</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>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/mcp-security-tool-poisoning/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/mcp-security-tool-poisoning/">MCP Tool Poisoning: How to Secure the Model Context Protocol</a></h3>
- <p class="dek">How the Model Context Protocol gets attacked — tool poisoning, rug pulls, command injection — and the layered defenses that secure your MCP tools.</p>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/mcp-security-tool-poisoning/" aria-label="Read: MCP Tool Poisoning: How to Secure the Model Context Protocol">Read →</a>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/evaluating-ai-agent-reliability/index.html b/docs/blog/evaluating-ai-agent-reliability/index.html
index 5d112b1f..9f61cc03 100644
--- a/docs/blog/evaluating-ai-agent-reliability/index.html
+++ b/docs/blog/evaluating-ai-agent-reliability/index.html
@@ -274,56 +274,56 @@ your bar.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/feed.xml b/docs/blog/feed.xml
index e8ca3aa2..d6f90dc5 100644
--- a/docs/blog/feed.xml
+++ b/docs/blog/feed.xml
@@ -4,9 +4,57 @@
<subtitle>Guides, deep dives, and comparisons on running multi-agent Claude Code: orchestration, agent memory, automation, and the tooling landscape.</subtitle>
<link href="https://munderdiffl.in/blog/feed.xml" rel="self" />
<link href="https://munderdiffl.in/blog/" />
- <updated>2026-06-09T00:00:00.000Z</updated>
+ <updated>2026-06-10T00:00:00.000Z</updated>
<id>https://munderdiffl.in/blog/</id>
<author><name>Chaitanya Giri</name><uri>https://munderdiffl.in</uri></author>
+ <entry>
+ <title>Deploy a Blog-Writer Agent: The One That Wrote This Post</title>
+ <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>
+ </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" />
+ <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>
+ <title>Run Your AI Agent Hive from Slack: The Complete Setup</title>
+ <link href="https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/" />
+ <id>https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/</id>
+ <published>2026-06-10T00:00:00.000Z</published>
+ <updated>2026-06-10T00:00:00.000Z</updated><category term="Guides" />
+ <summary>Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</summary>
+ </entry>
+ <entry>
+ <title>The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</title>
+ <link href="https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" />
+ <id>https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/</id>
+ <published>2026-06-10T00:00:00.000Z</published>
+ <updated>2026-06-10T00:00:00.000Z</updated><category term="Concepts" />
+ <summary>Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</summary>
+ </entry>
+ <entry>
+ <title>How to Trigger Your AI Agent Hive from a GitHub Webhook</title>
+ <link href="https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/" />
+ <id>https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/</id>
+ <published>2026-06-10T00:00:00.000Z</published>
+ <updated>2026-06-10T00:00:00.000Z</updated><category term="Guides" />
+ <summary>Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</summary>
+ </entry>
+ <entry>
+ <title>Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</title>
+ <link href="https://munderdiffl.in/blog/why-cli-agents-are-powerful/" />
+ <id>https://munderdiffl.in/blog/why-cli-agents-are-powerful/</id>
+ <published>2026-06-10T00:00:00.000Z</published>
+ <updated>2026-06-10T00:00:00.000Z</updated><category term="Concepts" />
+ <summary>CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</summary>
+ </entry>
<entry>
<title>Launching Munder Difflin v0.2.4</title>
<link href="https://munderdiffl.in/blog/launching-munder-difflin-v0-2-4/" />
@@ -439,52 +487,4 @@
<updated>2026-06-03T00:00:00.000Z</updated><category term="Internals" />
<summary>A practical tour of Claude Code hooks — the PreToolUse, PostToolUse, and Stop lifecycle — and how a Unix-socket hook shim drives a live office floor.</summary>
</entry>
- <entry>
- <title>Looking for a Claude Squad Alternative?</title>
- <link href="https://munderdiffl.in/blog/claude-squad-alternative/" />
- <id>https://munderdiffl.in/blog/claude-squad-alternative/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Comparisons" />
- <summary>What Claude Squad does well, where it stops, and why a memory-backed, orchestrated hive may be the Claude Squad alternative you&#39;re after.</summary>
- </entry>
- <entry>
- <title>A Conductor Alternative for Orchestrating Claude Code</title>
- <link href="https://munderdiffl.in/blog/conductor-claude-code-alternative/" />
- <id>https://munderdiffl.in/blog/conductor-claude-code-alternative/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Comparisons" />
- <summary>Conductor is a polished macOS app for parallel Claude Code worktrees. When to pick a cross-platform, orchestrated hive as your Conductor alternative.</summary>
- </entry>
- <entry>
- <title>A Crystal Alternative: Multi-Agent Claude Code with Memory</title>
- <link href="https://munderdiffl.in/blog/crystal-claude-code-alternative/" />
- <id>https://munderdiffl.in/blog/crystal-claude-code-alternative/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Comparisons" />
- <summary>Crystal runs parallel Claude Code worktrees well. Where a memory-backed, orchestrated hive changes the workflow — and when to stick with Crystal.</summary>
- </entry>
- <entry>
- <title>Bringing Your MCP Servers and Skills Into a Hive of Agents</title>
- <link href="https://munderdiffl.in/blog/mcp-and-skills-in-a-hive/" />
- <id>https://munderdiffl.in/blog/mcp-and-skills-in-a-hive/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Guides" />
- <summary>How agents in a hive inherit your existing Claude Code MCP servers, skills, and tools — and how to scope which agent gets which capability.</summary>
- </entry>
- <entry>
- <title>Real Terminals in Electron with node-pty</title>
- <link href="https://munderdiffl.in/blog/node-pty-electron-real-terminals/" />
- <id>https://munderdiffl.in/blog/node-pty-electron-real-terminals/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Internals" />
- <summary>How to run byte-for-byte authentic shells inside Electron with node-pty: the native-rebuild gotcha, the macOS PATH trap, and streaming PTY output over IPC.</summary>
- </entry>
- <entry>
- <title>Rendering Many Live Terminals Without Melting the CPU</title>
- <link href="https://munderdiffl.in/blog/rendering-many-live-terminals-performance/" />
- <id>https://munderdiffl.in/blog/rendering-many-live-terminals-performance/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Internals" />
- <summary>xterm.js performance for many live PTYs: a terminal pool, render-only-visible, smart scrollback, and accelerated rendering to stream dozens at once.</summary>
- </entry>
</feed>
diff --git a/docs/blog/from-one-terminal-to-a-team/index.html b/docs/blog/from-one-terminal-to-a-team/index.html
index 8332e1a0..71792274 100644
--- a/docs/blog/from-one-terminal-to-a-team/index.html
+++ b/docs/blog/from-one-terminal-to-a-team/index.html
@@ -249,43 +249,43 @@ jump; it’s free and open source.</p>
<h2>Related in Use Cases</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
- <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
+ <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>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
+ <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>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-02">Jun 2, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>3 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>
- <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>
+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>
+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/why-local-first-matters-for-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
@@ -294,11 +294,11 @@ jump; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>3 min</span>
</div>
- <h3><a href="/blog/why-local-first-matters-for-ai-agents/">Why Local-First Matters for Your AI Agents</a></h3>
- <p class="dek">The control, privacy, and cost case for keeping your AI agents and their memory on your own machine — and what cloud orchestration quietly costs.</p>
+ <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>
+ <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/why-local-first-matters-for-ai-agents/" aria-label="Read: Why Local-First Matters for Your AI Agents">Read →</a>
+ <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/generative-engine-optimization-techniques/index.html b/docs/blog/generative-engine-optimization-techniques/index.html
index a220a37a..cc277523 100644
--- a/docs/blog/generative-engine-optimization-techniques/index.html
+++ b/docs/blog/generative-engine-optimization-techniques/index.html
@@ -280,43 +280,43 @@ and quotable. <a href="/#install">Download Munder Difflin</a> to see it; free an
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <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/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/do-more-with-less-model-routing/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -325,11 +325,11 @@ and quotable. <a href="/#install">Download Munder Difflin</a> to see it; free an
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
- <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
+ <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/do-more-with-less-model-routing/" aria-label="Read: Do More With Less: Smart Model Routing Across Agents">Read →</a>
+ <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/how-ai-agents-verify-their-own-work/index.html b/docs/blog/how-ai-agents-verify-their-own-work/index.html
index 0857cac9..c17a8006 100644
--- a/docs/blog/how-ai-agents-verify-their-own-work/index.html
+++ b/docs/blog/how-ai-agents-verify-their-own-work/index.html
@@ -274,56 +274,56 @@ and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/how-the-god-orchestrator-works/index.html b/docs/blog/how-the-god-orchestrator-works/index.html
index af99c816..bbdddc90 100644
--- a/docs/blog/how-the-god-orchestrator-works/index.html
+++ b/docs/blog/how-the-god-orchestrator-works/index.html
@@ -318,43 +318,43 @@ to put one in charge of your floor; it’s free and open source.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
@@ -363,11 +363,11 @@ to put one in charge of your floor; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
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 0408e900..9f9c591c 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
@@ -404,56 +404,56 @@ task.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/mcp-security-tool-poisoning/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/mcp-security-tool-poisoning/">MCP Tool Poisoning: How to Secure the Model Context Protocol</a></h3>
- <p class="dek">How the Model Context Protocol gets attacked — tool poisoning, rug pulls, command injection — and the layered defenses that secure your MCP tools.</p>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/mcp-security-tool-poisoning/" aria-label="Read: MCP Tool Poisoning: How to Secure the Model Context Protocol">Read →</a>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/how-to-run-multiple-claude-code-agents/index.html b/docs/blog/how-to-run-multiple-claude-code-agents/index.html
index 27395ba3..a4a1077d 100644
--- a/docs/blog/how-to-run-multiple-claude-code-agents/index.html
+++ b/docs/blog/how-to-run-multiple-claude-code-agents/index.html
@@ -215,56 +215,56 @@ free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
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 8c16a83a..f76d34fa 100644
--- a/docs/blog/human-in-the-loop-ai-agents/index.html
+++ b/docs/blog/human-in-the-loop-ai-agents/index.html
@@ -279,43 +279,43 @@ and ask only when they should; it’s free and open source.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
@@ -324,11 +324,11 @@ and ask only when they should; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/human-in-the-loop-approving-ai-agents/index.html b/docs/blog/human-in-the-loop-approving-ai-agents/index.html
index 4b08637d..9ba9e1f0 100644
--- a/docs/blog/human-in-the-loop-approving-ai-agents/index.html
+++ b/docs/blog/human-in-the-loop-approving-ai-agents/index.html
@@ -271,56 +271,56 @@ you talk to? You can <a href="/#install">download Munder Difflin</a> free; it’
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/index.html b/docs/blog/index.html
index d44661f6..a2fc3e6a 100644
--- a/docs/blog/index.html
+++ b/docs/blog/index.html
@@ -85,43 +85,43 @@
building a self-coordinating hive of agents with a GOD orchestrator you talk to.</p>
<div class="filters" role="navigation" aria-label="Topics">
- <a class="chip" aria-current="page">All<span class="ct">85</span></a>
+ <a class="chip" aria-current="page">All<span class="ct">91</span></a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
<div class="wrap featured"><article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
- <span>STORY</span>
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
- <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <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>
<div class="foot">
- <span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ <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>
</div>
</div>
</article>
@@ -132,6 +132,114 @@
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-09">Jun 9, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
+ <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/launching-munder-difflin-v0-2-4/index.html b/docs/blog/launching-munder-difflin-v0-2-4/index.html
index bc3f940a..0619301d 100644
--- a/docs/blog/launching-munder-difflin-v0-2-4/index.html
+++ b/docs/blog/launching-munder-difflin-v0-2-4/index.html
@@ -261,7 +261,7 @@
<footer class="post-foot wrap"><div class="prevnext">
<a class="pn prev" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/"><span class="k">← Older</span><span class="t">Munder Difflin v0.2.4 Feature Walkthrough</span></a>
- <span></span>
+ <a class="pn next" href="/blog/why-cli-agents-are-powerful/"><span class="k">Newer →</span><span class="t">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</span></a>
</div>
<section class="related">
<h2>Related in Story</h2>
diff --git a/docs/blog/local-first-ai-agent-orchestration/index.html b/docs/blog/local-first-ai-agent-orchestration/index.html
index d658bf97..2c74ff2f 100644
--- a/docs/blog/local-first-ai-agent-orchestration/index.html
+++ b/docs/blog/local-first-ai-agent-orchestration/index.html
@@ -286,56 +286,56 @@ loop; it’s free and open source.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>
- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/long-running-agents-the-2026-shift/index.html b/docs/blog/long-running-agents-the-2026-shift/index.html
index d408ce23..084d65a7 100644
--- a/docs/blog/long-running-agents-the-2026-shift/index.html
+++ b/docs/blog/long-running-agents-the-2026-shift/index.html
@@ -294,56 +294,56 @@ source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/manage-multiple-claude-code-sessions/index.html b/docs/blog/manage-multiple-claude-code-sessions/index.html
index 32547088..8fc4349c 100644
--- a/docs/blog/manage-multiple-claude-code-sessions/index.html
+++ b/docs/blog/manage-multiple-claude-code-sessions/index.html
@@ -268,56 +268,56 @@ isolated agents, shared memory, and a single committer, all on your own machine.
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/mcp-and-skills-in-a-hive/index.html b/docs/blog/mcp-and-skills-in-a-hive/index.html
index e62b3de8..8a8e3a38 100644
--- a/docs/blog/mcp-and-skills-in-a-hive/index.html
+++ b/docs/blog/mcp-and-skills-in-a-hive/index.html
@@ -284,56 +284,56 @@ existing setup into a coordinated team of agents; it’s free and open source.</
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/mcp-security-tool-poisoning/index.html b/docs/blog/mcp-security-tool-poisoning/index.html
index 1f3a091b..36b23053 100644
--- a/docs/blog/mcp-security-tool-poisoning/index.html
+++ b/docs/blog/mcp-security-tool-poisoning/index.html
@@ -273,56 +273,56 @@ execution. Do that and MCP is what it should be: a powerful, <em>bounded</em> wa
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/multi-agent-orchestration-patterns/index.html b/docs/blog/multi-agent-orchestration-patterns/index.html
index 54f7d18b..3c055ca3 100644
--- a/docs/blog/multi-agent-orchestration-patterns/index.html
+++ b/docs/blog/multi-agent-orchestration-patterns/index.html
@@ -284,25 +284,25 @@ across a team you can actually see? You can <a href="/#install">download Munder
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
@@ -311,29 +311,29 @@ across a team you can actually see? You can <a href="/#install">download Munder
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>
- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free.</p>
+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>
+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/munder-difflin-faq/index.html b/docs/blog/munder-difflin-faq/index.html
index faa551e5..03d6f7c4 100644
--- a/docs/blog/munder-difflin-faq/index.html
+++ b/docs/blog/munder-difflin-faq/index.html
@@ -266,56 +266,56 @@ free, open source, and local-first.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/munder-difflin-v0-2-4-feature-walkthrough/index.html b/docs/blog/munder-difflin-v0-2-4-feature-walkthrough/index.html
index 844d4a89..c149886a 100644
--- a/docs/blog/munder-difflin-v0-2-4-feature-walkthrough/index.html
+++ b/docs/blog/munder-difflin-v0-2-4-feature-walkthrough/index.html
@@ -249,56 +249,56 @@
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</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>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/mcp-security-tool-poisoning/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-06">Jun 6, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/mcp-security-tool-poisoning/">MCP Tool Poisoning: How to Secure the Model Context Protocol</a></h3>
- <p class="dek">How the Model Context Protocol gets attacked — tool poisoning, rug pulls, command injection — and the layered defenses that secure your MCP tools.</p>
+ <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
+ <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/mcp-security-tool-poisoning/" aria-label="Read: MCP Tool Poisoning: How to Secure the Model Context Protocol">Read →</a>
+ <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/open-source-ai-tools-on-purpose/index.html b/docs/blog/open-source-ai-tools-on-purpose/index.html
index 8a5c887f..31ae9cb6 100644
--- a/docs/blog/open-source-ai-tools-on-purpose/index.html
+++ b/docs/blog/open-source-ai-tools-on-purpose/index.html
@@ -267,56 +267,56 @@ autonomous. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/overnight-ai-coding-realistic-expectations/index.html b/docs/blog/overnight-ai-coding-realistic-expectations/index.html
index 26cf5fee..34b2c97a 100644
--- a/docs/blog/overnight-ai-coding-realistic-expectations/index.html
+++ b/docs/blog/overnight-ai-coding-realistic-expectations/index.html
@@ -290,25 +290,25 @@ work on isolated branches, escalate the decisions that matter, and leave a reada
<h2>Related in Use Cases</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-02">Jun 2, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>3 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
- <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
+ <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>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
+ <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>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
@@ -317,16 +317,16 @@ work on isolated branches, escalate the decisions that matter, and leave a reada
<span class="dot" aria-hidden="true"></span>
<span>3 min</span>
</div>
- <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>
- <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>
+ <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
+ <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>
+ <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/why-local-first-matters-for-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
@@ -335,11 +335,11 @@ work on isolated branches, escalate the decisions that matter, and leave a reada
<span class="dot" aria-hidden="true"></span>
<span>3 min</span>
</div>
- <h3><a href="/blog/why-local-first-matters-for-ai-agents/">Why Local-First Matters for Your AI Agents</a></h3>
- <p class="dek">The control, privacy, and cost case for keeping your AI agents and their memory on your own machine — and what cloud orchestration quietly costs.</p>
+ <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>
+ <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/why-local-first-matters-for-ai-agents/" aria-label="Read: Why Local-First Matters for Your AI Agents">Read →</a>
+ <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/prompt-caching-for-ai-agents/index.html b/docs/blog/prompt-caching-for-ai-agents/index.html
index 2bc55102..feba0cc5 100644
--- a/docs/blog/prompt-caching-for-ai-agents/index.html
+++ b/docs/blog/prompt-caching-for-ai-agents/index.html
@@ -303,56 +303,56 @@ that doesn’t waste your tokens; it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/run-ai-agent-hive-from-slack-setup/index.html b/docs/blog/run-ai-agent-hive-from-slack-setup/index.html
new file mode 100644
index 00000000..7f64d4f1
--- /dev/null
+++ b/docs/blog/run-ai-agent-hive-from-slack-setup/index.html
@@ -0,0 +1,428 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Run Your AI Agent Hive from Slack: The Complete Setup — Munder Difflin Blog</title>
+<meta name="description" content="Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread." />
+<link rel="canonical" href="https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="Run Your AI Agent Hive from Slack: The Complete Setup — Munder Difflin Blog" />
+<meta property="og:description" content="Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread." />
+<meta property="og:url" content="https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+<meta property="article:published_time" content="2026-06-10T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Guides" />
+<meta property="article:tag" content="Automation" />
+<meta property="article:tag" content="Slack" />
+<meta property="article:tag" content="Hive" />
+<meta property="article:tag" content="Setup" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Run Your AI Agent Hive from Slack: The Complete Setup — Munder Difflin Blog" />
+<meta name="twitter:description" content="Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "Run Your AI Agent Hive from Slack: The Complete Setup",
+ "description": "Step-by-step setup for driving Munder Difflin's AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-06-10T00:00:00.000Z",
+ "author": { "@type": "Person", "name": "Chaitanya Giri" },
+ "publisher": {
+ "@type": "Organization",
+ "name": "Munder Difflin",
+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
+ },
+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/" },
+ "keywords": "slack ai agent setup, slack bot ai agents, slack events api webhook, trigger agents from slack, slack app mention bot",
+ "articleSection": "Guides",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "Run Your AI Agent Hive from Slack: The Complete Setup", "item": "https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "How do I connect Slack to Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "Create a Slack app at api.slack.com/apps, grant the bot the chat:write, channels:history, and groups:history scopes, install it, then paste the Signing Secret and Bot User OAuth Token into Munder Difflin's Settings. Enable Slack, copy the public tunnel Request URL the app gives you into Slack's Event Subscriptions, and subscribe to app_mention plus message events. @mention the bot in a channel to start work." } },
+ { "@type": "Question", "name": "Which Slack scopes does the hive need?", "acceptedAnswer": { "@type": "Answer", "text": "Three Bot Token Scopes: chat:write (so the bot can post done-summaries back in-thread), channels:history and groups:history (so Slack delivers the message and thread-reply events the hive listens to). The Signing Secret authenticates every inbound request; the xoxb- Bot User OAuth Token authorizes the bot's replies." } },
+ { "@type": "Question", "name": "Why did Slack stop triggering my agents?", "acceptedAnswer": { "@type": "Answer", "text": "The public Request URL comes from a local tunnel that is ephemeral — it rotates every time you stop and start the app. If triggers go quiet, restart Munder Difflin, copy the new tunnel URL, and re-paste it into Slack's Event Subscriptions → Request URL. Slack re-verifies and triggers resume." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/guides/">Guides</a>
+ </nav>
+ <h1>Run Your AI Agent Hive from Slack: The Complete Setup</h1>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</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-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>7 min read</span>
+ <span class="tag kind">Guides</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>This is the full, working setup for driving your
+<strong>Munder Difflin</strong> hive from Slack. Create a Slack app, add three bot scopes
+(<code>chat:write</code>, <code>channels:history</code>, <code>groups:history</code>), paste the
+<strong>Signing Secret</strong> and <strong>Bot User OAuth Token</strong> into Settings, then drop the
+app's public <strong>tunnel Request URL</strong> into Slack's Event Subscriptions and subscribe to
+<code>app_mention</code> + <code>message</code> events. <strong>@mention the bot</strong> to kick off
+work; the office replies in-thread, ingests file attachments, and posts a done-summary when the task
+finishes. One quirk to remember: that tunnel URL rotates on restart.</p></div>
+<p>Munder Difflin runs a virtual office of AI agents on your own machine. Most days you drive that office
+from the desktop app. But the request often starts somewhere else — a teammate asks in a channel, or
+you’re away from your desk and want to kick off a run from your phone. The Slack integration closes that
+gap: <strong>@mention your bot in Slack, and the message becomes work for your hive.</strong> When the task finishes,
+a summary posts straight back into the same thread.</p>
+<p>This is a complete how-to for the setup that’s live right now. It has two halves: the Slack app side
+(<a href="http://api.slack.com">api.slack.com</a>), and the Munder Difflin side (Settings). Do them in order and you’ll be triggering
+agents from chat in about ten minutes.</p>
+<h2 id="what-youre-building" tabindex="-1">What you’re building <a class="anchor" href="#what-youre-building" aria-hidden="true">#</a></h2>
+<p>A message that @mentions your bot in a connected Slack channel becomes a task in
+<a href="/blog/how-the-god-orchestrator-works/">the orchestrator’s</a> queue — exactly like a task you’d type into
+the app yourself. GOD then triages it and routes it to the right agent. Two things make this feel
+conversational rather than fire-and-forget:</p>
+<ul>
+<li><strong>Thread activation.</strong> The first @mention in a thread “activates” it. After that, you can keep replying
+in that same thread <em>without</em> re-mentioning the bot, and the hive keeps listening. It’s a real
+back-and-forth, not a one-shot command.</li>
+<li><strong>Done-summaries.</strong> When the work lands, the office posts a summary reply <strong>in the same thread</strong> via
+Slack’s <code>chat.postMessage</code>. You see the result where you asked the question.</li>
+</ul>
+<p>It also reads <strong>file and image attachments</strong> — drop a screenshot or a log file alongside your @mention
+and the hive ingests it.</p>
+<p>Under the hood there’s no <code>@slack/bolt</code>, no framework, and nothing hosted in the cloud. A tiny
+<code>node:http</code> server inside the app implements just the slice of Slack’s <strong>Events API</strong> it needs, and a
+local tunnel gives Slack a public doorbell to ring. Your agents, their memory, and your code never leave
+your machine.</p>
+<h2 id="part-1-create-the-slack-app" tabindex="-1">Part 1 — Create the Slack app <a class="anchor" href="#part-1-create-the-slack-app" aria-hidden="true">#</a></h2>
+<p>Head to <a href="https://api.slack.com/apps">api.slack.com/apps</a> and create a new app <strong>from scratch</strong>, in the
+workspace you want the bot to live in.</p>
+<p>You’ll collect two secrets and set three scopes. Here’s exactly where each lives.</p>
+<h3 id="signing-secret" tabindex="-1">Signing Secret <a class="anchor" href="#signing-secret" aria-hidden="true">#</a></h3>
+<p>In your app’s left nav, open <strong>Basic Information</strong> and find <strong>App Credentials</strong>. Copy the <strong>Signing
+Secret</strong>. This is what Munder Difflin uses to verify that every inbound request is genuinely from Slack —
+it never leaves your machine and is never logged.</p>
+<h3 id="bot-token-scopes" tabindex="-1">Bot Token Scopes <a class="anchor" href="#bot-token-scopes" aria-hidden="true">#</a></h3>
+<p>Open <strong>OAuth &amp; Permissions → Scopes → Bot Token Scopes</strong> and add these three:</p>
+<ul>
+<li><strong><code>chat:write</code></strong> — lets the bot post replies, including the done-summary, back into the thread.</li>
+<li><strong><code>channels:history</code></strong> — lets Slack deliver message and thread-reply events from <strong>public</strong> channels.</li>
+<li><strong><code>groups:history</code></strong> — the same, for <strong>private</strong> channels.</li>
+</ul>
+<p>You don’t need anything beyond these three. The hive learns its own bot user id automatically from each
+event, so there’s no extra scope just to detect mentions.</p>
+<h3 id="install-and-grab-the-bot-user-oauth-token" tabindex="-1">Install and grab the Bot User OAuth Token <a class="anchor" href="#install-and-grab-the-bot-user-oauth-token" aria-hidden="true">#</a></h3>
+<p>Still on <strong>OAuth &amp; Permissions</strong>, click <strong>Install to Workspace</strong> and approve. Slack then shows a <strong>Bot
+User OAuth Token</strong> that starts with <strong><code>xoxb-</code></strong> — copy it. That token authorizes the bot’s replies; like
+the signing secret, it stays in the app’s main process and is never logged.</p>
+<blockquote>
+<p>Keep both values handy. You’ll paste them into Munder Difflin next, then come back to finish Event
+Subscriptions.</p>
+</blockquote>
+<h2 id="part-2-configure-munder-difflin" tabindex="-1">Part 2 — Configure Munder Difflin <a class="anchor" href="#part-2-configure-munder-difflin" aria-hidden="true">#</a></h2>
+<p>Open Munder Difflin and go to <strong>Settings</strong>. In the Slack section:</p>
+<ol>
+<li><strong>Enable Slack.</strong></li>
+<li>Paste the <strong>Signing Secret</strong>.</li>
+<li>Paste the <strong>Bot User OAuth Token</strong> (<code>xoxb-…</code>).</li>
+<li><em>(Optional)</em> Set a <strong>Channel ID</strong> to restrict ingestion to a single channel. Leave it blank to accept
+any channel the bot is in. This is the cleanest way to keep a noisy workspace from turning into a
+noisy hive.</li>
+<li><em>(Optional)</em> Change the <strong>port</strong> if <code>3847</code> (the default) is already taken on your machine.</li>
+</ol>
+<p>Start it. The app binds the local webhook server and opens a public tunnel, then shows you a <strong>Request
+URL</strong> — the public address Slack will call. Copy that URL; you need it for the last step.</p>
+<p>If the tunnel can’t start, the app surfaces a real error rather than handing you a dead URL. The local
+handler is the security boundary, so it stays up regardless — but you do need a working tunnel URL for
+Slack to reach it.</p>
+<h2 id="part-3-point-slack-at-your-request-url" tabindex="-1">Part 3 — Point Slack at your Request URL <a class="anchor" href="#part-3-point-slack-at-your-request-url" aria-hidden="true">#</a></h2>
+<p>Back in your Slack app, open <strong>Event Subscriptions</strong> and toggle <strong>Enable Events</strong> on.</p>
+<p>Paste the <strong>Request URL</strong> from Munder Difflin into the <strong>Request URL</strong> field. Slack immediately fires a
+one-time <code>url_verification</code> handshake at it; the app answers the challenge and Slack shows a green
+<strong>Verified</strong>. (If it doesn’t verify, jump to the troubleshooting note below — it’s almost always the
+tunnel.)</p>
+<p>Now scroll to <strong>Subscribe to bot events</strong> and add:</p>
+<ul>
+<li><strong><code>app_mention</code></strong> — fires when someone @mentions the bot. This is the primary trigger.</li>
+<li><strong><code>message.channels</code></strong> — message events in public channels (for <strong>thread replies</strong> in an activated
+thread, and <strong>file_share</strong> uploads).</li>
+<li><strong><code>message.groups</code></strong> — the same, for private channels.</li>
+</ul>
+<p><strong>Save changes.</strong> Slack may prompt you to reinstall the app to apply the new event subscriptions — do it.</p>
+<p>That’s the whole loop. The hive triggers on:</p>
+<ul>
+<li>a direct <strong>@mention</strong> of the bot in a connected channel,</li>
+<li>any <strong>reply inside a thread</strong> the bot was already mentioned in (no re-mention needed),</li>
+<li>a <strong>file or image upload</strong> that @mentions the bot.</li>
+</ul>
+<p>It deliberately ignores the bot’s own posts, edits, channel-join notices, and every other message
+subtype — so it never talks to itself and never reacts to channel noise.</p>
+<h2 id="try-it" tabindex="-1">Try it <a class="anchor" href="#try-it" aria-hidden="true">#</a></h2>
+<p>In a channel where the bot is a member, type something like:</p>
+<blockquote>
+<p>@YourBot summarize the open PRs in the api repo and flag anything stale</p>
+</blockquote>
+<p>The message lands in the queue, GOD routes it, and an agent picks it up. Keep the conversation going by
+replying in that same thread — the hive is still listening. When the task is done, a summary appears
+right there in the thread.</p>
+<h2 id="troubleshooting-the-request-url-rotates-on-restart" tabindex="-1">Troubleshooting: the Request URL rotates on restart <a class="anchor" href="#troubleshooting-the-request-url-rotates-on-restart" aria-hidden="true">#</a></h2>
+<p>Here’s the one quirk worth tattooing on the back of your hand. <strong>The public Request URL comes from an
+ephemeral tunnel, and it changes every time the app restarts.</strong> So if Slack suddenly stops triggering
+your agents — verification was green yesterday, silence today — it’s almost always because the app was
+restarted and the old URL went stale.</p>
+<p>The fix is quick:</p>
+<ol>
+<li><strong>Stop and Start</strong> Munder Difflin’s Slack integration (or just relaunch the app).</li>
+<li>Copy the <strong>new Request URL</strong> it shows you.</li>
+<li>Paste it back into Slack’s <strong>Event Subscriptions → Request URL</strong> and let it re-verify.</li>
+</ol>
+<p>Triggers resume the moment Slack shows <strong>Verified</strong> again. If you find yourself doing this a lot, get
+into the habit of re-checking the Request URL whenever you restart — it’s the single most common reason
+Slack triggering “breaks.”</p>
+<h2 id="why-its-built-this-way" tabindex="-1">Why it’s built this way <a class="anchor" href="#why-its-built-this-way" aria-hidden="true">#</a></h2>
+<p>It would have been easier to host this in a cloud function. Doing it as a <strong>local</strong> webhook is the
+point. Every request is HMAC-verified against your signing secret in constant time, with a five-minute
+replay guard and a size cap checked first — anything suspicious gets a flat 403. The secrets stay on
+your box. Slack is only a thin remote surface for <em>starting and watching</em> work; the office itself —
+agents, memory, git history — never leaves your machine. It’s the same
+<a href="/blog/local-first-ai-agent-orchestration/">local-first philosophy</a> behind everything Munder Difflin
+does: keep the control plane on your computer, and let the outside world knock politely at the door.</p>
+<p>Pair it with <a href="/blog/scheduling-autonomous-agent-missions/">scheduled missions</a> and the picture rounds
+out: timers put recurring work into the queue, Slack puts ad-hoc work into the queue, and your office
+runs both — whether or not you’re watching.</p>
+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
+<p><strong>How do I connect Slack to Munder Difflin?</strong> Create a Slack app, add the <code>chat:write</code>,
+<code>channels:history</code>, and <code>groups:history</code> bot scopes, install it, then paste the Signing Secret and
+<code>xoxb-</code> Bot User OAuth Token into Settings. Copy the app’s Request URL into Slack’s Event Subscriptions,
+subscribe to <code>app_mention</code> + message events, and @mention the bot to start work.</p>
+<p><strong>Which scopes does it need?</strong> Just three: <code>chat:write</code> for replies and done-summaries,
+<code>channels:history</code> and <code>groups:history</code> so Slack delivers the message and thread-reply events the hive
+listens to.</p>
+<p><strong>Why did Slack stop triggering?</strong> The Request URL is from an ephemeral tunnel that rotates on restart.
+Relaunch the app, copy the new URL, and re-paste it into Event Subscriptions.</p>
+<hr>
+<p>Munder Difflin turns a Slack thread into a remote control for an AI office that still lives entirely on
+your machine — <a href="https://munderdiffl.in/#how">orchestrated by GOD</a>, verified at the edge, and queued like
+any other task. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run your hive from chat;
+it’s free and open source.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">How do I connect Slack to Munder Difflin?</p>
+ <p class="a">Create a Slack app at api.slack.com/apps, grant the bot the chat:write, channels:history, and groups:history scopes, install it, then paste the Signing Secret and Bot User OAuth Token into Munder Difflin&#39;s Settings. Enable Slack, copy the public tunnel Request URL the app gives you into Slack&#39;s Event Subscriptions, and subscribe to app_mention plus message events. @mention the bot in a channel to start work.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Which Slack scopes does the hive need?</p>
+ <p class="a">Three Bot Token Scopes: chat:write (so the bot can post done-summaries back in-thread), channels:history and groups:history (so Slack delivers the message and thread-reply events the hive listens to). The Signing Secret authenticates every inbound request; the xoxb- Bot User OAuth Token authorizes the bot&#39;s replies.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Why did Slack stop triggering my agents?</p>
+ <p class="a">The public Request URL comes from a local tunnel that is ephemeral — it rotates every time you stop and start the app. If triggers go quiet, restart Munder Difflin, copy the new tunnel URL, and re-paste it into Slack&#39;s Event Subscriptions → Request URL. Slack re-verifies and triggers resume.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/guides/">Guides</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/slack/">Slack</a><a class="tag" href="/blog/tags/hive/">Hive</a><a class="tag" href="/blog/tags/setup/">Setup</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#what-youre-building">What you’re building</a></li><li class="lvl-2"><a href="#part-1-create-the-slack-app">Part 1 — Create the Slack app</a></li><li class="lvl-3"><a href="#signing-secret">Signing Secret</a></li><li class="lvl-3"><a href="#bot-token-scopes">Bot Token Scopes</a></li><li class="lvl-3"><a href="#install-and-grab-the-bot-user-oauth-token">Install and grab the Bot User OAuth Token</a></li><li class="lvl-2"><a href="#part-2-configure-munder-difflin">Part 2 — Configure Munder Difflin</a></li><li class="lvl-2"><a href="#part-3-point-slack-at-your-request-url">Part 3 — Point Slack at your Request URL</a></li><li class="lvl-2"><a href="#try-it">Try it</a></li><li class="lvl-2"><a href="#troubleshooting-the-request-url-rotates-on-restart">Troubleshooting: the Request URL rotates on restart</a></li><li class="lvl-2"><a href="#why-its-built-this-way">Why it’s built this way</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/"><span class="k">← Older</span><span class="t">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</span></a>
+ <a class="pn next" href="/blog/deploy-automated-pr-reviewer-agent/"><span class="k">Newer →</span><span class="t">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Guides</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-09">Jun 9, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-06">Jun 6, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
+ <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/run-an-office-of-ai-agents/index.html b/docs/blog/run-an-office-of-ai-agents/index.html
index 8582106f..9b78a368 100644
--- a/docs/blog/run-an-office-of-ai-agents/index.html
+++ b/docs/blog/run-an-office-of-ai-agents/index.html
@@ -206,43 +206,43 @@ open source.</p>
<h2>Related in Use Cases</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
- <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
+ <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>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
+ <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>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-02">Jun 2, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>3 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
- <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/why-local-first-matters-for-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
@@ -251,11 +251,11 @@ open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>3 min</span>
</div>
- <h3><a href="/blog/why-local-first-matters-for-ai-agents/">Why Local-First Matters for Your AI Agents</a></h3>
- <p class="dek">The control, privacy, and cost case for keeping your AI agents and their memory on your own machine — and what cloud orchestration quietly costs.</p>
+ <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
+ <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/why-local-first-matters-for-ai-agents/" aria-label="Read: Why Local-First Matters for Your AI Agents">Read →</a>
+ <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/scheduling-autonomous-agent-missions/index.html b/docs/blog/scheduling-autonomous-agent-missions/index.html
index de625130..c7435c59 100644
--- a/docs/blog/scheduling-autonomous-agent-missions/index.html
+++ b/docs/blog/scheduling-autonomous-agent-missions/index.html
@@ -297,43 +297,43 @@ mission and watch the floor wake itself up; it’s free and open source.</p>
<h2>Related in Orchestration</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
- <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
- <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
+ <h3><a href="/blog/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
+ <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
+ <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
@@ -342,11 +342,11 @@ mission and watch the floor wake itself up; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
- <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/security-for-ai-coding-agents/index.html b/docs/blog/security-for-ai-coding-agents/index.html
index 88b42465..e3197b8f 100644
--- a/docs/blog/security-for-ai-coding-agents/index.html
+++ b/docs/blog/security-for-ai-coding-agents/index.html
@@ -268,56 +268,56 @@ and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/small-team-ai-agents-playbook/index.html b/docs/blog/small-team-ai-agents-playbook/index.html
index 17f88f5f..91ad82dc 100644
--- a/docs/blog/small-team-ai-agents-playbook/index.html
+++ b/docs/blog/small-team-ai-agents-playbook/index.html
@@ -273,56 +273,56 @@ it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/tags/automation/index.html b/docs/blog/tags/automation/index.html
index 97ff7cf1..346751d0 100644
--- a/docs/blog/tags/automation/index.html
+++ b/docs/blog/tags/automation/index.html
@@ -58,11 +58,83 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Automation</h1>
- <p class="lead">7 posts tagged <strong>Automation</strong>.</p>
+ <p class="lead">11 posts tagged <strong>Automation</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/tags/cli-agents/index.html b/docs/blog/tags/cli-agents/index.html
new file mode 100644
index 00000000..48a65a48
--- /dev/null
+++ b/docs/blog/tags/cli-agents/index.html
@@ -0,0 +1,124 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>CLI Agents — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged CLI Agents." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/cli-agents/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="CLI Agents — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged CLI Agents." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/cli-agents/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="CLI Agents — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged CLI Agents." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+<header class="page-head wrap">
+ <p class="eyebrow">Tag</p>
+ <h1>#CLI Agents</h1>
+ <p class="lead">1 post tagged <strong>CLI Agents</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/code-review/index.html b/docs/blog/tags/code-review/index.html
new file mode 100644
index 00000000..968f382b
--- /dev/null
+++ b/docs/blog/tags/code-review/index.html
@@ -0,0 +1,124 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Code Review — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Code Review." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/code-review/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Code Review — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Code Review." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/code-review/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Code Review — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Code Review." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+<header class="page-head wrap">
+ <p class="eyebrow">Tag</p>
+ <h1>#Code Review</h1>
+ <p class="lead">1 post tagged <strong>Code Review</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/concepts/index.html b/docs/blog/tags/concepts/index.html
index 619d8ff2..6975c111 100644
--- a/docs/blog/tags/concepts/index.html
+++ b/docs/blog/tags/concepts/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Concepts</h1>
- <p class="lead">11 posts tagged <strong>Concepts</strong>.</p>
+ <p class="lead">12 posts tagged <strong>Concepts</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
diff --git a/docs/blog/tags/content/index.html b/docs/blog/tags/content/index.html
new file mode 100644
index 00000000..5c2250ea
--- /dev/null
+++ b/docs/blog/tags/content/index.html
@@ -0,0 +1,124 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Content — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Content." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/content/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Content — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Content." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/content/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Content — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Content." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+<header class="page-head wrap">
+ <p class="eyebrow">Tag</p>
+ <h1>#Content</h1>
+ <p class="lead">1 post tagged <strong>Content</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/cost/index.html b/docs/blog/tags/cost/index.html
index 15c3d30c..936c595b 100644
--- a/docs/blog/tags/cost/index.html
+++ b/docs/blog/tags/cost/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Cost</h1>
- <p class="lead">3 posts tagged <strong>Cost</strong>.</p>
+ <p class="lead">5 posts tagged <strong>Cost</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/the-multi-agent-cost-playbook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/github/index.html b/docs/blog/tags/github/index.html
new file mode 100644
index 00000000..6150577e
--- /dev/null
+++ b/docs/blog/tags/github/index.html
@@ -0,0 +1,124 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>GitHub — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged GitHub." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/github/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="GitHub — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged GitHub." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/github/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="GitHub — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged GitHub." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+<header class="page-head wrap">
+ <p class="eyebrow">Tag</p>
+ <h1>#GitHub</h1>
+ <p class="lead">1 post tagged <strong>GitHub</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/guides/index.html b/docs/blog/tags/guides/index.html
index 3dedf6ff..e19503a2 100644
--- a/docs/blog/tags/guides/index.html
+++ b/docs/blog/tags/guides/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Guides</h1>
- <p class="lead">12 posts tagged <strong>Guides</strong>.</p>
+ <p class="lead">14 posts tagged <strong>Guides</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/hive/index.html b/docs/blog/tags/hive/index.html
index c8fae5c6..3755851e 100644
--- a/docs/blog/tags/hive/index.html
+++ b/docs/blog/tags/hive/index.html
@@ -58,11 +58,65 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Hive</h1>
- <p class="lead">3 posts tagged <strong>Hive</strong>.</p>
+ <p class="lead">6 posts tagged <strong>Hive</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/human-in-the-loop-approving-ai-agents/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/local-first/index.html b/docs/blog/tags/local-first/index.html
index 69e5b4ba..c525a72d 100644
--- a/docs/blog/tags/local-first/index.html
+++ b/docs/blog/tags/local-first/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Local-First</h1>
- <p class="lead">6 posts tagged <strong>Local-First</strong>.</p>
+ <p class="lead">7 posts tagged <strong>Local-First</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/model-routing/index.html b/docs/blog/tags/model-routing/index.html
index 01b8f21f..86439117 100644
--- a/docs/blog/tags/model-routing/index.html
+++ b/docs/blog/tags/model-routing/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Model Routing</h1>
- <p class="lead">2 posts tagged <strong>Model Routing</strong>.</p>
+ <p class="lead">3 posts tagged <strong>Model Routing</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/the-multi-agent-cost-playbook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/multi-agent/index.html b/docs/blog/tags/multi-agent/index.html
index 0f78ce49..eedc53a5 100644
--- a/docs/blog/tags/multi-agent/index.html
+++ b/docs/blog/tags/multi-agent/index.html
@@ -58,11 +58,65 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Multi-Agent</h1>
- <p class="lead">58 posts tagged <strong>Multi-Agent</strong>.</p>
+ <p class="lead">61 posts tagged <strong>Multi-Agent</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/tags/open-source/index.html b/docs/blog/tags/open-source/index.html
index 7ecaa5ae..56f10c8d 100644
--- a/docs/blog/tags/open-source/index.html
+++ b/docs/blog/tags/open-source/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Open Source</h1>
- <p class="lead">5 posts tagged <strong>Open Source</strong>.</p>
+ <p class="lead">7 posts tagged <strong>Open Source</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/tags/orchestration/index.html b/docs/blog/tags/orchestration/index.html
index 9c977bfb..5f92e482 100644
--- a/docs/blog/tags/orchestration/index.html
+++ b/docs/blog/tags/orchestration/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Orchestration</h1>
- <p class="lead">14 posts tagged <strong>Orchestration</strong>.</p>
+ <p class="lead">16 posts tagged <strong>Orchestration</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/tags/setup/index.html b/docs/blog/tags/setup/index.html
new file mode 100644
index 00000000..5b5ce913
--- /dev/null
+++ b/docs/blog/tags/setup/index.html
@@ -0,0 +1,124 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Setup — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Setup." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/setup/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Setup — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Setup." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/setup/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Setup — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Setup." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+<header class="page-head wrap">
+ <p class="eyebrow">Tag</p>
+ <h1>#Setup</h1>
+ <p class="lead">1 post tagged <strong>Setup</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/slack/index.html b/docs/blog/tags/slack/index.html
index 014d24d0..6ae8c286 100644
--- a/docs/blog/tags/slack/index.html
+++ b/docs/blog/tags/slack/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Slack</h1>
- <p class="lead">1 post tagged <strong>Slack</strong>.</p>
+ <p class="lead">2 posts tagged <strong>Slack</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/use-cases/index.html b/docs/blog/tags/use-cases/index.html
index 4f59bbc1..7d1461c5 100644
--- a/docs/blog/tags/use-cases/index.html
+++ b/docs/blog/tags/use-cases/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Use Cases</h1>
- <p class="lead">5 posts tagged <strong>Use Cases</strong>.</p>
+ <p class="lead">6 posts tagged <strong>Use Cases</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/webhooks/index.html b/docs/blog/tags/webhooks/index.html
new file mode 100644
index 00000000..232086a4
--- /dev/null
+++ b/docs/blog/tags/webhooks/index.html
@@ -0,0 +1,124 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Webhooks — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Webhooks." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/webhooks/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Webhooks — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Webhooks." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/webhooks/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Webhooks — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Webhooks." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+<header class="page-head wrap">
+ <p class="eyebrow">Tag</p>
+ <h1>#Webhooks</h1>
+ <p class="lead">1 post tagged <strong>Webhooks</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html b/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html
new file mode 100644
index 00000000..1c02527e
--- /dev/null
+++ b/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html
@@ -0,0 +1,402 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents — Munder Difflin Blog</title>
+<meta name="description" content="Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality." />
+<link rel="canonical" href="https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents — Munder Difflin Blog" />
+<meta property="og:description" content="Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality." />
+<meta property="og:url" content="https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+<meta property="article:published_time" content="2026-06-10T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Cost" />
+<meta property="article:tag" content="Orchestration" />
+<meta property="article:tag" content="Model Routing" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents — Munder Difflin Blog" />
+<meta name="twitter:description" content="Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents",
+ "description": "Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-06-10T00:00:00.000Z",
+ "author": { "@type": "Person", "name": "Chaitanya Giri" },
+ "publisher": {
+ "@type": "Organization",
+ "name": "Munder Difflin",
+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
+ },
+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" },
+ "keywords": "mixed-capability agent swarm, multi-agent token efficiency, agent specialization, orchestrator delegation, identical vs mixed agents",
+ "articleSection": "Concepts",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents", "item": "https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "Why not just run tens of identical top-tier agents on a problem?", "acceptedAnswer": { "@type": "Answer", "text": "Because most tasks are a mix of cheap and hard subtasks, and identical premium agents pay frontier prices for the cheap majority too. You also pay a hidden tax: identical agents with no shared state each re-derive the same context, and without an owner they duplicate work and collide. You get a big bill for redundant effort, not more capability." } },
+ { "@type": "Question", "name": "Is a mixed-capability swarm actually as capable as an all-premium fleet?", "acceptedAnswer": { "@type": "Answer", "text": "On most real workloads, yes — and sometimes more, because specialization and a clean division of labor beat raw horsepower applied uniformly. The frontier model still does the hard reasoning; it just isn't wasted on formatting and lookups. Quality only drops if you route a genuinely hard task to a model that can't handle it, which is a routing mistake, not a swarm one." } },
+ { "@type": "Question", "name": "What makes a swarm token-efficient rather than just cheaper per agent?", "acceptedAnswer": { "@type": "Answer", "text": "Three structural things: an orchestrator that routes each subtask to the right capability tier, shared memory so no agent re-derives context that another already established, and scoped contracts so each agent carries only what its task needs. Specialization plus delegation plus shared state is the lever — not the per-token price of any one model." } },
+ { "@type": "Question", "name": "Doesn't an orchestrator add overhead that eats the savings?", "acceptedAnswer": { "@type": "Answer", "text": "It adds a little — one premium agent reasoning about the whole job — but it removes far more: the redundant re-derivation, the colliding work, and the frontier-priced busywork that a leaderless clone army generates. The orchestrator's cost is a fixed overhead; the savings scale with every routine subtask it routes away from the expensive tier." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/concepts/">Concepts</a>
+ </nav>
+ <h1>The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</h1>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</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-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>7 min read</span>
+ <span class="tag kind">Concepts</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>Throwing <strong>tens of identical
+top-tier CLI agents</strong> at a problem feels like brute-forcing your way to a great answer. It's
+mostly brute-forcing your way to a big bill. Real tasks are a <strong>mix</strong> of cheap and hard
+subtasks, and a clone army pays frontier prices for the cheap majority — while quietly re-deriving the
+same context N times and colliding with itself because no one owns the plan. A <strong>mixed-capability
+swarm</strong> — an orchestrator routing each subtask to the right tier, <strong>shared memory</strong>
+so nobody re-derives context, scoped contracts, and real parallelism — gets comparable or better results
+at a <strong>fraction of the tokens</strong>. The lever is specialization, delegation, and shared state —
+not horsepower applied uniformly.</p></div>
+<p>There’s a seductive move when a problem looks big: spin up <em>more of the best agent</em>. Ten identical
+top-tier CLI agents, all on the frontier model, all pointed at the same repo. It looks like a force
+multiplier. It feels safe — every agent is maximally capable, so surely the swarm is too.</p>
+<p>It’s a trap. Not because the agents are bad, but because the <em>shape of the work</em> doesn’t reward
+sameness. We’ve argued before that <a href="/blog/do-more-with-less-model-routing/">a hive shouldn’t all run the biggest
+model</a> and laid out the <a href="/blog/the-multi-agent-cost-playbook/">five levers that cut a fleet’s
+bill</a>. This post is the head-to-head those posts imply: <strong>the
+clone army versus the mixed swarm</strong> — why uniform top-tier agents burn tokens on work a cheaper agent
+could do, and why a swarm of mixed-capability agents is both leaner <em>and</em>, surprisingly often, better.</p>
+<h2 id="most-tasks-are-not-uniform-theyre-lumpy" tabindex="-1">Most tasks are not uniform — they’re lumpy <a class="anchor" href="#most-tasks-are-not-uniform-theyre-lumpy" aria-hidden="true">#</a></h2>
+<p>Pick any real job an agent team gets handed. “Add this feature.” “Audit this codebase.” “Triage these
+issues.” Now look inside it. You’ll find a handful of genuinely hard subtasks — the architecture call,
+the subtle bug, the ambiguous spec that needs judgment — surrounded by a <em>much larger</em> pile of routine
+ones: reading files, reformatting, renaming, classifying, summarizing logs, writing boilerplate tests,
+checking a convention.</p>
+<p>That lumpiness is the whole game. The hard subtasks genuinely reward a frontier model. The routine ones
+don’t — a small, fast model does them just as well. So when you run <em>every</em> agent on the top tier, you’re
+not buying ten units of capability. You’re buying one unit of capability you needed and nine units you’re
+paying frontier prices for routine work you’d have gotten for a tenth the cost. The capability you bought
+on the easy subtasks was never the bottleneck.</p>
+<h2 id="the-clone-armys-three-hidden-taxes" tabindex="-1">The clone army’s three hidden taxes <a class="anchor" href="#the-clone-armys-three-hidden-taxes" aria-hidden="true">#</a></h2>
+<p>The per-token waste is the obvious cost. The structural ones are worse.</p>
+<p><strong>Tax 1 — Re-derivation.</strong> Ten identical agents with no shared state each rebuild the same understanding
+from scratch. Each one reads the same files, re-infers the same architecture, re-discovers the same
+constraint that “auth lives in the middleware layer.” That context-building is real tokens, paid N times,
+to arrive at knowledge one agent already had. Without <a href="/blog/markdown-first-agent-memory/">shared memory</a>,
+the swarm is N strangers who refuse to talk.</p>
+<p><strong>Tax 2 — Collision.</strong> Identical agents with no owner have no division of labor. Two of them pick the
+same subtask; a third refactors a file a fourth is mid-edit on; their outputs contradict and someone (you)
+has to reconcile them. A leaderless clone army doesn’t parallelize a problem — it parallelizes <em>confusion</em>,
+and then you pay again to merge it. This is exactly the <a href="/blog/coordinating-ai-coding-agents/">coordinate-without-colliding
+problem</a>, made worse by sameness: when every agent is interchangeable,
+nothing tells them who does what.</p>
+<p><strong>Tax 3 — No escalation ceiling, no floor.</strong> Because every agent is already maxed out, there’s nowhere to
+<em>escalate</em> a truly nasty subtask (everyone’s already on the best model) and nowhere to <em>de-escalate</em> the
+easy follow-ups (everyone stays expensive). You’ve flattened the one dimension that lets a team be
+efficient: the ability to spend big where it matters and small where it doesn’t.</p>
+<p>So the clone army’s bill isn’t “10× one agent.” It’s 10× <em>plus</em> re-derivation <em>plus</em> collision-cleanup —
+for a result that a smaller, better-organized team would have produced with less drama.</p>
+<h2 id="what-a-mixed-swarm-does-differently" tabindex="-1">What a mixed swarm does differently <a class="anchor" href="#what-a-mixed-swarm-does-differently" aria-hidden="true">#</a></h2>
+<p>A mixed-capability swarm isn’t “the same idea, but cheaper agents.” It’s a different <em>structure</em>, and the
+structure is where the wins come from.</p>
+<ul>
+<li><strong>An orchestrator that routes by tier.</strong> Instead of ten peers, you have one lead that sees the whole job,
+decomposes it, and sends each subtask to the <a href="/blog/do-more-with-less-model-routing/">right capability tier</a>:
+routine work to fast cheap workers, the hard reasoning to a frontier worker, and itself reserved for
+planning and integration. The expensive model still does the expensive thinking — it just stops doing the
+cheap thinking.</li>
+<li><strong>Shared memory so nobody re-derives.</strong> The context one agent establishes — the architecture, the
+decision, the gotcha — is written once to a shared board and read by everyone. Re-derivation tax: gone.
+This is why a hive leans on <a href="/blog/how-agents-remember-semantic-memory/">compact, markdown-first memory and semantic
+recall</a> instead of stuffing the whole world into ten separate
+context windows.</li>
+<li><strong>Scoped contracts.</strong> Each worker gets a <em>narrow</em> assignment with a clear input and expected output — not
+the whole problem. Narrow scope means a small model can handle it, the context window stays tiny (so the
+<a href="/blog/the-multi-agent-cost-playbook/">per-turn cost you pay N times</a> stays small), and there’s no ambiguity
+about who owns what. Collision tax: gone.</li>
+<li><strong>Real parallelism, not redundant parallelism.</strong> The independent subtasks run at once because the
+orchestrator knows they’re independent — a genuine <a href="/blog/multi-agent-orchestration-patterns/">fan-out</a>,
+not ten agents racing to do the same thing.</li>
+</ul>
+<p>Specialization, delegation, shared state. That’s the lever. Each one removes a tax the clone army pays.</p>
+<h2 id="but-is-it-as-capable" tabindex="-1">“But is it as <em>capable</em>?” <a class="anchor" href="#but-is-it-as-capable" aria-hidden="true">#</a></h2>
+<p>Here’s the part that surprises people: the mixed swarm often produces <em>better</em> output, not just cheaper.</p>
+<p>Two reasons. First, a clean division of labor beats raw horsepower applied uniformly — the same reason a
+real team doesn’t put its most senior engineer on every ticket. A frontier agent that’s <em>only</em> doing hard
+reasoning, with the routine noise handled elsewhere, is a frontier agent that isn’t drowning the hard
+problem in busywork. You concentrate capability where it changes the outcome.</p>
+<p>Second, the structure adds a quality dimension the clone army lacks: you can route risky output through a
+<a href="/blog/how-ai-agents-verify-their-own-work/">maker-checker pass</a> — a cheap worker produces, a stronger
+agent verifies — which catches more than ten parallel agents independently being confident. Capability
+isn’t just the model; it’s the <em>organization</em> around the model.</p>
+<p>The honest caveat — and we <a href="/blog/multi-agent-orchestration-patterns/">keep this one honest</a> — is that
+quality drops the moment you route a genuinely hard subtask to a model that can’t handle it. But that’s a
+<em>routing</em> mistake, not a swarm one. Default lean, escalate the hard minority on signal, and the capability
+gap to an all-premium fleet closes to roughly nothing — at a fraction of the tokens.</p>
+<h2 id="what-fraction-of-the-tokens-actually-means" tabindex="-1">What “fraction of the tokens” actually means <a class="anchor" href="#what-fraction-of-the-tokens-actually-means" aria-hidden="true">#</a></h2>
+<p>We won’t fabricate a benchmark number, but the direction is not subtle, and it comes from three
+multiplying sources. The price gap between a small and a frontier model is large per token. The routine
+subtasks vastly outnumber the hard ones in most workloads. And shared memory plus scoped contracts erase
+the re-derivation and collision the clone army pays on top. Multiply those together and the mixed swarm
+isn’t a little cheaper — it’s <em>categorically</em> cheaper, for output that holds up. The real denominator is
+<strong>cost per completed task</strong>, and a leaderless clone army that needs a human to merge its contradictions
+isn’t cheap on that measure at all.</p>
+<h2 id="how-munder-difflin-is-built-around-this" tabindex="-1">How Munder Difflin is built around this <a class="anchor" href="#how-munder-difflin-is-built-around-this" aria-hidden="true">#</a></h2>
+<p>This isn’t just a thesis — it’s the architecture of the product. <a href="https://munderdiffl.in">Munder Difflin</a>
+runs a virtual office where a <a href="/blog/how-the-god-orchestrator-works/">god orchestrator</a> decomposes your
+intent and delegates to Office-themed worker agents of <em>varying</em> capability. The cheap workers handle the
+routine; the orchestrator and any escalated workers handle the hard reasoning — <a href="/blog/the-multi-agent-cost-playbook/">per-agent model
+selection</a> is a real setting, not advice. A shared board, inboxes,
+and memory mean no agent re-derives what another already established. And a token budget with a <em>steward</em>
+model keeps the whole swarm inside a spend ceiling you set — so the structure that makes it efficient is
+also the structure that makes the cost predictable. It supports Claude Code, Codex, and Antigravity CLIs,
+runs <a href="/blog/why-local-first-matters-for-ai-agents/">local-first</a>, and you can <a href="/blog/observability-for-agent-fleets/">watch every agent
+work</a>.</p>
+<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>
+<p>The clone army feels powerful because every soldier is elite. But a problem isn’t won by ten identical
+elites re-deriving the same context and stepping on each other — it’s won by the <em>right</em> capability on
+each subtask, a shared brain so nobody repeats anyone, and a lead who owns the plan. A mixed-capability
+swarm is leaner because it stops paying frontier prices for routine work, and it’s often <em>better</em> because
+specialization and delegation beat undifferentiated horsepower. Don’t buy more of the best agent. Build a
+team out of the right ones.</p>
+<p>Want to run a swarm that routes by capability instead of brute-forcing with clones? <a href="https://munderdiffl.in/#install">Download Munder
+Difflin</a> — a local, 24/7 virtual office of AI agents. It’s free and open
+source.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">Why not just run tens of identical top-tier agents on a problem?</p>
+ <p class="a">Because most tasks are a mix of cheap and hard subtasks, and identical premium agents pay frontier prices for the cheap majority too. You also pay a hidden tax: identical agents with no shared state each re-derive the same context, and without an owner they duplicate work and collide. You get a big bill for redundant effort, not more capability.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Is a mixed-capability swarm actually as capable as an all-premium fleet?</p>
+ <p class="a">On most real workloads, yes — and sometimes more, because specialization and a clean division of labor beat raw horsepower applied uniformly. The frontier model still does the hard reasoning; it just isn&#39;t wasted on formatting and lookups. Quality only drops if you route a genuinely hard task to a model that can&#39;t handle it, which is a routing mistake, not a swarm one.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What makes a swarm token-efficient rather than just cheaper per agent?</p>
+ <p class="a">Three structural things: an orchestrator that routes each subtask to the right capability tier, shared memory so no agent re-derives context that another already established, and scoped contracts so each agent carries only what its task needs. Specialization plus delegation plus shared state is the lever — not the per-token price of any one model.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Doesn&#39;t an orchestrator add overhead that eats the savings?</p>
+ <p class="a">It adds a little — one premium agent reasoning about the whole job — but it removes far more: the redundant re-derivation, the colliding work, and the frontier-priced busywork that a leaderless clone army generates. The orchestrator&#39;s cost is a fixed overhead; the savings scale with every routine subtask it routes away from the expensive tier.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/cost/">Cost</a><a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/model-routing/">Model Routing</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#most-tasks-are-not-uniform-theyre-lumpy">Most tasks are not uniform — they’re lumpy</a></li><li class="lvl-2"><a href="#the-clone-armys-three-hidden-taxes">The clone army’s three hidden taxes</a></li><li class="lvl-2"><a href="#what-a-mixed-swarm-does-differently">What a mixed swarm does differently</a></li><li class="lvl-2"><a href="#but-is-it-as-capable">“But is it as capable?”</a></li><li class="lvl-2"><a href="#what-fraction-of-the-tokens-actually-means">What “fraction of the tokens” actually means</a></li><li class="lvl-2"><a href="#how-munder-difflin-is-built-around-this">How Munder Difflin is built around this</a></li><li class="lvl-2"><a href="#the-bottom-line">The bottom line</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/trigger-ai-agents-from-github-webhook/"><span class="k">← Older</span><span class="t">How to Trigger Your AI Agent Hive from a GitHub Webhook</span></a>
+ <a class="pn next" href="/blog/run-ai-agent-hive-from-slack-setup/"><span class="k">Newer →</span><span class="t">Run Your AI Agent Hive from Slack: The Complete Setup</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Concepts</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-05">Jun 5, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>4 min</span>
+ </div>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-04">Jun 4, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
+ <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/the-lethal-trifecta-for-coding-agents/index.html b/docs/blog/the-lethal-trifecta-for-coding-agents/index.html
index e40830ed..cd2c767c 100644
--- a/docs/blog/the-lethal-trifecta-for-coding-agents/index.html
+++ b/docs/blog/the-lethal-trifecta-for-coding-agents/index.html
@@ -291,56 +291,56 @@ secrets; it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/the-multi-agent-cost-playbook/index.html b/docs/blog/the-multi-agent-cost-playbook/index.html
index 9771b62d..2dd411b9 100644
--- a/docs/blog/the-multi-agent-cost-playbook/index.html
+++ b/docs/blog/the-multi-agent-cost-playbook/index.html
@@ -272,56 +272,56 @@ to run a fleet that doesn’t bankrupt you — it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/topics/comparisons/index.html b/docs/blog/topics/comparisons/index.html
index b175e98b..15630643 100644
--- a/docs/blog/topics/comparisons/index.html
+++ b/docs/blog/topics/comparisons/index.html
@@ -68,21 +68,21 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/" aria-current="page">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.html
index 5ee31891..40042af5 100644
--- a/docs/blog/topics/concepts/index.html
+++ b/docs/blog/topics/concepts/index.html
@@ -63,26 +63,26 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>concepts</h1>
- <p class="lead">13 posts in this cluster.</p>
+ <p class="lead">15 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
@@ -90,6 +90,42 @@
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
diff --git a/docs/blog/topics/guides/index.html b/docs/blog/topics/guides/index.html
index 57545499..c86e88ee 100644
--- a/docs/blog/topics/guides/index.html
+++ b/docs/blog/topics/guides/index.html
@@ -63,26 +63,26 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>guides</h1>
- <p class="lead">23 posts in this cluster.</p>
+ <p class="lead">25 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/" aria-current="page">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/" aria-current="page">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
@@ -90,6 +90,42 @@
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/topics/index.html b/docs/blog/topics/index.html
index 4b5583ba..2c228c4e 100644
--- a/docs/blog/topics/index.html
+++ b/docs/blog/topics/index.html
@@ -70,25 +70,25 @@
<span class="thumb t-guides" aria-hidden="true">GUIDES</span>
<div class="body">
<h3 style="color:var(--ink)">guides</h3>
- <p class="dek">23 posts.</p>
+ <p class="dek">25 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
- <a class="card" href="/blog/topics/internals/" style="text-decoration:none">
- <span class="thumb t-internals" aria-hidden="true">INTERNALS</span>
+ <a class="card" href="/blog/topics/concepts/" style="text-decoration:none">
+ <span class="thumb t-concepts" aria-hidden="true">CONCEPTS</span>
<div class="body">
- <h3 style="color:var(--ink)">internals</h3>
+ <h3 style="color:var(--ink)">concepts</h3>
<p class="dek">15 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
- <a class="card" href="/blog/topics/concepts/" style="text-decoration:none">
- <span class="thumb t-concepts" aria-hidden="true">CONCEPTS</span>
+ <a class="card" href="/blog/topics/internals/" style="text-decoration:none">
+ <span class="thumb t-internals" aria-hidden="true">INTERNALS</span>
<div class="body">
- <h3 style="color:var(--ink)">concepts</h3>
- <p class="dek">13 posts.</p>
+ <h3 style="color:var(--ink)">internals</h3>
+ <p class="dek">15 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -106,7 +106,7 @@
<span class="thumb t-orchestration" aria-hidden="true">ORCHESTRATION</span>
<div class="body">
<h3 style="color:var(--ink)">orchestration</h3>
- <p class="dek">8 posts.</p>
+ <p class="dek">9 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -120,20 +120,20 @@
</div>
</a>
- <a class="card" href="/blog/topics/story/" style="text-decoration:none">
- <span class="thumb t-story" aria-hidden="true">STORY</span>
+ <a class="card" href="/blog/topics/use-cases/" style="text-decoration:none">
+ <span class="thumb t-use-cases" aria-hidden="true">USE-CASES</span>
<div class="body">
- <h3 style="color:var(--ink)">story</h3>
+ <h3 style="color:var(--ink)">use-cases</h3>
<p class="dek">5 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
- <a class="card" href="/blog/topics/use-cases/" style="text-decoration:none">
- <span class="thumb t-use-cases" aria-hidden="true">USE-CASES</span>
+ <a class="card" href="/blog/topics/story/" style="text-decoration:none">
+ <span class="thumb t-story" aria-hidden="true">STORY</span>
<div class="body">
- <h3 style="color:var(--ink)">use-cases</h3>
- <p class="dek">4 posts.</p>
+ <h3 style="color:var(--ink)">story</h3>
+ <p class="dek">5 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -144,19 +144,21 @@
<div class="filters" style="padding-top:36px">
<span class="eyebrow" style="align-self:center">Tags</span>
- <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">58</span></a>
+ <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">61</span></a>
<a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">40</span></a>
<a class="chip" href="/blog/tags/internals/">Internals<span class="ct">22</span></a>
- <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">14</span></a>
+ <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">16</span></a>
+
+ <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">14</span></a>
- <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">12</span></a>
+ <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">12</span></a>
<a class="chip" href="/blog/tags/comparisons/">Comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">11</span></a>
+ <a class="chip" href="/blog/tags/automation/">Automation<span class="ct">11</span></a>
<a class="chip" href="/blog/tags/tools/">Tools<span class="ct">9</span></a>
@@ -164,22 +166,24 @@
<a class="chip" href="/blog/tags/getting-started/">Getting Started<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/automation/">Automation<span class="ct">7</span></a>
+ <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">6</span></a>
+ <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/story/">Story<span class="ct">6</span></a>
+ <a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">6</span></a>
- <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">6</span></a>
+ <a class="chip" href="/blog/tags/use-cases/">Use Cases<span class="ct">6</span></a>
- <a class="chip" href="/blog/tags/use-cases/">Use Cases<span class="ct">5</span></a>
+ <a class="chip" href="/blog/tags/story/">Story<span class="ct">6</span></a>
- <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">5</span></a>
+ <a class="chip" href="/blog/tags/hive/">Hive<span class="ct">6</span></a>
<a class="chip" href="/blog/tags/security/">Security<span class="ct">5</span></a>
<a class="chip" href="/blog/tags/autonomous/">Autonomous<span class="ct">5</span></a>
+ <a class="chip" href="/blog/tags/cost/">Cost<span class="ct">5</span></a>
+
<a class="chip" href="/blog/tags/observability/">Observability<span class="ct">4</span></a>
<a class="chip" href="/blog/tags/guardrails/">Guardrails<span class="ct">4</span></a>
@@ -196,7 +200,7 @@
<a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">3</span></a>
- <a class="chip" href="/blog/tags/cost/">Cost<span class="ct">3</span></a>
+ <a class="chip" href="/blog/tags/model-routing/">Model Routing<span class="ct">3</span></a>
<a class="chip" href="/blog/tags/agentic-ai/">Agentic AI<span class="ct">3</span></a>
@@ -204,8 +208,6 @@
<a class="chip" href="/blog/tags/seo/">SEO<span class="ct">3</span></a>
- <a class="chip" href="/blog/tags/hive/">Hive<span class="ct">3</span></a>
-
<a class="chip" href="/blog/tags/release/">Release<span class="ct">3</span></a>
<a class="chip" href="/blog/tags/god/">GOD<span class="ct">2</span></a>
@@ -230,10 +232,10 @@
<a class="chip" href="/blog/tags/reliability/">Reliability<span class="ct">2</span></a>
- <a class="chip" href="/blog/tags/model-routing/">Model Routing<span class="ct">2</span></a>
-
<a class="chip" href="/blog/tags/prompt-caching/">Prompt Caching<span class="ct">2</span></a>
+ <a class="chip" href="/blog/tags/slack/">Slack<span class="ct">2</span></a>
+
<a class="chip" href="/blog/tags/protocols/">Protocols<span class="ct">2</span></a>
<a class="chip" href="/blog/tags/codex/">Codex<span class="ct">2</span></a>
@@ -286,8 +288,6 @@
<a class="chip" href="/blog/tags/munder-difflin/">Munder Difflin<span class="ct">1</span></a>
- <a class="chip" href="/blog/tags/slack/">Slack<span class="ct">1</span></a>
-
<a class="chip" href="/blog/tags/devrel/">DevRel<span class="ct">1</span></a>
<a class="chip" href="/blog/tags/industry/">Industry<span class="ct">1</span></a>
@@ -302,6 +302,18 @@
<a class="chip" href="/blog/tags/tutorial/">Tutorial<span class="ct">1</span></a>
+ <a class="chip" href="/blog/tags/content/">Content<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/code-review/">Code Review<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/setup/">Setup<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/github/">GitHub<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/webhooks/">Webhooks<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/cli-agents/">CLI Agents<span class="ct">1</span></a>
+
</div>
</section>
diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.html
index 5d1efbbc..c3c0ea3e 100644
--- a/docs/blog/topics/internals/index.html
+++ b/docs/blog/topics/internals/index.html
@@ -68,21 +68,21 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.html
index 0d015d86..526ea227 100644
--- a/docs/blog/topics/memory/index.html
+++ b/docs/blog/topics/memory/index.html
@@ -68,21 +68,21 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/" aria-current="page">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.html
index 257f0920..ea01c9a0 100644
--- a/docs/blog/topics/orchestration/index.html
+++ b/docs/blog/topics/orchestration/index.html
@@ -63,26 +63,26 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>orchestration</h1>
- <p class="lead">8 posts in this cluster.</p>
+ <p class="lead">9 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/" aria-current="page">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/" aria-current="page">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
@@ -90,6 +90,24 @@
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 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>
+ <div class="foot">
+ <span class="tag kind">Orchestration</span>
+ <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.html
index eddb423e..7a77e6f7 100644
--- a/docs/blog/topics/story/index.html
+++ b/docs/blog/topics/story/index.html
@@ -68,21 +68,21 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">5</span></a>
</div>
</header>
diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.html
index 3c16d07f..afa83f01 100644
--- a/docs/blog/topics/use-cases/index.html
+++ b/docs/blog/topics/use-cases/index.html
@@ -63,26 +63,26 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>use-cases</h1>
- <p class="lead">4 posts in this cluster.</p>
+ <p class="lead">5 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">23</span></a>
+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">13</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
<a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/use-cases/" aria-current="page">use-cases<span class="ct">5</span></a>
- <a class="chip" href="/blog/topics/use-cases/" aria-current="page">use-cases<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
</div>
</header>
@@ -90,6 +90,24 @@
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
+ <span>USE CASES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
diff --git a/docs/blog/trigger-ai-agents-from-github-webhook/index.html b/docs/blog/trigger-ai-agents-from-github-webhook/index.html
new file mode 100644
index 00000000..e59c25fe
--- /dev/null
+++ b/docs/blog/trigger-ai-agents-from-github-webhook/index.html
@@ -0,0 +1,420 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>How to Trigger Your AI Agent Hive from a GitHub Webhook — Munder Difflin Blog</title>
+<meta name="description" content="Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host." />
+<link rel="canonical" href="https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="How to Trigger Your AI Agent Hive from a GitHub Webhook — Munder Difflin Blog" />
+<meta property="og:description" content="Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host." />
+<meta property="og:url" content="https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+<meta property="article:published_time" content="2026-06-10T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Guides" />
+<meta property="article:tag" content="Automation" />
+<meta property="article:tag" content="GitHub" />
+<meta property="article:tag" content="Webhooks" />
+<meta property="article:tag" content="Hive" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="How to Trigger Your AI Agent Hive from a GitHub Webhook — Munder Difflin Blog" />
+<meta name="twitter:description" content="Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "How to Trigger Your AI Agent Hive from a GitHub Webhook",
+ "description": "Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-06-10T00:00:00.000Z",
+ "author": { "@type": "Person", "name": "Chaitanya Giri" },
+ "publisher": {
+ "@type": "Organization",
+ "name": "Munder Difflin",
+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
+ },
+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/" },
+ "keywords": "github webhook ai agent, trigger ai agents from github, github webhook automation, webhook to ai orchestrator, ci ai agent trigger",
+ "articleSection": "Guides",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "How to Trigger Your AI Agent Hive from a GitHub Webhook", "item": "https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "Can you trigger an AI agent from a GitHub webhook?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Munder Difflin runs a small, opt-in local webhook that turns an inbound POST into a task. Point a GitHub webhook (or a one-line curl from a GitHub Action) at the public URL with the shared secret in an x-md-webhook-secret header and a JSON body of { message, title? }, and the GOD orchestrator picks it up, files a kanban card, and routes it to an agent." } },
+ { "@type": "Question", "name": "Is the Munder Difflin webhook secure?", "acceptedAnswer": { "@type": "Answer", "text": "It's built to be. Every POST must carry your shared secret in x-md-webhook-secret, compared in constant time, and the secret is verified before the body is even buffered. A 1 MB body cap and a fixed-window rate limit (120 requests/minute) bound abuse ahead of any parsing. The response hands back a 192-bit capability token; a GET reveals only that one task's status — no listing, no enumeration." } },
+ { "@type": "Question", "name": "Do I need to host a public server to receive GitHub webhooks?", "acceptedAnswer": { "@type": "Answer", "text": "No. The endpoint runs on your own machine inside the desktop app. A best-effort local tunnel (tunnelmole) gives GitHub a public URL to reach your local port, so there's nothing to deploy. If the tunnel can't start, the local handler still runs — the tunnel is a doorbell, not the security boundary." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/guides/">Guides</a>
+ </nav>
+ <h1>How to Trigger Your AI Agent Hive from a GitHub Webhook</h1>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</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-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>7 min read</span>
+ <span class="tag kind">Guides</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>Munder Difflin can <strong>turn a GitHub
+webhook into a task for your hive</strong>. Flip on the webhook trigger, copy the public URL it opens via
+a local tunnel, and have GitHub (or a GitHub Action) <strong>POST <code>{ message, title? }</code></strong>
+with your shared secret in an <code>x-md-webhook-secret</code> header. The GOD orchestrator files a kanban
+card, routes it to an agent, and hands back a <strong>capability token</strong> you can poll for status.
+The endpoint lives <em>on your machine</em>; the tunnel is just a doorbell. Off by default until you switch
+it on.</p></div>
+<p>Most of the time you brief your agents from the app. But a lot of work <em>starts</em> in GitHub — a PR opens, an
+issue gets a label, a release tag lands. Munder Difflin’s webhook trigger lets you bridge that gap: a GitHub
+event becomes a task in your hive’s queue, triaged and routed by <a href="/blog/how-the-god-orchestrator-works/">the GOD
+orchestrator</a> like any other piece of work. This is a hands-on
+walkthrough using GitHub as the concrete example, but the same endpoint accepts a POST from anything that
+can speak HTTP.</p>
+<h2 id="what-the-webhook-trigger-actually-does" tabindex="-1">What the webhook trigger actually does <a class="anchor" href="#what-the-webhook-trigger-actually-does" aria-hidden="true">#</a></h2>
+<p>The contract is small and worth stating exactly, because everything downstream depends on it.</p>
+<ul>
+<li><strong><code>POST</code></strong> to the endpoint with an <code>x-md-webhook-secret: &lt;your-secret&gt;</code> header and a JSON body of
+<code>{ message, title? }</code>. On success the message is routed to god/Michael, a stamped kanban card is created,
+and you get back <code>{ ok: true, token, taskId }</code>.</li>
+<li><strong><code>GET</code></strong> the endpoint with <code>x-md-webhook-token: &lt;token&gt;</code> (or <code>?token=&lt;token&gt;</code>) and you get back
+<code>{ ok, status, title, result }</code> — <strong>only</strong> for that one token’s task.</li>
+</ul>
+<p>That’s the whole surface. <code>message</code> is the work to do (a required, non-empty string); <code>title</code> is an optional
+label for the card. Note what is <em>not</em> in that body: the secret. It’s verified at the door and never forwarded
+into the routed message, the card, or the response — so it can’t leak downstream.</p>
+<p>This is <strong>inbound</strong> automation — the outside world asking your hive to <em>do</em> something. It’s the mirror of
+<a href="/blog/human-in-the-loop-approving-ai-agents/">human-in-the-loop approvals</a>, where an agent reaches <em>out</em> to a
+person mid-run. One starts work remotely; the other checks with you. Together they let a hive run while you’re
+not at the keyboard.</p>
+<h2 id="step-1-enable-the-webhook-trigger-and-get-the-public-url" tabindex="-1">Step 1 — Enable the webhook trigger and get the public URL <a class="anchor" href="#step-1-enable-the-webhook-trigger-and-get-the-public-url" aria-hidden="true">#</a></h2>
+<p>In Munder Difflin, switch on the webhook trigger and set a <strong>shared secret</strong> (treat it like a password — long
+and random). When it starts, two things happen:</p>
+<ol>
+<li>A bare HTTP server binds to a local port inside the app’s main process. This is the security boundary, and
+it’s live the instant the port is bound.</li>
+<li>The app opens a <strong>best-effort local tunnel</strong> (via <code>tunnelmole</code>) and hands you a <strong>public URL</strong> that forwards
+to that local port. That’s the URL you give GitHub.</li>
+</ol>
+<p>The tunnel is non-fatal by design. If it can’t be established, the local handler keeps running and the app
+reports the tunnel error without a URL — so you’re never in a half-broken state where the endpoint is exposed
+but unguarded. The tunnel is a doorbell; it is not what keeps strangers out.</p>
+<p>Copy the public URL. You’ll paste it into GitHub next.</p>
+<h2 id="step-2-point-github-at-it" tabindex="-1">Step 2 — Point GitHub at it <a class="anchor" href="#step-2-point-github-at-it" aria-hidden="true">#</a></h2>
+<p>You have two clean ways to do this, depending on how literal you want to be.</p>
+<p><strong>Option A — A GitHub Action (recommended).</strong> GitHub’s native webhooks send GitHub’s <em>own</em> payload shape, but
+our endpoint wants <code>{ message, title? }</code>. The simplest, most accurate bridge is a one-step workflow that POSTs
+exactly the body the endpoint expects. Drop this in <code>.github/workflows/notify-hive.yml</code>:</p>
+<pre class="language-yaml"><code class="language-yaml"><span class="token key atrule">name</span><span class="token punctuation">:</span> Notify Hive
+<span class="token key atrule">on</span><span class="token punctuation">:</span>
+ <span class="token key atrule">pull_request</span><span class="token punctuation">:</span>
+ <span class="token key atrule">types</span><span class="token punctuation">:</span> <span class="token punctuation">[</span>opened<span class="token punctuation">,</span> reopened<span class="token punctuation">]</span>
+<span class="token key atrule">jobs</span><span class="token punctuation">:</span>
+ <span class="token key atrule">ping</span><span class="token punctuation">:</span>
+ <span class="token key atrule">runs-on</span><span class="token punctuation">:</span> ubuntu<span class="token punctuation">-</span>latest
+ <span class="token key atrule">steps</span><span class="token punctuation">:</span>
+ <span class="token punctuation">-</span> <span class="token key atrule">name</span><span class="token punctuation">:</span> POST to Munder Difflin
+ <span class="token key atrule">run</span><span class="token punctuation">:</span> <span class="token punctuation">|</span><span class="token scalar string">
+ curl -sS -X POST "$HIVE_URL" \
+ -H "x-md-webhook-secret: $HIVE_SECRET" \
+ -H "content-type: application/json" \
+ -d "{\"message\": \"Review PR #$: $ — $\", \"title\": \"PR #$\"}"</span>
+ <span class="token key atrule">env</span><span class="token punctuation">:</span>
+ <span class="token key atrule">HIVE_URL</span><span class="token punctuation">:</span> $
+ <span class="token key atrule">HIVE_SECRET</span><span class="token punctuation">:</span> $</code></pre>
+<p>Store the public URL as the <code>HIVE_URL</code> repo secret and your shared secret as <code>HIVE_SECRET</code> (Settings →
+Secrets and variables → Actions). Now every opened or reopened PR composes a one-sentence brief and posts it
+to your hive. Because <em>you</em> author the <code>message</code>, you control exactly what the orchestrator is asked to do.</p>
+<p><strong>Option B — A raw repository webhook.</strong> If you’d rather use Settings → Webhooks, you can — but be aware GitHub
+controls the payload there, and our endpoint reads only the top-level <code>message</code> and <code>title</code> strings. GitHub’s
+event payload doesn’t contain those keys, so a raw webhook won’t produce a usable task on its own. Use the
+Action approach when you want the hive to receive a clean, purposeful instruction rather than a raw event dump.</p>
+<blockquote>
+<p>Tip: GitHub webhooks have their own <code>secret</code> field that signs the body with HMAC. That’s GitHub’s scheme,
+not ours — our endpoint authenticates on the <code>x-md-webhook-secret</code> <em>header</em>, which the Action sets
+explicitly. Don’t confuse the two.</p>
+</blockquote>
+<h2 id="step-3-confirm-a-triggering-post-works" tabindex="-1">Step 3 — Confirm a triggering POST works <a class="anchor" href="#step-3-confirm-a-triggering-post-works" aria-hidden="true">#</a></h2>
+<p>Before wiring CI, prove the round trip with <code>curl</code>:</p>
+<pre class="language-bash"><code class="language-bash"><span class="token function">curl</span> <span class="token parameter variable">-sS</span> <span class="token parameter variable">-X</span> POST <span class="token string">"https://your-tunnel-url.example"</span> <span class="token punctuation">\</span>
+ <span class="token parameter variable">-H</span> <span class="token string">"x-md-webhook-secret: YOUR_SECRET"</span> <span class="token punctuation">\</span>
+ <span class="token parameter variable">-H</span> <span class="token string">"content-type: application/json"</span> <span class="token punctuation">\</span>
+ <span class="token parameter variable">-d</span> <span class="token string">'{"message": "Triage the newest open issue and draft a first response.", "title": "Issue triage"}'</span></code></pre>
+<p>A good response looks like:</p>
+<pre class="language-json"><code class="language-json"><span class="token punctuation">{</span> <span class="token property">"ok"</span><span class="token operator">:</span> <span class="token boolean">true</span><span class="token punctuation">,</span> <span class="token property">"token"</span><span class="token operator">:</span> <span class="token string">"…192-bit token…"</span><span class="token punctuation">,</span> <span class="token property">"taskId"</span><span class="token operator">:</span> <span class="token string">"…card id…"</span> <span class="token punctuation">}</span></code></pre>
+<p>Hang onto that <code>token</code>. To check what the hive did with it, <code>GET</code> the same endpoint:</p>
+<pre class="language-bash"><code class="language-bash"><span class="token function">curl</span> <span class="token parameter variable">-sS</span> <span class="token string">"https://your-tunnel-url.example"</span> <span class="token parameter variable">-H</span> <span class="token string">"x-md-webhook-token: YOUR_TOKEN"</span>
+<span class="token comment"># → { "ok": true, "status": "…", "title": "Issue triage", "result": "…" }</span></code></pre>
+<p>The token is the <em>only</em> key to that task. A <code>GET</code> returns only the status, title, and result for the one task
+it maps to — it can’t list or enumerate any other work. An unknown token gets the same <code>404</code> as a malformed
+one, so a probe can’t tell “valid but unknown” from “wrong shape.”</p>
+<h2 id="what-the-hive-does-with-it" tabindex="-1">What the hive does with it <a class="anchor" href="#what-the-hive-does-with-it" aria-hidden="true">#</a></h2>
+<p>Once a POST passes the secret check, the handler hands <code>{ message, title }</code> to the app, which <strong>routes the
+message to god/Michael</strong> — the orchestrator’s inbox — and <strong>files a stamped kanban card</strong>. From there it’s
+just another task: the orchestrator reads it, decides who should handle it, and dispatches to the right agent,
+exactly like work that arrives through <a href="/blog/coordinating-ai-coding-agents/">the hive’s normal message
+routing</a>. A reviewer agent might read the PR; a writer might draft the
+issue response. The webhook doesn’t pick the agent — it just gets the work onto the board.</p>
+<h2 id="security-in-one-breath" tabindex="-1">Security, in one breath <a class="anchor" href="#security-in-one-breath" aria-hidden="true">#</a></h2>
+<p>A public endpoint that can enqueue work for autonomous agents is exactly what you don’t want strangers poking,
+so the handler treats every request as hostile until proven otherwise:</p>
+<ul>
+<li><strong>Secret-gated, constant-time.</strong> A POST must carry the exact secret in <code>x-md-webhook-secret</code>, compared in
+constant time. A length mismatch fails immediately.</li>
+<li><strong>Authenticate before buffering.</strong> The secret is checked <em>before</em> the request body is read, so an
+unauthenticated peer can’t make the server buffer anything (within the cap).</li>
+<li><strong>Bounded before any work.</strong> A <strong>1 MB body cap</strong> and a <strong>fixed-window rate limit</strong> (120 requests/minute,
+globally — the remote IP is the tunnel’s, so per-IP would be meaningless) reject abuse ahead of any parse
+or crypto.</li>
+<li><strong>Capability tokens, not listings.</strong> The 192-bit token a POST returns is unguessable, and a GET scoped to
+it reveals only that single task.</li>
+</ul>
+<p>The secret stays local and is never logged, echoed, or forwarded. The principle is the one every trust
+boundary should follow: authenticate at the edge, fail closed, keep verification cheap and constant-time.</p>
+<h2 id="why-this-fits-a-local-first-hive" tabindex="-1">Why this fits a local-first hive <a class="anchor" href="#why-this-fits-a-local-first-hive" aria-hidden="true">#</a></h2>
+<p>It would’ve been easier to host this as a cloud function. Doing it as a <strong>local</strong> endpoint is the point. Your
+agents, their memory, and your git history never leave your machine — GitHub is only a <em>trigger</em>, a thin remote
+surface for starting and watching work. Nothing to deploy, nothing to pay for, no third party sitting between
+a repo event and your code. It’s the same philosophy behind <a href="/blog/local-first-ai-agent-orchestration/">local-first
+orchestration</a>: keep the control plane on your box, and let the
+outside world knock politely at the door.</p>
+<p>Pair it with <a href="/blog/scheduling-autonomous-agent-missions/">scheduled missions</a> and the picture rounds out:
+timers put recurring work in the queue, GitHub puts event-driven work in the queue, and the orchestrator runs
+both — whether or not you’re watching.</p>
+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
+<p><strong>Can you trigger an AI agent from GitHub?</strong> Yes — point a GitHub Action’s curl (or any HTTP client) at the
+webhook URL with your secret in <code>x-md-webhook-secret</code> and a <code>{ message, title? }</code> body, and the orchestrator
+files a card and routes it to an agent.</p>
+<p><strong>Is it secure?</strong> The secret is checked in constant time before the body is buffered, a 1 MB cap and a
+120/minute rate limit bound abuse first, and the POST returns a 192-bit capability token whose GET reveals only
+that one task. The secret is never logged or forwarded.</p>
+<p><strong>Do I need a public server?</strong> No. The endpoint runs locally; a best-effort tunnel gives GitHub a URL to reach
+it, and the handler runs even if the tunnel doesn’t.</p>
+<hr>
+<p>Munder Difflin turns a GitHub event into a remote control for a hive that still lives entirely on your machine
+— <a href="https://munderdiffl.in/#how">orchestrated by GOD</a>, verified at the edge, queued like any other task.
+<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to wire your repo into your agents; it’s free and
+open source.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">Can you trigger an AI agent from a GitHub webhook?</p>
+ <p class="a">Yes. Munder Difflin runs a small, opt-in local webhook that turns an inbound POST into a task. Point a GitHub webhook (or a one-line curl from a GitHub Action) at the public URL with the shared secret in an x-md-webhook-secret header and a JSON body of { message, title? }, and the GOD orchestrator picks it up, files a kanban card, and routes it to an agent.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Is the Munder Difflin webhook secure?</p>
+ <p class="a">It&#39;s built to be. Every POST must carry your shared secret in x-md-webhook-secret, compared in constant time, and the secret is verified before the body is even buffered. A 1 MB body cap and a fixed-window rate limit (120 requests/minute) bound abuse ahead of any parsing. The response hands back a 192-bit capability token; a GET reveals only that one task&#39;s status — no listing, no enumeration.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Do I need to host a public server to receive GitHub webhooks?</p>
+ <p class="a">No. The endpoint runs on your own machine inside the desktop app. A best-effort local tunnel (tunnelmole) gives GitHub a public URL to reach your local port, so there&#39;s nothing to deploy. If the tunnel can&#39;t start, the local handler still runs — the tunnel is a doorbell, not the security boundary.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/guides/">Guides</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/github/">GitHub</a><a class="tag" href="/blog/tags/webhooks/">Webhooks</a><a class="tag" href="/blog/tags/hive/">Hive</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#what-the-webhook-trigger-actually-does">What the webhook trigger actually does</a></li><li class="lvl-2"><a href="#step-1-enable-the-webhook-trigger-and-get-the-public-url">Step 1 — Enable the webhook trigger and get the public URL</a></li><li class="lvl-2"><a href="#step-2-point-github-at-it">Step 2 — Point GitHub at it</a></li><li class="lvl-2"><a href="#step-3-confirm-a-triggering-post-works">Step 3 — Confirm a triggering POST works</a></li><li class="lvl-2"><a href="#what-the-hive-does-with-it">What the hive does with it</a></li><li class="lvl-2"><a href="#security-in-one-breath">Security, in one breath</a></li><li class="lvl-2"><a href="#why-this-fits-a-local-first-hive">Why this fits a local-first hive</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/why-cli-agents-are-powerful/"><span class="k">← Older</span><span class="t">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</span></a>
+ <a class="pn next" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/"><span class="k">Newer →</span><span class="t">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Guides</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-09">Jun 9, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <span>GUIDES</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-06">Jun 6, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
+ <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/trigger-ai-agents-from-slack/index.html b/docs/blog/trigger-ai-agents-from-slack/index.html
index 386201b8..65aae0bd 100644
--- a/docs/blog/trigger-ai-agents-from-slack/index.html
+++ b/docs/blog/trigger-ai-agents-from-slack/index.html
@@ -268,56 +268,56 @@ it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/what-are-claude-code-agents/index.html b/docs/blog/what-are-claude-code-agents/index.html
index 0d55f597..d03e248b 100644
--- a/docs/blog/what-are-claude-code-agents/index.html
+++ b/docs/blog/what-are-claude-code-agents/index.html
@@ -247,56 +247,56 @@ into an office; it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/what-is-a-multi-agent-harness/index.html b/docs/blog/what-is-a-multi-agent-harness/index.html
index 70f42d64..2b40783e 100644
--- a/docs/blog/what-is-a-multi-agent-harness/index.html
+++ b/docs/blog/what-is-a-multi-agent-harness/index.html
@@ -234,56 +234,56 @@ want to watch a coordinated team of agents work an office floor,
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/what-is-aeo-for-dev-tools/index.html b/docs/blog/what-is-aeo-for-dev-tools/index.html
index 8266b8c3..da631362 100644
--- a/docs/blog/what-is-aeo-for-dev-tools/index.html
+++ b/docs/blog/what-is-aeo-for-dev-tools/index.html
@@ -367,56 +367,56 @@ harness actually is</a>. Free and MIT-licensed.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/whats-new-in-agentic-ai-june-2026/index.html b/docs/blog/whats-new-in-agentic-ai-june-2026/index.html
index 05ddd35d..2caf523b 100644
--- a/docs/blog/whats-new-in-agentic-ai-june-2026/index.html
+++ b/docs/blog/whats-new-in-agentic-ai-june-2026/index.html
@@ -326,56 +326,56 @@ hive run; it’s free and open source.</p>
<h2>Related in Guides</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
- <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</p>
+ <h3><a href="/blog/run-ai-agent-hive-from-slack-setup/">Run Your AI Agent Hive from Slack: The Complete Setup</a></h3>
+ <p class="dek">Step-by-step setup for driving Munder Difflin&#39;s AI agent hive from Slack: create the app, set scopes, paste the tunnel Request URL, and @mention your bot to start work — done-summaries post back in-thread.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
+ <a class="more" href="/blog/run-ai-agent-hive-from-slack-setup/" aria-label="Read: Run Your AI Agent Hive from Slack: The Complete Setup">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-github-webhook/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-06">Jun 6, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/">Does the June 2026 Agent SDK Change Affect Munder Difflin?</a></h3>
- <p class="dek">From June 15, 2026 the Claude Agent SDK gets a separate credit. Munder Difflin drives the native Claude Code CLI, so your hive runs on your plan as before.</p>
+ <h3><a href="/blog/trigger-ai-agents-from-github-webhook/">How to Trigger Your AI Agent Hive from a GitHub Webhook</a></h3>
+ <p class="dek">Wire a GitHub webhook to Munder Difflin: a secret-gated local endpoint turns each repo event into a task for your GOD orchestrator — POST a message, get a token, poll the result. No server to host.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/does-the-june-2026-agent-sdk-change-affect-munder-difflin/" aria-label="Read: Does the June 2026 Agent SDK Change Affect Munder Difflin?">Read →</a>
+ <a class="more" href="/blog/trigger-ai-agents-from-github-webhook/" aria-label="Read: How to Trigger Your AI Agent Hive from a GitHub Webhook">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/how-to-install-and-use-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>9 min</span>
+ <span>7 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>
+ <h3><a href="/blog/munder-difflin-v0-2-4-feature-walkthrough/">Munder Difflin v0.2.4 Feature Walkthrough</a></h3>
+ <p class="dek">A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.</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>
+ <a class="more" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-label="Read: Munder Difflin v0.2.4 Feature Walkthrough">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/when-do-agents-need-an-agent-protocol/index.html b/docs/blog/when-do-agents-need-an-agent-protocol/index.html
index c2e7ba88..6a2b7580 100644
--- a/docs/blog/when-do-agents-need-an-agent-protocol/index.html
+++ b/docs/blog/when-do-agents-need-an-agent-protocol/index.html
@@ -277,56 +277,56 @@ of agents without protocol ceremony; it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>
- <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/why-cli-agents-are-powerful/index.html b/docs/blog/why-cli-agents-are-powerful/index.html
new file mode 100644
index 00000000..2815f62d
--- /dev/null
+++ b/docs/blog/why-cli-agents-are-powerful/index.html
@@ -0,0 +1,414 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work — Munder Difflin Blog</title>
+<meta name="description" content="CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it." />
+<link rel="canonical" href="https://munderdiffl.in/blog/why-cli-agents-are-powerful/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work — Munder Difflin Blog" />
+<meta property="og:description" content="CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it." />
+<meta property="og:url" content="https://munderdiffl.in/blog/why-cli-agents-are-powerful/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+<meta property="article:published_time" content="2026-06-10T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Concepts" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Local-First" />
+<meta property="article:tag" content="Cost" />
+<meta property="article:tag" content="CLI Agents" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work — Munder Difflin Blog" />
+<meta name="twitter:description" content="CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it." />
+<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" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work",
+ "description": "CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-10T00:00:00.000Z",
+ "dateModified": "2026-06-10T00:00:00.000Z",
+ "author": { "@type": "Person", "name": "Chaitanya Giri" },
+ "publisher": {
+ "@type": "Organization",
+ "name": "Munder Difflin",
+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
+ },
+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/why-cli-agents-are-powerful/" },
+ "keywords": "cli agents, why cli agents are powerful, terminal-level ai agents, reduce agent token consumption, local-first ai agents, shared agent memory",
+ "articleSection": "Concepts",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/why-cli-agents-are-powerful/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work", "item": "https://munderdiffl.in/blog/why-cli-agents-are-powerful/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "Why are CLI agents more powerful than chat-only assistants?", "acceptedAnswer": { "@type": "Answer", "text": "Because a CLI agent has terminal-level access to the machine it runs on. It can read and write real files, run the build, run the tests, use git, and call any tool you have installed — then read the actual output and react to it. A chat assistant can only suggest a change; a CLI agent makes the change and proves it works by executing it. That closes the loop between proposing and verifying, which is the whole game in autonomous work." } },
+ { "@type": "Question", "name": "Why does running CLI agents locally matter?", "acceptedAnswer": { "@type": "Answer", "text": "Local execution is what makes the terminal-level access real. The agent operates on your actual filesystem, your installed toolchain, and your git history — no upload, no sandbox copy, no round-trip to a vendor's environment. You also get privacy (code and data never leave the machine), and the agents can run 24/7 on hardware you already own instead of metered cloud compute." } },
+ { "@type": "Question", "name": "How does Munder Difflin reduce token consumption?", "acceptedAnswer": { "@type": "Answer", "text": "Four structural levers. A shared memory layer and board so agents read context once instead of re-deriving it per turn. Scoped task contracts so each agent only loads what its job needs, not the whole project. A token-budget steward that paces and caps spend across the hive. And capability routing — sending routine work to a cheaper-tier agent and reserving the expensive orchestrator for reasoning — instead of one giant always-on context carrying everything." } },
+ { "@type": "Question", "name": "Does a shared memory layer actually save tokens?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, because the expensive part of an agent isn't the model — it's the context it re-reads every turn, multiplied across a whole team. When agents share a board and a memory layer, the project's facts, decisions, and state are derived once and recalled compactly, instead of each agent re-discovering them by re-reading files into its own window. In a fleet you pay context N times, so removing redundant re-derivation compounds." } },
+ { "@type": "Question", "name": "Is Munder Difflin local-first and open source?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Munder Difflin is a local, 24/7 multi-agent CLI harness that runs as an Electron desktop app on your own computer. It drives the CLIs you already have — Claude Code, Codex, Antigravity — so there's no API key and no per-seat platform tax on top of model tokens. It's free and open source." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/concepts/">Concepts</a>
+ </nav>
+ <h1>Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</h1>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</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-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>7 min read</span>
+ <span class="tag kind">Concepts</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>CLI agents are powerful for one
+reason: terminal-level access.</strong> They don't just <em>suggest</em> edits — they read and write
+real files, run builds and tests, use git, call any installed tool, and <strong>verify their own work by
+actually executing it</strong>. Running them <strong>locally</strong> (as Munder Difflin does) is what
+makes that access real: your filesystem, your toolchain, your git history, private and on 24/7. And
+because a whole hive of these agents could get expensive, Munder Difflin cuts token consumption with four
+structural levers: a <strong>shared memory layer + board</strong>, <strong>scoped task contracts</strong>,
+a <strong>token-budget steward</strong>, and <strong>capability routing</strong> — so agents stop
+re-deriving context and stop paying frontier prices for routine work.</p></div>
+<p>There’s a quiet line that separates a <em>chat assistant</em> from an <em>agent</em>, and almost everyone draws it in
+the wrong place. It’s not “how smart is the model.” It’s a much more boring question: <strong>can the thing
+actually touch the machine?</strong></p>
+<p>A chat assistant lives behind a glass wall. You describe a problem, it describes a solution, and the
+handoff back to reality — applying the diff, running the build, reading the error, trying again — is
+<em>your</em> job. A CLI agent lives on the other side of that wall. It has a terminal. And a terminal changes
+everything.</p>
+<h2 id="the-whole-argument-terminal-level-access-closes-the-loop" tabindex="-1">The whole argument: terminal-level access closes the loop <a class="anchor" href="#the-whole-argument-terminal-level-access-closes-the-loop" aria-hidden="true">#</a></h2>
+<p>Give an AI a terminal on a real machine and a short, specific list of unlocks falls out:</p>
+<ul>
+<li><strong>It reads and writes real files</strong> — not a pasted snippet, the actual file on disk, in the actual
+project, with the actual surrounding code.</li>
+<li><strong>It runs the build and the tests</strong> — and then <em>reads the output</em>. A failing test isn’t a
+hypothetical; it’s a stack trace the agent can see and respond to.</li>
+<li><strong>It uses git</strong> — branches, diffs, commits, blame. It can inspect history to understand <em>why</em> code is
+the way it is, and leave an audit trail of what it changed.</li>
+<li><strong>It calls any tool you have installed</strong> — your linter, your formatter, your package manager, your
+deploy script, <code>curl</code>, <code>jq</code>, the CLI for your database. If it’s on your <code>PATH</code>, it’s in the agent’s
+hands.</li>
+</ul>
+<p>Each bullet is useful on its own. Together they do something a chat assistant structurally cannot:
+<strong>they close the loop between proposing a change and verifying it.</strong></p>
+<p>This is the part worth slowing down on. A language model is extremely good at producing a <em>plausible</em>
+answer — “this should fix it, the build will pass now.” Plausible is cheap. Plausible is also, often,
+wrong. The difference between a toy and a tool is whether the system can <em>check itself</em>, and checking
+requires execution. You can’t verify a build is green by reasoning about it; you verify it by running it
+and reading the output. A CLI agent can do that. A chat assistant can only assert it. (We wrote a whole
+piece on this discipline: <a href="/blog/how-ai-agents-verify-their-own-work/">how AI agents verify their own work before saying
+“done.”</a>)</p>
+<p>So the headline isn’t “CLI agents can type commands.” It’s that <strong>a terminal turns a generator into a
+worker</strong> — something that can act, observe the consequence, and correct, in a tight loop, without a human
+shuttling output back and forth across the glass.</p>
+<h2 id="local-is-what-makes-the-access-real" tabindex="-1">Local is what makes the access <em>real</em> <a class="anchor" href="#local-is-what-makes-the-access-real" aria-hidden="true">#</a></h2>
+<p>Here’s the catch people miss. Terminal-level access is only as powerful as the machine the terminal is
+attached to. And there’s a real difference between an agent running in some vendor’s ephemeral container
+and an agent running <strong>on your own computer.</strong></p>
+<p>Run it locally and the access stops being a sandbox approximation and becomes the genuine article:</p>
+<ul>
+<li><strong>Real filesystem.</strong> The agent works on <em>your</em> repo, in place — not an uploaded copy, not a snapshot
+that drifts out of sync. The file it edits is the file you ship.</li>
+<li><strong>Real toolchain.</strong> It uses the exact versions of the exact tools you have installed. The build that
+passes for the agent is the build that passes for you, because it’s the same build.</li>
+<li><strong>Privacy.</strong> Your code, your data, and your secrets never leave the machine to make this work. For a
+lot of teams that’s not a nice-to-have; it’s the difference between “allowed” and “not allowed.”</li>
+<li><strong>24/7 on hardware you already own.</strong> A local agent doesn’t clock out and doesn’t bill you for idle
+compute. Close the lid, open it tomorrow, and the floor is still there.</li>
+</ul>
+<p>This is the bet <strong>Munder Difflin</strong> makes. It’s a local, 24/7 multi-agent CLI harness — an Electron
+desktop app that runs a whole <em>virtual office</em> of Office-themed agents on your computer, collaborating
+through a shared board, inboxes, and memory. It doesn’t replace your CLI agents; it <strong>drives the ones you
+already have</strong> — Claude Code, Codex, Antigravity — so the terminal-level access is real, local, and
+private by construction. (For the deeper case, see <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters for AI
+agents</a>.)</p>
+<h2 id="but-a-hive-of-agents-could-get-expensive-so-heres-how-munder-difflin-doesnt" tabindex="-1">But a hive of agents could get expensive — so here’s how Munder Difflin doesn’t <a class="anchor" href="#but-a-hive-of-agents-could-get-expensive-so-heres-how-munder-difflin-doesnt" aria-hidden="true">#</a></h2>
+<p>Everything above is the upside. The honest downside of “run a whole office of agents” is the obvious one:
+<strong>N agents, each running a powerful model, each carrying its own context, is N times the token bill.</strong>
+Power that you can’t afford isn’t power.</p>
+<p>The naive design — one giant, always-on context that every agent shares and everyone re-reads on every
+turn — is exactly the design that bankrupts you. Munder Difflin is built the other way, around four
+structural levers that cut token consumption without dumbing the agents down. None of these are
+benchmark claims; they’re architectural choices, and you can reason about why each one bends the curve.</p>
+<p><strong>1. A shared memory layer and board — so agents don’t re-derive context.</strong> The expensive part of an
+agent isn’t the model call; it’s the <em>context</em> it re-reads every turn, paid again for every agent in the
+fleet. When the hive shares a board and a <a href="/blog/markdown-first-agent-memory/">memory layer</a>, the
+project’s facts, decisions, and current state are derived <strong>once</strong> and recalled compactly — instead of
+each agent independently re-discovering them by dragging files back into its own window. Redundant
+re-derivation is the single biggest avoidable cost in a multi-agent system, and shared memory is the
+direct fix.</p>
+<p><strong>2. Scoped task contracts — so each agent loads only what its job needs.</strong> Instead of handing every
+agent the whole project and hoping it stays focused, work arrives as a <em>scoped contract</em>: here’s the
+task, here’s the slice of context that’s relevant, here’s what “done” looks like. The agent’s window
+stays small because its job is small. This is <a href="/blog/context-engineering-for-ai-agents/">context discipline</a>
+made structural — the harness scopes the context for you rather than relying on the model to ignore the
+parts it doesn’t need (it won’t, and you’d pay for them anyway).</p>
+<p><strong>3. A token-budget steward — so spend is paced and capped, not unbounded.</strong> Autonomy without a budget is
+how you wake up to a surprise bill. Munder Difflin runs the hive against a token budget: a steward that
+paces work and caps consumption across the floor, so a long-running mission grinds along <em>within a
+ceiling</em> instead of sprinting until the meter screams. Predictable, attributable cost is part of what
+makes 24/7 operation safe to leave running.</p>
+<p><strong>4. Capability routing — so the right agent does the work, not the most expensive one.</strong> The price
+spread between a small model and a frontier one is large, and most agent work is routine. So you route:
+the cheap-tier worker handles the routine majority, and the expensive orchestrator is reserved for the
+reasoning that actually needs it. One always-on giant context paying frontier rates for file-shuffling is
+pure waste; <a href="/blog/do-more-with-less-model-routing/">routing work to the right-capability agent</a> is how a
+fleet costs <em>less</em> than the single over-powered agent it replaces.</p>
+<p>These compound. Shared memory removes the re-derivation, scoped contracts shrink each window, the steward
+caps the total, and routing keeps frontier prices off routine work. (For the full unified treatment, see
+<a href="/blog/the-multi-agent-cost-playbook/">the multi-agent cost playbook</a>.) The point isn’t a magic discount
+— it’s that a hive is only worth running if it’s <em>engineered</em> to be affordable, and these are the
+mechanics that make it so.</p>
+<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>
+<p>CLI agents are powerful because a terminal turns a model from a thing that <em>talks about</em> work into a
+thing that <em>does</em> work — reading files, running builds, using git, calling your tools, and verifying
+itself by execution. Local-first is what makes that access real, private, and always-on. And a
+shared-memory, scoped-contract, budgeted, capability-routed hive is what makes a <em>floor</em> of those agents
+something you can actually afford to leave running.</p>
+<p>That’s Munder Difflin: a virtual office of CLI agents on your own computer — real access, real
+verification, fewer tokens. <a href="https://munderdiffl.in/#install">Download it</a> — it’s free, open source, and
+local-first.</p>
+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
+<p><strong>Why are CLI agents more powerful than chat-only assistants?</strong> Terminal-level access. A CLI agent makes
+the change and proves it works by running it; a chat assistant can only suggest one. Execution closes the
+loop between proposing and verifying.</p>
+<p><strong>Why run them locally?</strong> Local execution is what makes the access real — your actual filesystem,
+toolchain, and git history — plus privacy and 24/7 operation on hardware you own.</p>
+<p><strong>How does Munder Difflin cut token use?</strong> Shared memory and a board (don’t re-derive context), scoped
+task contracts (load only what the job needs), a token-budget steward (pace and cap spend), and
+capability routing (right agent, not the priciest one).</p>
+<p>Sources: <a href="https://platform.claude.com/docs/en/build-with-claude/prompt-caching">Anthropic — Prompt caching</a>;
+<a href="https://platform.claude.com/docs/en/about-claude/pricing">Anthropic — Pricing</a>.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">Why are CLI agents more powerful than chat-only assistants?</p>
+ <p class="a">Because a CLI agent has terminal-level access to the machine it runs on. It can read and write real files, run the build, run the tests, use git, and call any tool you have installed — then read the actual output and react to it. A chat assistant can only suggest a change; a CLI agent makes the change and proves it works by executing it. That closes the loop between proposing and verifying, which is the whole game in autonomous work.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Why does running CLI agents locally matter?</p>
+ <p class="a">Local execution is what makes the terminal-level access real. The agent operates on your actual filesystem, your installed toolchain, and your git history — no upload, no sandbox copy, no round-trip to a vendor&#39;s environment. You also get privacy (code and data never leave the machine), and the agents can run 24/7 on hardware you already own instead of metered cloud compute.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How does Munder Difflin reduce token consumption?</p>
+ <p class="a">Four structural levers. A shared memory layer and board so agents read context once instead of re-deriving it per turn. Scoped task contracts so each agent only loads what its job needs, not the whole project. A token-budget steward that paces and caps spend across the hive. And capability routing — sending routine work to a cheaper-tier agent and reserving the expensive orchestrator for reasoning — instead of one giant always-on context carrying everything.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Does a shared memory layer actually save tokens?</p>
+ <p class="a">Yes, because the expensive part of an agent isn&#39;t the model — it&#39;s the context it re-reads every turn, multiplied across a whole team. When agents share a board and a memory layer, the project&#39;s facts, decisions, and state are derived once and recalled compactly, instead of each agent re-discovering them by re-reading files into its own window. In a fleet you pay context N times, so removing redundant re-derivation compounds.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Is Munder Difflin local-first and open source?</p>
+ <p class="a">Yes. Munder Difflin is a local, 24/7 multi-agent CLI harness that runs as an Electron desktop app on your own computer. It drives the CLIs you already have — Claude Code, Codex, Antigravity — so there&#39;s no API key and no per-seat platform tax on top of model tokens. It&#39;s free and open source.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/concepts/">Concepts</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/local-first/">Local-First</a><a class="tag" href="/blog/tags/cost/">Cost</a><a class="tag" href="/blog/tags/cli-agents/">CLI Agents</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#the-whole-argument-terminal-level-access-closes-the-loop">The whole argument: terminal-level access closes the loop</a></li><li class="lvl-2"><a href="#local-is-what-makes-the-access-real">Local is what makes the access real</a></li><li class="lvl-2"><a href="#but-a-hive-of-agents-could-get-expensive-so-heres-how-munder-difflin-doesnt">But a hive of agents could get expensive — so here’s how Munder Difflin doesn’t</a></li><li class="lvl-2"><a href="#the-bottom-line">The bottom line</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/launching-munder-difflin-v0-2-4/"><span class="k">← Older</span><span class="t">Launching Munder Difflin v0.2.4</span></a>
+ <a class="pn next" href="/blog/trigger-ai-agents-from-github-webhook/"><span class="k">Newer →</span><span class="t">How to Trigger Your AI Agent Hive from a GitHub Webhook</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Concepts</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-05">Jun 5, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>4 min</span>
+ </div>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-04">Jun 4, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
+ <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/why-local-first-matters-for-ai-agents/index.html b/docs/blog/why-local-first-matters-for-ai-agents/index.html
index b0669866..2631b4a8 100644
--- a/docs/blog/why-local-first-matters-for-ai-agents/index.html
+++ b/docs/blog/why-local-first-matters-for-ai-agents/index.html
@@ -234,43 +234,43 @@ machine, on macOS, Windows, and Linux. <a href="/#install">Download Munder Diffl
<h2>Related in Use Cases</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
- <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
+ <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>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
+ <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>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-02">Jun 2, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>3 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
- <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)</a></h3>
+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What&#39;s Realistic (and What&#39;s Not)">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
<div class="body">
@@ -279,11 +279,11 @@ machine, on macOS, Windows, and Linux. <a href="/#install">Download Munder Diffl
<span class="dot" aria-hidden="true"></span>
<span>3 min</span>
</div>
- <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>
- <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>
+ <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>
+ <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>
<div class="foot">
<span class="tag kind">Use Cases</span>
- <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>
+ <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>
</div>
</div>
</article>
diff --git a/docs/sitemap.xml b/docs/sitemap.xml
index a837166b..c11c9b30 100644
--- a/docs/sitemap.xml
+++ b/docs/sitemap.xml
@@ -10,13 +10,49 @@
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https://munderdiffl.in/</loc>
- <lastmod>2026-06-08</lastmod>
+ <lastmod>2026-06-09</lastmod>
<changefreq>weekly</changefreq>
<priority>1.0</priority>
</url>
<url><loc>https://munderdiffl.in/blog/</loc><changefreq>daily</changefreq><priority>0.9</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/</loc><changefreq>weekly</changefreq><priority>0.6</priority></url>
<url><loc>https://munderdiffl.in/blog/about/</loc><changefreq>monthly</changefreq><priority>0.4</priority></url>
+ <url>
+ <loc>https://munderdiffl.in/blog/deploy-a-blog-writer-agent/</loc>
+ <lastmod>2026-06-10</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>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/run-ai-agent-hive-from-slack-setup/</loc>
+ <lastmod>2026-06-10</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/</loc>
+ <lastmod>2026-06-10</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/trigger-ai-agents-from-github-webhook/</loc>
+ <lastmod>2026-06-10</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/why-cli-agents-are-powerful/</loc>
+ <lastmod>2026-06-10</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
<url>
<loc>https://munderdiffl.in/blog/launching-munder-difflin-v0-2-4/</loc>
<lastmod>2026-06-09</lastmod>
@@ -528,31 +564,33 @@
<priority>0.8</priority>
</url>
<url><loc>https://munderdiffl.in/blog/topics/guides/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
- <url><loc>https://munderdiffl.in/blog/topics/internals/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/concepts/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
+ <url><loc>https://munderdiffl.in/blog/topics/internals/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/comparisons/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/orchestration/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/memory/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
- <url><loc>https://munderdiffl.in/blog/topics/story/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/use-cases/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
+ <url><loc>https://munderdiffl.in/blog/topics/story/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/multi-agent/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/claude-code/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/internals/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/orchestration/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/guides/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/comparisons/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/concepts/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/comparisons/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/automation/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/tools/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/memory/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/getting-started/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/automation/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/mempalace/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/story/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/local-first/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/use-cases/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/open-source/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/mempalace/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/use-cases/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/story/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/hive/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/security/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/autonomous/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/cost/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/observability/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/guardrails/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/workflow/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
@@ -561,11 +599,10 @@
<url><loc>https://munderdiffl.in/blog/tags/electron/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/mcp/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/architecture/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/cost/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/model-routing/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/agentic-ai/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/aeo/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/seo/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/hive/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/release/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/god/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/messaging/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
@@ -578,8 +615,8 @@
<url><loc>https://munderdiffl.in/blog/tags/hooks/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/performance/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/reliability/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/model-routing/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/prompt-caching/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/slack/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/protocols/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/codex/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/subagents/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
@@ -606,7 +643,6 @@
<url><loc>https://munderdiffl.in/blog/tags/brand/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/the-office/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/munder-difflin/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/slack/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/devrel/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/industry/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/interoperability/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
@@ -614,4 +650,10 @@
<url><loc>https://munderdiffl.in/blog/tags/cline/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/geo/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/tutorial/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/content/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/code-review/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/setup/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/github/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/webhooks/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/cli-agents/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
</urlset>