an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
content(blog): 16 new posts — comparisons, harness/loop engineering concepts, product guides — + demo videos in 5 posts
Chaitanya Giridf15a9a96f2b
diff --git a/README.md b/README.mdindex 55c80bd3..62c3214a 100644--- a/README.md+++ b/README.md@@ -158,7 +158,7 @@ terminal/event plane, and [`DESIGN.md`](./DESIGN.md) for the visual system.| **Avatar states** | Avatars reflect real work — including new v0.2.0 states for *compacting* (context compaction) and *looping* (circuit-breaker intervention), on top of crisper HiDPI floor text and high-contrast speech bubbles. |> [!NOTE]-> **Status: v0.3.3 — a built-in Monaco IDE + GitHub Copilot CLI.** Two headliners. **A real IDE on the floor**: a title-bar **IDE** button opens a full-window **Monaco** editor (the VS Code editor engine, fully self-hosted — no CDN) over the office — a **git CHANGES rail with side-by-side diffs vs HEAD** for reviewing exactly what your agents changed, a workspace **file tree**, **editor tabs** with dirty-state tracking and **Cmd/Ctrl+S** save (hardened against losing keystrokes typed during an in-flight save), with **all fs/git access brokered through the main process** — the renderer touches no disk. And **GitHub Copilot CLI joins the engine roster** (the **first community-contributed provider**, [PR #101](https://github.com/chaitanyagiri/munder-difflin/pull/101) by [@anxkhn](https://github.com/anxkhn)): hire a Copilot-powered worker in its documented non-interactive print mode (`copilot -p` with `-s --allow-all-tools --no-ask-user` gated by the floor auto-mode toggle), a **model picker** (Claude Sonnet 4.5 default · GPT-5.4 · auto), `--resume` session continuity, and the official npm installer offered when the CLI is missing — authenticated by your **existing GitHub Copilot login**, no new keys. (Honest caveat: print mode exits per turn and has no hook bridge, so routed inbox mail bounces to the GOD orchestrator rather than draining — Copilot workers shine on dispatched, self-contained tasks.) Built on **v0.3.2 — Talk to Michael (Realtime Michael)**: a **low-latency voice channel to the GOD orchestrator** over the OpenAI Realtime API (WebRTC) — he reads the hive and, behind spoken **echo-back confirmation**, dispatches, spawns, kills, and steers, speaks completions the moment they land, under a live cost meter with spend cap and idle auto-disconnect (BYOK OpenAI key, minted main-only into ephemeral tokens). Built on **v0.3.1** (three more engines — **OpenCode · Crush · pi.dev** — each a worker *and* Michael, with **BYOK keys + local LLMs**) and **v0.3.0**'s platform release — **selectable agent engines**, an **integrations registry + loopback secret broker**, **Slack-spawned ephemeral workers**, **temporal date-range skills**, and the **Agent Gallery**. Everything from **v0.2.0–v0.3.2** — shareable hires, Free Flow voice dictation, the enterprise Knowledge Graph, multi-window "floors", the rich composer, agent session resume, observability, the circuit breaker, durable persistence, Command Center, task kanban, GitHub/CI integration, and the Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page. Press **Talk** and Michael listens, answers, and *acts* in real time over the **OpenAI Realtime API (WebRTC)**: he reads the hive (tasks, board, memory, agents, activity) and — behind spoken **echo-back confirmation** for anything destructive — creates and assigns work, dispatches agents, spawns and kills workers, and steers the floor, all attributed to a distinct **michael-voice** actor that pings the GOD terminal. He **greets you on connect**, **speaks task completions the moment they land** ("respond when done", with an on-screen toast + closed-session warm-start), and runs under a **live cost meter with a hard spend cap and idle auto-disconnect**. It's **bring-your-own OpenAI key**: the key is decrypted **main-only**, minted into **short-lived ephemeral session tokens**, and never reaches the renderer — and **Settings → AI Engines** documents the Realtime key as its own requirement, with the **Talk** button showing a live enabled/disabled cue. The realtime loop is **human-verified end-to-end** (connect → mic → answer, plus the full spawn/kill/dispatch action path) on a real OpenAI key; it requires **your own OpenAI key with Realtime API access**. Plus **Slack hardening** (proactive app/voice posting **off by default**; no sends without an explicit channel+thread), a dedicated **auto-compact maintenance schedule** decoupled from missions, and **per-agent environment metadata**. Built on **v0.3.1** (three more engines — **OpenCode · Crush · pi.dev** — each a worker *and* Michael, with **BYOK keys + local LLMs**) and **v0.3.0**'s platform release — **selectable agent engines** (every hire and Michael a pluggable engine with its own consented **skills + MCP catalog** behind a **consent UI**), an **integrations registry + loopback secret broker** (write-only secrets), **Slack-spawned ephemeral workers**, **temporal date-range skills**, and the **Agent Gallery** with **six off-the-shelf hires**. Everything from **v0.2.0–v0.3.1** — shareable hires, Free Flow voice dictation, the enterprise Knowledge Graph, multi-window "floors", the rich composer, agent session resume, observability, the circuit breaker, durable persistence, Command Center, task kanban, GitHub/CI integration, and the Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page.+> **Status: v0.3.3 — a built-in Monaco IDE + GitHub Copilot CLI.** Two headliners. **A real IDE on the floor**: a title-bar **IDE** button opens a full-window **Monaco** editor (the VS Code editor engine, fully self-hosted — no CDN) over the office — a **git CHANGES rail with side-by-side diffs vs HEAD** for reviewing exactly what your agents changed, a workspace **file tree**, **editor tabs** with dirty-state tracking and **Cmd/Ctrl+S** save (hardened against losing keystrokes typed during an in-flight save), with **all fs/git access brokered through the main process** — the renderer touches no disk. And **GitHub Copilot CLI joins the engine roster** (the **first community-contributed provider**, [PR #101](https://github.com/chaitanyagiri/munder-difflin/pull/101) by [@anxkhn](https://github.com/anxkhn)): hire a Copilot-powered worker in its documented non-interactive print mode (`copilot -p` with `-s --allow-all-tools --no-ask-user` gated by the floor auto-mode toggle), a **model picker** (Claude Sonnet 4.5 default · GPT-5.4 · auto), `--resume` session continuity, and the official npm installer offered when the CLI is missing — authenticated by your **existing GitHub Copilot login**, no new keys. (Honest caveat: print mode exits per turn and has no hook bridge, so routed inbox mail bounces to the GOD orchestrator rather than draining — Copilot workers shine on dispatched, self-contained tasks.) Built on **v0.3.2 — Talk to Michael (Realtime Michael)**: a **low-latency voice channel to the GOD orchestrator** over the OpenAI Realtime API (WebRTC) — he reads the hive and, behind spoken **echo-back confirmation**, dispatches, spawns, kills, and steers, speaks completions the moment they land, under a live cost meter with spend cap and idle auto-disconnect (BYOK OpenAI key, minted main-only into ephemeral tokens). Built on **v0.3.1** (three more engines — **OpenCode · Crush · pi.dev** — each a worker *and* Michael, with **BYOK keys + local LLMs**) and **v0.3.0**'s platform release — **selectable agent engines**, an **integrations registry + loopback secret broker**, **Slack-spawned ephemeral workers**, **temporal date-range skills**, and the **Agent Gallery**. Everything from **v0.2.0–v0.3.2** — shareable hires, Free Flow voice dictation, the enterprise Knowledge Graph, multi-window "floors", the rich composer, agent session resume, observability, the circuit breaker, durable persistence, Command Center, task kanban, GitHub/CI integration, and the Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page.<div align="right">(<a href="#munder-difflin">↑ back to top</a>)</div>diff --git a/blog/src/posts/command-center-guide.md b/blog/src/posts/command-center-guide.mdnew file mode 100644index 00000000..677489c2--- /dev/null+++ b/blog/src/posts/command-center-guide.md@@ -0,0 +1,91 @@+---+title: "The Command Center: Kanban, Fleet, and Budgets in One Place"+description: "A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Non-technical+primaryKeyword: "ai agent command center"+secondaryKeywords: ["agent task kanban", "monitor ai agent fleet", "per-agent token budgets", "ai agent cost tracking", "multi-agent dashboard"]+tags: ["Guides", "Command Center", "Kanban", "Cost", "Observability"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is the Command Center in Munder Difflin?"+ a: "It's Michael's control surface — the management view of the whole hive. It has tabs for the orchestrator Terminal, the Floor (roster, dispatch, per-agent model selector, live fleet monitoring), Memory (semantic search plus a memory graph), Activity (event log, board, real token telemetry, observability, and a CI watcher), Tasks (a dependency-aware kanban board), and Schedules (recurring missions with last/next-fired times)."+ - q: "How does the task kanban work?"+ a: "The Tasks tab is a dependency-aware kanban board. You assign tasks to agents and track them across todo, doing, blocked, and done. Because tasks can declare dependencies, downstream work waits until its prerequisites finish, so a chain of related tasks starts in the right order without you babysitting the handoffs."+ - q: "How do per-agent budgets and cost tracking work?"+ a: "You set a token budget per agent, and live fleet monitoring tracks consumption across the roster. Cost numbers are real, not estimates from vibes: the Activity tab reads the JSONL transcripts Claude Code writes and surfaces actual token counts plus estimated USD cost per agent per session, backed by a durable cost ledger that survives restarts. The budget pairs with a circuit breaker that steers, then constrains, then stops an agent that loops or blows its cap."+ - q: "When should I watch the office floor versus the Command Center?"+ a: "The floor is for ambient awareness and single-agent moments — seeing who's working, watching envelopes fly, dropping into one terminal. The Command Center is for management questions: what's queued and blocked, what each agent has spent, whether CI is green, and what fires next on the schedule. Roughly: floor for one agent right now, board for the whole fleet over time."+ - q: "Does the Command Center include observability?"+ a: "Yes. The Activity tab includes a live OpenTelemetry collector with per-model cost attribution, a fleet grid, and a per-agent tool-span waterfall, so you can see exactly what every agent is doing and what it costs in real time. Each agent card also carries a context-window gauge showing how much of the model's context that agent has consumed."+ - q: "Can the Command Center pull in work from GitHub?"+ a: "Yes. You can ingest open issues from any registered repo via the gh CLI and assign them to agents with one click, and a CI status watcher shows live pass/fail/in-progress state for GitHub Actions runs in the Activity tab. Work flows in from GitHub, gets tracked on the kanban, and its CI result lands back in the same view."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>The office floor is fun to watch, but you don't manage a team by staring at desks. Munder Difflin's <strong>Command Center</strong> is the management view: a <strong>dependency-aware task kanban</strong>, <strong>live fleet monitoring with per-agent token budgets</strong>, <strong>real cost telemetry</strong> backed by a durable ledger, <strong>OpenTelemetry observability</strong> with a per-agent tool-span waterfall, plus GitHub issue ingestion, a CI watcher, and a Schedules tab. Rule of thumb: <strong>watch the floor for one agent right now, watch the board for the whole fleet over time</strong>.</p></div>++<video controls preload="none" playsinline poster="/media/demo/features-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/features.mp4" type="video/mp4" />+</video>++Munder Difflin has two ways of looking at the same hive. The **office floor** is the ambient view: avatars at desks, envelopes flying between them, speech bubbles when a tool fires. The **Command Center** is the management view — Michael's control surface, the place you go when the question stops being "what is Dwight doing?" and becomes "what is *everyone* doing, what has it cost, and what's next?"++This guide walks through what's in it and how the pieces fit together.++## What's in the Command Center++Six tabs, one control surface:++- **Terminal** — Michael's own terminal, the [GOD orchestrator](/blog/how-the-god-orchestrator-works/) you talk to directly.+- **Floor** — the roster and dispatch controls: hire, dispatch work, pick a model per agent, and watch live fleet monitoring across everyone at once.+- **Memory** — semantic search over the shared memory palace, plain text search, and a memory graph.+- **Activity** — the append-only event log, the blackboard, real token telemetry, the observability view, and a CI watcher.+- **Tasks** — the kanban board.+- **Schedules** — recurring missions and the adaptive heartbeat, with last/next-fired times.++You could run the hive from the floor alone. But once you have more than two or three agents, the Command Center is where the actual decisions happen.++## The task kanban: work as a board, not a chat log++The Tasks tab is a **dependency-aware kanban board**. Tasks move across four columns — todo, doing, blocked, done — and each task is assigned to a specific agent.++The load-bearing word is *dependency-aware*. Real work has ordering: the refactor has to land before the tests get updated; the schema migration comes before the endpoint. On the board you wire those dependencies explicitly, and downstream tasks wait until their prerequisites finish. You're not the sequencer anymore — the board is.++Work gets onto the board a few ways: you create tasks yourself, Michael creates and assigns them as he routes requests, and you can **pull open GitHub issues from any registered repo** (via the `gh` CLI) and assign them to agents with one click. Issue in, task tracked, agent dispatched — and when the work ships, the **CI status watcher** in the Activity tab shows live pass/fail/in-progress for the repo's GitHub Actions runs. The loop closes in the same window it opened in.++## Fleet status: the roster at a glance++The Floor tab is where the fleet stops being a set of individual terminals and becomes a roster. Each agent card shows what that agent is up to, and the card's progress bar doubles as a **context-window gauge** — a glanceable read on how much of the model's context each agent has burned. An agent near the top of its gauge is an agent about to compact or slow down; you can see it coming instead of discovering it.++Dispatch also lives here: pick an agent, pick a model (the **per-agent model selector** means your cheap-tier worker and your frontier-tier reviewer are one dropdown apart), and send work. Routine tasks go to the cheap tier; the frontier tier is reserved for the reasoning that needs it.++## Budgets and cost: real numbers, not vibes++This is the part that makes a 24/7 fleet safe to leave running.++**Per-agent token budgets.** You set a budget per agent, and live fleet monitoring tracks consumption across the whole roster against it. Budgets pair with the **circuit breaker**, which handles the runaway case on a ladder: *steer* (nudge the agent), then *constrain*, then *stop*. An agent that loops, storms errors, or blows through its cap gets caught by machinery, not by you noticing the bill.++**Real telemetry.** The Activity tab doesn't estimate from message counts — it reads the JSONL transcripts Claude Code writes to `~/.claude/projects/` and surfaces **actual token counts and estimated USD cost per agent, per session**, backed by a **durable cost ledger** that survives app restarts. Yesterday's spend is still there this morning, attributed to the agent that spent it.++**Observability.** Also in Activity: a live **OpenTelemetry collector** with per-model cost attribution, a fleet grid, and a **per-agent tool-span waterfall** — the "what exactly is this agent doing, step by step, and what does each step cost" view. It's the same discipline we covered in [observability for agent fleets](/blog/observability-for-agent-fleets/), built into the harness instead of bolted on.++## Schedules: the board's fourth dimension++The kanban answers "what's in flight." The **Schedules tab** answers "what happens next without me." Recurring missions carry a label, an interval, a target agent, and a body, and the tab shows last-fired and next-fired times, so drift is visible. A scheduler **heartbeat** re-engages the floor when it goes quiet. Together with the board, it turns the hive from something you drive into something you supervise — the full pattern is in [scheduling autonomous agent missions](/blog/scheduling-autonomous-agent-missions/).++## Floor or board? A simple rule++Both views are the same hive, so this is about attention, not data:++- **Watch the floor** when you care about *one agent right now* — you just dispatched something, you want to type into a session, or you want ambient awareness while doing other work. (Also: it's charming.)+- **Watch the board** when you care about *the fleet over time* — what's queued, what's blocked on what, who's near budget, whether CI is green, what fires tonight.++In practice: floor open while you work, Command Center when you check in. Morning check-in is the board — done column, spend per agent, blocked tasks, next scheduled missions. That's a two-minute read that would take twenty minutes of terminal-scrolling without it. And when something needs a human decision, escalations land in the [approvals queue](/blog/human-in-the-loop-approving-ai-agents/) rather than hiding in a scrollback buffer.++## Try it++The Command Center ships in the current release, free and open source. [Download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — and if the board earns its place in your morning routine, a [star on GitHub](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/blog/src/posts/crewai-autogen-vs-a-local-agent-harness.md b/blog/src/posts/crewai-autogen-vs-a-local-agent-harness.mdnew file mode 100644index 00000000..3724fb50--- /dev/null+++ b/blog/src/posts/crewai-autogen-vs-a-local-agent-harness.md@@ -0,0 +1,85 @@+---+title: "CrewAI and AutoGen vs a Local Agent Harness: Framework or App?"+description: "CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need."+date: 2026-07-03+category: comparisons+categoryLabel: Comparisons+type: Technical+primaryKeyword: "crewai vs autogen vs agent harness"+secondaryKeywords: ["multi-agent framework vs harness", "crewai alternative", "autogen alternative", "langgraph vs harness", "microsoft agent framework", "multi-agent orchestration app"]+tags: ["Comparisons", "Multi-Agent", "CrewAI", "AutoGen", "LangGraph"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What's the difference between a multi-agent framework and a multi-agent harness?"+ a: "A framework is a library — CrewAI, Microsoft Agent Framework, and LangGraph are Python (and .NET/JS) packages you import to build your own agent system, which means you also build the UI, guardrails, memory, and triggers around it. A harness is a finished application: you download it, point it at your repos, and a coordinated team of agents runs with orchestration, approvals, budgets, and memory already built in. Same underlying idea, opposite division of labor."+ - q: "Is CrewAI free and open source?"+ a: "Yes. The CrewAI Python framework is MIT-licensed and open source, with agents organized into Crews (autonomous role-based teams) and Flows (event-driven workflows with precise control). You bring an LLM API key — OpenAI by default, with local models via Ollama supported — and CrewAI also sells an enterprise platform (AMP) for managed deployment, observability, and governance."+ - q: "What happened to Microsoft AutoGen?"+ a: "Microsoft merged AutoGen with Semantic Kernel into the Microsoft Agent Framework, which reached its production-ready 1.0 release in April 2026 for Python and .NET. AutoGen and Semantic Kernel are now in maintenance mode — bug fixes and security patches, but new feature work happens in Agent Framework. It combines AutoGen's agent abstractions with Semantic Kernel's enterprise features plus graph-based workflows."+ - q: "Do frameworks like CrewAI or LangGraph require API keys?"+ a: "Generally yes — they call model provider APIs directly, so you supply keys (or point at a local model server). A harness like Munder Difflin instead drives the agent CLIs you already run — Claude Code, Codex, Copilot CLI and others — so it can ride the subscriptions you already pay for, with BYO keys and local LLMs as options rather than requirements."+ - q: "When should I pick a framework instead of a harness?"+ a: "Pick a framework when the agent system is a component of your product: a support pipeline inside your SaaS, a document-processing workflow, anything that needs custom logic, your own deployment, and tight integration with your stack. CrewAI, Agent Framework, and LangGraph are excellent at exactly that. Pick a harness when the goal is a team of coding agents working your repos today, with no code to write."+ - q: "Is Munder Difflin a framework I can import into my own app?"+ a: "No. It's a local-first, MIT-licensed Electron desktop app for macOS, Windows, and Linux — the harness itself is the product. You download it, spawn agents that run as real CLI processes in isolated git worktrees, and a GOD orchestrator routes work between them while you watch, with approvals, budgets, a circuit breaker, and shared memory already wired in."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks</strong> — Python you import to <em>build</em> a multi-agent system, which means you also build the UI, guardrails, memory, and triggers yourself. <strong>A multi-agent harness is the finished app</strong>: Munder Difflin is a free, local-first desktop app that drives the agent CLIs you already have — Claude Code, Codex, Copilot CLI — as a coordinated team, with an orchestrator, approval gates, budgets, and shared memory built in. <strong>Frameworks win when agents are a component of your product. A harness wins when you want a team working your repos today, with no code.</strong></p></div>++"Which multi-agent framework should I use?" is usually the wrong first question. The right first question is: **are you building an agent system, or do you want to use one?**++Those are different jobs, and the tools for them belong to different categories. CrewAI, Microsoft's Agent Framework, and LangGraph sit in one; a multi-agent harness like Munder Difflin sits in the other. This post draws the line honestly, because both sides of it are good at what they're for.++## What the frameworks actually are++**CrewAI** is an MIT-licensed Python framework for orchestrating role-based agents. You define agents, tasks, and workflows in code: *Crews* for autonomous collaborative teams, *Flows* for event-driven workflows with conditional branching and state management. You bring an LLM API key (OpenAI by default; local models via Ollama work too), and there's a commercial platform (AMP) layered on top for managed deployment, observability, and governance. It's a genuinely well-designed library with serious enterprise adoption.++**AutoGen** — the Microsoft research project that popularized conversational multi-agent patterns — has been merged with Semantic Kernel into the **Microsoft Agent Framework**, which shipped its production-ready 1.0 in April 2026 for Python and .NET. AutoGen and Semantic Kernel themselves are in maintenance mode; Agent Framework carries the torch, combining AutoGen's agent abstractions with Semantic Kernel's enterprise plumbing (state management, middleware, telemetry) plus graph-based workflows. If you're on Azure and building agents into a product, it's the obvious pick.++**LangGraph** hit a stable 1.0 in late 2025 and is used in production at companies like Klarna, LinkedIn, Uber, and Replit. It models agent workflows as graphs with cycles — loop, retry, reflect — with checkpointing and a first-class `interrupt()` primitive for human-in-the-loop. For complex stateful pipelines where you want explicit control over every branch, it's the default answer.++Notice what all three have in common. They're **libraries**. `pip install`, import, write Python. That's not a criticism — it's the point. A framework's job is to give a developer building blocks.++## What a framework doesn't give you++Here's the part the comparison charts skip: when you pick a framework, **you've signed up to build the harness yourself.** The agent loop is maybe a fifth of a working multi-agent system. Around it you still need:++- **A UI** — some way to see what N agents are doing right now, not just logs.+- **Guardrails** — approval gates for spend and destructive operations, budgets, something that stops a looping agent before it burns $200.+- **Memory** — persistence across sessions, so Tuesday's agent knows what Monday's learned.+- **Triggers** — Slack, webhooks, schedules, so work arrives without you typing it.+- **Isolation** — so two agents editing the same repo don't destroy each other's work.++Frameworks are adding pieces of this (LangGraph's interrupts, CrewAI's memory and tracing, Agent Framework's telemetry), and their commercial platforms sell more of it. But the assembled, running system is still your project. That's a great deal if the agent system *is* your product. It's a terrible deal if what you wanted was help with your repos this afternoon.++## What a harness is instead++A [multi-agent harness](/blog/what-is-a-multi-agent-harness/) is the other answer: the system, already assembled, as an app. Munder Difflin is a free, MIT-licensed, local-first desktop app (macOS/Windows/Linux) where every agent is a **real CLI process** — Claude Code, OpenAI Codex, Antigravity, OpenCode, Crush, pi.dev, GitHub Copilot CLI — running in its own pseudo-terminal and its own isolated git worktree. A [GOD orchestrator](/blog/how-the-god-orchestrator-works/) routes work between them; agents share long-term memory; triggers include typing, Slack, webhooks, schedules, and voice.++The pieces you'd have built around a framework are already there: [human approval gates](/blog/human-in-the-loop-approving-ai-agents/) on spend, scope, and destructive ops; a circuit breaker with a steer → constrain → stop ladder; per-agent token budgets; OpenTelemetry observability; a Command Center with a kanban board and live fleet monitoring. And because it drives CLIs rather than calling model APIs, it rides the **subscriptions you already pay for** — no mandatory API key, with BYO keys and local LLMs as options.++The honest flip side: you can't `import` Munder Difflin into your SaaS. It won't run your custom document pipeline inside your product. It's an app for a specific job — a team of agents working your repositories, visible on one screen — not a toolkit for arbitrary agent systems.++## The honest decision rule++**Choose a framework (CrewAI, Agent Framework, LangGraph) when:**++- Agents are a *component of something you're shipping* — embedded in your product, your pipeline, your infrastructure.+- You need custom orchestration logic, your own deployment story, or deep integration with your stack (Azure, LangSmith, your data layer).+- You have engineering time to build and maintain the surrounding harness, and that investment pays off because the system is core to your business.++**Choose a harness (Munder Difflin) when:**++- The goal is "a team working my repos today" — coding, reviewing, fixing issues — with zero glue code.+- You want guardrails, memory, isolation, and a UI on day one, not as a Q3 project.+- You want it local and driving the CLI subscriptions you already have, rather than metering API calls through code you wrote.++There's no loser here. It's the same distinction as Rails vs. a deployed app: nobody asks which is "better," because one is for builders of systems and the other is a system. If you're still weighing categories, [how to choose a multi-agent tool](/blog/how-to-choose-a-multi-agent-tool/) walks the wider field, and [local-first vs cloud agent SDKs](/blog/local-first-vs-cloud-agent-sdks/) covers the deployment axis.++## Try the harness side in five minutes++If your answer was "I just want the team," that's the job Munder Difflin exists for. [Download the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — free, open source, local-first — and if it earns it, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.++Sources: [CrewAI on GitHub](https://github.com/crewAIInc/crewAI); [Microsoft Agent Framework overview](https://learn.microsoft.com/en-us/agent-framework/overview/); [Migrating Semantic Kernel and AutoGen to Agent Framework](https://devblogs.microsoft.com/agent-framework/migrate-your-semantic-kernel-and-autogen-projects-to-microsoft-agent-framework-release-candidate/); [LangGraph](https://www.langchain.com/langgraph).diff --git a/blog/src/posts/github-copilot-cli-vs-claude-code-for-hive-work.md b/blog/src/posts/github-copilot-cli-vs-claude-code-for-hive-work.mdnew file mode 100644index 00000000..f687d807--- /dev/null+++ b/blog/src/posts/github-copilot-cli-vs-claude-code-for-hive-work.md@@ -0,0 +1,99 @@+---+title: "GitHub Copilot CLI vs Claude Code as Hive Workers"+description: "How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both."+date: 2026-07-03+category: comparisons+categoryLabel: Comparisons+type: Technical+primaryKeyword: "github copilot cli vs claude code"+secondaryKeywords: ["copilot cli multi-agent", "claude code multi-agent harness", "copilot cli print mode", "agent engine comparison", "copilot cli automation", "claude code hooks"]+tags: ["Comparisons", "Claude Code", "Copilot CLI", "Multi-Agent", "Engines"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Can GitHub Copilot CLI work as an agent in a multi-agent system?"+ a: "Yes, with a specific shape. Copilot CLI's documented programmatic mode (copilot -p) executes one prompt and exits after completion, which makes it excellent for dispatched, self-contained tasks: hand it a scoped job, it runs autonomously with --allow-all-tools and --no-ask-user, returns a result, and terminates. What it can't do in that mode is stay resident and react to incoming messages, because there is no long-lived process to deliver them to."+ - q: "Why is Claude Code better suited to long-lived hive work?"+ a: "Claude Code exposes lifecycle hooks that an external harness can attach to. In Munder Difflin, those hooks let the harness see every turn, gate actions for human approval, steer mid-run, and — critically — drain the agent's inbox at the end of each turn via the Stop hook, so a Claude worker picks up new mail without being respawned. That persistent, observable lifecycle is what makes it eligible to be a worker that converses, or the GOD orchestrator itself."+ - q: "What happens when you send a message to a Copilot CLI worker in Munder Difflin?"+ a: "It doesn't silently disappear — it bounces to the GOD orchestrator. Because Copilot's print mode exits per turn, there's no resident process with a hook bridge to drain an inbox, so the provider is registered with canReceiveInbox set to false and routed mail is redirected to the orchestrator, which can re-dispatch the work as a fresh Copilot task or hand it to a hive-aware worker."+ - q: "Does GitHub Copilot CLI have hooks of its own?"+ a: "Yes. Copilot CLI supports hooks defined in JSON files (in .github/hooks/ per repo or ~/.copilot/hooks/ personally), including sessionStart and sessionEnd events, plus MCP servers and custom instructions. Munder Difflin's v0.3.3 integration doesn't bridge those into the hive yet — it drives the documented print mode, where the process exits after each prompt — so within the harness a Copilot worker is non-hive-aware by design."+ - q: "How is Copilot CLI billed compared to Claude Code?"+ a: "Copilot CLI authenticates with your existing GitHub Copilot login and consumes premium requests from your Copilot plan — GitHub documents one premium request per prompt on the default model, multiplied by the model's rate for others. Claude Code runs on your Anthropic plan or API key. Practically, that means a mixed hive spreads work across two subscriptions you may already be paying for."+ - q: "Should I pick one engine or mix them?"+ a: "Mix them. Use Claude Code for the orchestrator and long-lived workers that need to receive mail, converse across turns, and run under hook-driven guardrails. Use Copilot CLI workers for burst work: scoped, self-contained tasks dispatched by the orchestrator that finish in one shot. Munder Difflin lets you choose the engine per hire, so this is a per-agent decision, not a platform decision."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Inside a multi-agent harness, the engine question isn't "which CLI writes better code" — it's <strong>what lifecycle the process exposes</strong>. <strong>Claude Code</strong> runs as a long-lived session with native hooks, so Munder Difflin can gate it, steer it, <strong>drain its inbox on the Stop hook</strong>, and even make it the GOD orchestrator. <strong>GitHub Copilot CLI</strong> (new in v0.3.3) runs in its documented print mode — <code>copilot -p</code> — which <strong>exits after every prompt</strong>: brilliant for dispatched, self-contained tasks on your existing Copilot subscription, but with no resident process to receive mail, routed messages <strong>bounce to the orchestrator</strong> instead. Verdict: <strong>mix them</strong> — Claude as orchestrator and long-lived workers, Copilot for burst tasks.</p></div>++Munder Difflin v0.3.3 added GitHub Copilot CLI as its seventh agent engine — the project's first community-contributed provider ([PR #101](https://github.com/chaitanyagiri/munder-difflin/pull/101) by @anxkhn). That makes a comparison suddenly practical rather than theoretical: you can hire a Claude Code worker and a Copilot worker onto the same floor and watch them behave differently. This post is about *that* difference — not "which model is smarter," but how each CLI behaves as a **worker inside a hive**.++Both are genuinely good tools. The differences below are lifecycle differences, and lifecycle is what a harness cares about.++## The thing a harness actually needs from an engine++A [multi-agent harness](/blog/what-is-a-multi-agent-harness/) wraps real CLI processes and coordinates them: routing messages between inboxes, gating destructive actions, tracking turns, waking idle agents when mail arrives. To do all that, it needs answers from the engine to three questions:++1. **Does the process stay alive between turns?** (Can it hold a conversation, or is every invocation a fresh start?)+2. **Does it emit lifecycle signals a harness can attach to?** (Turn ended, tool about to run, session stopped?)+3. **Can it be interrupted, steered, and fed new input mid-stream?**++Claude Code and Copilot CLI give very different answers — and neither answer is wrong. They're different shapes for different jobs.++## Claude Code: the hive-aware resident++Claude Code runs as a persistent interactive session in its pseudo-terminal, and it exposes native hooks — external commands fired at lifecycle points. Munder Difflin leans on those hard:++- **Turn-end inbox drain.** When a Claude worker finishes a turn, the Stop hook fires and the harness checks the agent's mailbox. If mail is waiting, the agent drains it *in the same session* — no respawn, no lost context. This is what makes a worker conversational: other agents can message it and it will actually respond.+- **Hook-driven guardrails.** The human-in-the-loop gate, mid-run steering, and graceful stop are all driven through Claude Code hook returns — you can intervene without killing the session.+- **Orchestrator eligibility.** Because the process is long-lived and observable, Claude Code can be the [GOD orchestrator](/blog/how-the-god-orchestrator-works/) itself — the always-on supervisor that adjudicates traffic and routes tasks.++If you want the deeper treatment of driving Claude Code as a coordinated fleet, see the [Claude Code orchestration guide](/blog/claude-code-orchestration-guide/).++## GitHub Copilot CLI: the burst specialist++GitHub Copilot CLI is GitHub's terminal agent, and its docs describe two modes: an interactive session, and a **programmatic mode** built for scripting — per GitHub's own reference, `-p` will "execute a prompt programmatically (exits after completion)." That exit-per-turn behavior is the documented design, and Munder Difflin drives it exactly as documented. The spawn shape from the v0.3.3 changelog:++```+copilot -p "<prompt>" -s --allow-all-tools --no-ask-user [--model <id>]+```++Piece by piece: `-p` passes the task, `-s` (silent) outputs only the agent response, `--allow-all-tools` auto-approves tool use (GitHub notes it's required for programmatic runs — and in Munder Difflin these auto-approval flags are gated by the floor's auto-mode toggle, like every other engine), and `--no-ask-user` disables clarifying questions so the run is fully autonomous. There's a model picker (Claude Sonnet 4.5 by default, GPT-5.4, or `auto`) and best-effort `--resume` session continuity.++Two things make Copilot workers genuinely attractive:++- **It's on your existing subscription.** Copilot CLI authenticates with your GitHub Copilot login — no new API key. GitHub bills it in premium requests (one per prompt on the default model, times the model's multiplier), drawing from the allowance you may already have.+- **Exit-per-turn is a feature for dispatched work.** A scoped task arrives, the process runs it to completion with no residual state, and terminates cleanly. For burst tasks, that's exactly what you want.++The honest limitation: with no resident process between turns, there's nothing to deliver inbox mail *to*. So in Munder Difflin, Copilot's provider is registered non-hive-aware (`canReceiveInbox: false`), and routed mail **bounces to the GOD orchestrator** instead of silently dropping. The orchestrator can then re-dispatch it as a fresh Copilot task or hand it to a hive-aware worker.++To be fair to Copilot CLI: the tool itself is more extensible than the print-mode integration uses. GitHub ships its own hooks system (JSON files in `.github/hooks/` or `~/.copilot/hooks/`, with `sessionStart`/`sessionEnd` events), MCP server support, and custom instructions. A deeper bridge is conceivable; v0.3.3 ships the documented, honest version.++## Verdict: don't pick — mix++The comparison table writes itself once you frame it as lifecycle:++| | Claude Code | GitHub Copilot CLI |+|---|---|---|+| Process lifetime | Long-lived session | Exits after each prompt (`-p`) |+| Harness hook bridge | Native hooks (incl. Stop-hook inbox drain) | None in print mode |+| Receives hive mail | Yes, drains inbox in-session | No — bounces to orchestrator |+| Orchestrator-eligible | Yes | No |+| Auth | Anthropic plan / API key | Existing GitHub Copilot login |+| Sweet spot | Orchestrator, conversational workers | Dispatched, self-contained burst tasks |++Because Munder Difflin makes the engine a per-hire choice, this isn't an either/or. The pattern that works: **Claude Code as the orchestrator and your long-lived workers** — the agents that need to receive messages, hold context across turns, and run under hook-driven approval gates — and **Copilot CLI workers for burst tasks** the orchestrator dispatches: a scoped refactor, a test-writing pass, a one-shot investigation. Different engines for different roles is the general lesson of mixed fleets, and it also spreads cost across two subscriptions you likely already pay for.++For everything else in the release — including the built-in Monaco IDE — see the [v0.3.3 launch post](/blog/launching-munder-difflin-v0-3-3/).++## Try both on one floor++Hire a Claude worker and a Copilot worker side by side and watch the difference yourself — [download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) (free, MIT, local-first), and if it's useful, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.++Sources: [GitHub Docs — Copilot CLI command reference](https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference);+[GitHub Docs — Running Copilot CLI programmatically](https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/run-cli-programmatically);+[GitHub Docs — About Copilot CLI](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli);+[GitHub Docs — Hooks for Copilot](https://docs.github.com/en/copilot/concepts/agents/hooks);+[GitHub Docs — Copilot premium requests](https://docs.github.com/en/copilot/concepts/billing/copilot-requests).diff --git a/blog/src/posts/how-to-add-a-github-copilot-cli-agent.md b/blog/src/posts/how-to-add-a-github-copilot-cli-agent.mdnew file mode 100644index 00000000..03f736ea--- /dev/null+++ b/blog/src/posts/how-to-add-a-github-copilot-cli-agent.md@@ -0,0 +1,105 @@+---+title: "How to Add a GitHub Copilot CLI Agent to Your Floor"+description: "A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "github copilot cli agent"+secondaryKeywords: ["add github copilot cli agent", "copilot cli multi-agent", "copilot -p print mode", "github copilot cli munder difflin", "copilot cli model picker"]+tags: ["Guides", "GitHub Copilot", "CLI Agents", "Multi-Agent", "Engines"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Do I need a new API key to run a GitHub Copilot CLI agent in Munder Difflin?"+ a: "No. The Copilot engine authenticates through your existing GitHub Copilot login — the same auth the copilot CLI uses in a plain terminal. There is no BYOK key to paste into Settings for this engine; if you can run copilot in your shell, you can hire it on the floor."+ - q: "What models can a Copilot CLI agent use?"+ a: "The Add Agent flow includes a model picker for the Copilot engine with three options: Claude Sonnet 4.5 (the default), GPT-5.4, and auto, which lets Copilot choose. Your selection is passed to the CLI via the --model flag on every turn."+ - q: "Why does my Copilot agent's inbox mail go to the orchestrator instead?"+ a: "By design. Copilot CLI runs in non-interactive print mode, which exits after each turn and exposes no hook bridge, so a Copilot worker cannot sit idle and drain a mailbox. Rather than letting routed mail silently drop, the harness bounces it to the GOD orchestrator, which handles or re-routes it. Use Copilot workers for dispatched, self-contained tasks and they work great."+ - q: "What does the auto-mode toggle change for Copilot agents?"+ a: "In auto mode the harness adds Copilot's auto-approval flags (-s --allow-all-tools --no-ask-user) so the agent can use tools without stopping to ask. With auto mode off, those flags are omitted and Copilot runs more conservatively — the same gating every other engine on the floor gets."+ - q: "Does a Copilot agent keep context between turns if print mode exits every time?"+ a: "Yes, best-effort. The engine uses Copilot CLI's --resume flag to reattach the previous session on the next turn, so follow-up prompts land in the same conversation rather than starting cold. It is session continuity, not a persistent process."+ - q: "Who built the Copilot engine?"+ a: "It's the first community-contributed provider in Munder Difflin — PR #101 by @anxkhn, shipped in v0.3.3. The engine registers Copilot as a provider preset alongside Claude Code, Codex, Antigravity, OpenCode, Crush, and pi.dev, and comes with a self-contained registry test asserting the command shape."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>As of <strong>v0.3.3</strong>, GitHub Copilot CLI is a first-class agent engine in Munder Difflin — the project's <strong>first community-contributed provider</strong> (PR #101 by @anxkhn). Install <code>@github/copilot</code> (or let the harness's missing-CLI installer do it), hit <strong>Add Agent</strong>, pick the Copilot engine, choose a model (<strong>Claude Sonnet 4.5 default, GPT-5.4, or auto</strong>), and it authenticates with your <strong>existing Copilot login — no new keys</strong>. One honest caveat: Copilot runs in <strong>print mode</strong> (<code>copilot -p</code>), which exits per turn, so its workers can't drain inbox mail — routed mail <strong>bounces to the orchestrator</strong> instead of dropping. Use Copilot workers for <strong>dispatched, self-contained tasks</strong>.</p></div>++If you already pay for GitHub Copilot, you have an agent engine sitting in your subscription that most people only ever use as autocomplete. Copilot CLI is the terminal version — a real coding agent you run with `copilot` — and since [v0.3.3](/blog/launching-munder-difflin-v0-3-3/), Munder Difflin can hire it onto the floor next to your Claude Code, Codex, and OpenCode workers.++This guide walks the whole path: install, hire, model choice, what auto-mode changes, and the one behavioral caveat you should understand before you assign work.++## Step 0: have the floor running++You need Munder Difflin itself first — if you don't, [the install guide](/blog/how-to-install-and-use-munder-difflin/) covers it in a few minutes. Everything below assumes you're looking at the office floor with Michael seated in his office.++## Step 1: install Copilot CLI (or don't — the harness will offer)++The engine drives the official npm package:++```bash+npm install -g @github/copilot+```++Then log in once with your GitHub account if you haven't (`copilot` walks you through it on first run). That's the entire auth story: **the engine uses your existing GitHub Copilot login, no new keys**, nothing to paste into Settings → AI Engines.++You can also skip this step entirely. Munder Difflin has a self-healing installer for missing engine CLIs: if you pick Copilot in Add Agent and the `copilot` binary isn't on your `PATH`, the harness offers the official `npm install -g @github/copilot`, runs it in the terminal, then auto restarts-and-continues into the freshly installed binary. No dead end, no manual retry.++## Step 2: Add Agent, pick Copilot++Click **Add Agent** on the floor. The visual provider picker now lists GitHub Copilot CLI alongside the other six engines. Pick it, name your hire, choose a working directory — and if you flip the git-isolation toggle, the agent gets its own dedicated worktree so it never collides with other agents on branches (more on why that matters in [worktrees vs the hive](/blog/claude-code-git-worktrees-vs-hive/)).++Here's the whole hire flow in nineteen seconds:++<video controls preload="none" playsinline poster="/media/demo/agents-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/agents.mp4" type="video/mp4" />+</video>++Copilot hires also work through voice — Realtime Michael's `spawn` action can hire one — and if you paste a raw `copilot ...` command into the custom-command field, the harness infers the binary and treats it as a Copilot engine.++## Step 3: choose a model++The Copilot engine ships with a model picker, `COPILOT_MODELS`, with three options:++- **Claude Sonnet 4.5** — the default.+- **GPT-5.4** — if you'd rather run OpenAI's model.+- **auto** — let Copilot pick per request.++Whatever you choose is passed through as `--model <id>` on each turn. This is a per-hire choice, so you can run one Copilot worker on Sonnet and another on GPT-5.4 and compare them on the same board.++## What auto-mode gates++Under the hood, every turn a Copilot agent takes is Copilot CLI's documented non-interactive **print mode**:++```bash+copilot -p "<prompt>" -s --allow-all-tools --no-ask-user [--model <id>]+```++The auto-approval flags — `-s --allow-all-tools --no-ask-user` — are **gated by the floor's auto-mode toggle**, exactly like every other engine. Auto-mode on: Copilot gets its documented allow-all flags and works without stopping to ask permission per tool call. Auto-mode off: the flags are omitted and the agent runs conservatively. The floor-level guardrails — [the approvals queue](/blog/human-in-the-loop-approving-ai-agents/), budgets, the circuit breaker — sit above all of that regardless of engine.++Session continuity is handled with `--resume` (best-effort): print mode exits after every turn, but the next turn reattaches the prior session, so follow-ups don't start cold.++## The honest inbox caveat++This is the part worth reading twice. Print mode **exits per turn and exposes no hook bridge**, which means a Copilot worker can't do the thing hive-aware engines do: sit idle, notice mail in its inbox, and drain it. The engine is registered as non-hive-aware (`canReceiveInbox: false`) on purpose.++So what happens when another agent routes a message to your Copilot worker? It **bounces to the GOD orchestrator** instead of silently dropping. Michael sees the bounced mail and handles or re-routes it — the message survives, it just doesn't land in a mailbox nobody is checking. (If you're new to how Michael adjudicates traffic, [the GOD orchestrator post](/blog/how-the-god-orchestrator-works/) explains the routing model.)++The practical rule: **use Copilot workers for dispatched, self-contained tasks.** "Take this issue, fix it, report back" is their sweet spot. Long-running conversational back-and-forth between agents is not — hand that to a hive-aware engine. Shipping the limitation honestly, with a bounce path instead of a black hole, was a deliberate design call in PR #101, and it's the right one.++## Recap++1. `npm install -g @github/copilot` — or let the missing-CLI installer offer it.+2. **Add Agent** → pick the Copilot engine → optionally flip git isolation.+3. Pick a model: Claude Sonnet 4.5 (default), GPT-5.4, or auto.+4. Know the shape: print mode per turn, `--resume` continuity, auto-mode gates the approval flags.+5. Assign dispatched, self-contained tasks; let mail-heavy coordination live on hive-aware engines.++That's a seventh engine on your floor, powered by a subscription you already have.++## Try it++Grab the latest build from [the releases page](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — and if the Copilot engine saves you a hire, a [star on GitHub](https://github.com/chaitanyagiri/munder-difflin) is how community contributions like PR #101 keep coming.diff --git a/blog/src/posts/how-to-hire-from-the-agent-gallery.md b/blog/src/posts/how-to-hire-from-the-agent-gallery.mdnew file mode 100644index 00000000..cd98b198--- /dev/null+++ b/blog/src/posts/how-to-hire-from-the-agent-gallery.md@@ -0,0 +1,80 @@+---+title: "How to Hire From the Agent Gallery"+description: "A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Non-technical+primaryKeyword: "agent gallery"+secondaryKeywords: ["hire an ai agent", "off-the-shelf agent roles", "import agent manifest", "munder difflin hires", "ready-made ai coworkers"]+tags: ["Guides", "Multi-Agent", "Agent Design", "Getting Started", "Security"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is the Agent Gallery?"+ a: "It's a free gallery of ready-made agent roles for Munder Difflin at munderdiffl.in/hires — no login, no trackers. Each role, called a hire, is a small JSON manifest that packages a configured agent: name, avatar, provider, model, flags, a goal, capability tags, and a token budget. It ships with six off-the-shelf hires you can import in one click and adapt to your project."+ - q: "Does importing a hire from the gallery start an agent automatically?"+ a: "No. Import only pre-fills the Add-Agent modal behind an explicit imported banner. You review every field, change anything you like, and the agent spawns only when you click spawn. There is no code path that runs an agent on import — the human is always the spawn gate."+ - q: "Is it safe to import a hire manifest someone sent me?"+ a: "The import pipeline is built on the assumption that it isn't — every manifest is validated as untrusted input. There is no executable field, so a manifest can never name a program to run; command flags pass a default-deny allowlist; and deep-link fetches are https-only and bounded. Even after all that, you still review the pre-filled form before anything spawns. Treat the goal text with the same skepticism you'd give any file from the internet."+ - q: "Can I change the engine or model a gallery hire uses?"+ a: "Yes. The manifest is a starting point, not a lock. In the Add-Agent modal you can switch the hire onto any engine you have — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI — pick a different model, and on local-capable engines use the OSS-model quick-picks to run it on open models via Ollama or a BYOK provider."+ - q: "What should I customize before spawning a hire?"+ a: "Four things. Identity: the name and avatar you'll recognize on the floor. Workspace: the working directory it operates in, ideally with the git-isolation toggle on so it gets its own worktree. Engine: the CLI and model that match the job's difficulty and your budget. Briefing: rewrite the goal so it names your repo, your conventions, and what done means — a generic goal produces generic work."+ - q: "How much does hiring from the gallery cost?"+ a: "The gallery and the app are free and open source (MIT-licensed code). You pay only for the model usage of whatever CLI or key the agent runs on. Every hire carries a token budget field, and the harness pairs per-agent budgets with live fleet monitoring and a circuit breaker, so an imported role can't quietly outspend the ceiling you gave it."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>The <strong>Agent Gallery</strong> (<a href="https://munderdiffl.in/hires/">munderdiffl.in/hires</a>) is where you hire ready-made AI coworkers for Munder Difflin — it ships with <strong>six off-the-shelf hires</strong>. A hire is a small JSON manifest: provider, model, flags, goal, capabilities, token budget. Importing one — by <code>munderdifflin://hire</code> link or a local file — <strong>never runs anything</strong>: it only pre-fills the Add-Agent modal behind an "imported" banner, and the manifest is <strong>validated as untrusted input</strong> along the way. You review, customize the <strong>identity, workspace, engine, and briefing</strong>, and <em>you</em> click spawn. Five minutes from browsing to a working agent on your floor.</p></div>++The slowest part of running a multi-agent office isn't running the agents. It's the blank Add-Agent form: which engine, which model, which flags, and — the one that actually stalls people — what is this thing's *job*? The Agent Gallery exists so you never start from that blank box. You start from a role somebody already got right, and you edit.++This is the practical walkthrough: browse, import, review, customize, spawn. (If you haven't installed the app yet, do [that first](/blog/how-to-install-and-use-munder-difflin/) — the gallery assumes you have a floor to hire onto.)++## Step 1: Browse the gallery++The gallery lives at [munderdiffl.in/hires](https://munderdiffl.in/hires/) — a static page, no login, no trackers. It's stocked with **six off-the-shelf hires**, each a complete role: a PR reviewer, a docs writer, a QA enforcer, a security auditor, a token-spend auditor, and a migrations grinder, each fronted by a pixel avatar from the app's affectionate Office parody cast.++Every card tells you what you're getting before you click anything: the role's goal, its capability tags, and which provider it's written for. Don't overthink the choice — you're picking a starting point, not signing a contract. Everything on the card is editable after import.++## Step 2: Import the hire++Two ways in, both landing in the same place:++- **Deep link.** Click the hire button on a card and the `munderdifflin://hire` link opens the app directly.+- **Local file.** Save the manifest JSON (or receive one from a teammate) and import it from disk.++Either way, one thing is worth being precise about: **import never spawns anything.** What opens is the app's ordinary Add-Agent modal, pre-filled with the manifest's values and marked with an explicit **"imported" banner** so you know these fields came from outside. The agent starts only when you click spawn. A hire you got from the internet is inert data until a human acts on it.++That's not an accident of UI — it's a security posture. A manifest arrives by clicked link or downloaded file, which makes it attacker-controlled bytes, and the import pipeline treats it that way: there's **no executable field** (the binary always comes from your own locally configured provider presets), command flags pass a **default-deny allowlist**, and the deep-link fetch is **https-only and bounded**. The full threat model is its own post: [treating a hire manifest as untrusted input](/blog/hire-manifest-untrusted-input/).++## Step 3: Actually read the manifest++The imported banner is your cue to slow down for thirty seconds. A hire manifest encodes the whole role — name, avatar, provider, model, command flags, goal, capability tags, and a token budget — and every one of those is now sitting in front of you as a form field. Read them like you'd read a job description before forwarding it to HR:++- **Goal text** is the prompt this agent will work from. It's free text from someone else, which makes it the one field validation can't vouch for. If anything in it looks off, rewrite it.+- **Model and flags** tell you what it costs to run and how it behaves. The allowlist keeps flags safe; it doesn't make them right for you.+- **Token budget** is the spend ceiling the author suggested. Set it to what *you* are comfortable with — the harness enforces per-agent budgets with live fleet monitoring and a circuit breaker behind it.++## Step 4: Customize the four things that matter++A gallery hire is deliberately generic. Four edits turn it into *your* hire:++**Identity.** Rename it and pick the avatar you want to see walking the floor. This sounds cosmetic; it isn't. When six agents are working at once, you triage by face and name.++**Workspace.** Point the hire at the repo it should work in, and flip on the **git isolation** toggle so it auto-provisions its own worktree on spawn — agents that share a checkout collide on branches; agents with worktrees don't ([why worktrees, in depth](/blog/claude-code-git-worktrees-vs-hive/)).++**Engine.** The manifest names a provider, but the modal's picker is yours: run the role on Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. Match the engine to the job — and if the role is routine enough, the local-capable engines surface **OSS-model quick-picks** so it can run on open models for pennies.++**Briefing.** Rewrite the goal until it names your project, your conventions, and what "done" looks like. This is the highest-leverage sixty seconds of the whole flow: a hire that arrives with "review pull requests" leaves with "review PRs on repo X, enforce the lint config, never approve without a green typecheck."++One more gate you'll meet after spawning: hires carry a manifest of allowed **skills and MCP servers**, default-deny over a shared catalog. Anything the hire wants to use surfaces in a consent UI for you to grant — imported input is reviewed, never auto-granted.++## Step 5: Spawn, and put it to work++Click spawn. The agent appears at a desk, joins the hive with its own mailbox and long-term memory, and is immediately routable: assign it kanban tasks, or just tell the GOD orchestrator what you need and let [Michael route the work](/blog/how-the-god-orchestrator-works/).++From browsing a card to a working coworker is genuinely a five-minute path — and every minute of it kept you in the loop: you read the manifest, you set the budget, you clicked spawn.++Grab the latest build from the [releases page](https://github.com/chaitanyagiri/munder-difflin/releases/latest), and if the gallery saves you a blank-form afternoon, a [GitHub star](https://github.com/chaitanyagiri/munder-difflin) is appreciated.diff --git a/blog/src/posts/how-to-install-and-use-munder-difflin.md b/blog/src/posts/how-to-install-and-use-munder-difflin.mdindex dcac1704..3f203789 100644--- a/blog/src/posts/how-to-install-and-use-munder-difflin.md+++ b/blog/src/posts/how-to-install-and-use-munder-difflin.md@@ -7,7 +7,7 @@ categoryLabel: Guidestype: TechnicalprimaryKeyword: "how to install munder difflin"secondaryKeywords: ["munder difflin download", "munder difflin app", "munder difflin tutorial"]-tags: ["Guides", "Getting Started", "Tutorial", "Claude Code", "Automation"]+tags: ["Guides", "Getting Started", "Tutorial", "Claude Code", "Automation", "Video"]author:name: Chaitanya Giriinitials: CG@@ -31,6 +31,9 @@ launch you'll pick a harness home, add your repos, and confirm auto mode. Then y<strong>Goal</strong>, and let the hive work <strong>ambitious, long-horizon tasks for hours ordays</strong> while you watch the floor.</p></div>+*Watch the 51-second setup walkthrough:*+<video controls preload="none" playsinline poster="/media/demo/setup-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;"><source src="/media/demo/setup.mp4" type="video/mp4" /></video>+Most tools help you run a Claude Code agent. Munder Difflin helps you run a *team* of them —unattended, coordinated, and aimed at the big jobs: a multi-day refactor, a migration, aninvestigation that needs to grind overnight. This is the start-to-finish guide: install it, meet thediff --git a/blog/src/posts/how-to-talk-to-your-orchestrator.md b/blog/src/posts/how-to-talk-to-your-orchestrator.mdnew file mode 100644index 00000000..07adf74d--- /dev/null+++ b/blog/src/posts/how-to-talk-to-your-orchestrator.md@@ -0,0 +1,95 @@+---+title: "How to Brief Your Orchestrator (So the Floor Actually Ships)"+description: "A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Non-technical+primaryKeyword: "how to brief an ai orchestrator"+secondaryKeywords: ["ai orchestrator prompts", "multi-agent task delegation", "god orchestrator briefing", "steering ai agents mid-run", "voice control ai agents", "ai agent approvals"]+tags: ["Guides", "Orchestration", "Multi-Agent", "Talk Mode", "Human-in-the-Loop"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What should a brief to an AI orchestrator contain?"+ a: "Four things: the goal (the outcome you want, not the steps), the constraints (what the agents must not touch, which repo, what conventions to follow), the budget (token caps and rough time expectations), and the deliverable (what artifact proves the work is done — a PR, a passing test suite, a document). Everything else — task breakdown, staffing, sequencing — is the orchestrator's job."+ - q: "Why shouldn't I tell the orchestrator the exact steps?"+ a: "Because step-by-step briefs turn a supervisor into a typist. Munder Difflin's GOD orchestrator exists to decompose work, assign it to the right agents, wire dependencies on the task board, and adjudicate results. If you pre-chew every step, you lose the parallelism and the routing — and you own every mistake in your own plan. State the goal and the definition of done; let it plan."+ - q: "How do I steer the orchestrator mid-run without killing agents?"+ a: "Munder Difflin has a mid-run steer and a graceful stop built on Claude Code hook returns, so you can redirect or halt an agent without killing its session. You can also type directly into any agent's terminal, message the orchestrator to re-plan, or use the circuit breaker's steer-constrain-stop ladder if something is looping or overspending."+ - q: "How do I ask the orchestrator for status?"+ a: "Ask it directly — 'what's the state of the floor?' — in its terminal or over Talk mode, where Michael reads the hive (tasks, board, memory, agents, activity) and answers out loud. Or read the surfaces yourself: the Command Center has a kanban Tasks tab, live fleet monitoring, token and cost telemetry, and an activity log."+ - q: "What is Talk mode in Munder Difflin?"+ a: "Talk mode (Realtime Michael, shipped in v0.3.2) is a low-latency voice channel to the GOD orchestrator over the OpenAI Realtime API. Press Talk and Michael listens, answers, and acts: he creates and assigns tasks, dispatches agents, spawns and kills workers, and speaks task completions the moment they land. Destructive verbs require a spoken echo-back confirmation, and the session runs under a live cost meter with a hard spend cap. It's bring-your-own OpenAI key."+ - q: "Does the orchestrator ask for my approval before risky actions?"+ a: "Yes. The GOD agent resolves routine requests itself and escalates only critical items — spend, destructive operations, scope changes — into a human-in-the-loop approvals queue you act on. In Talk mode, destructive actions additionally require a spoken echo-back confirmation with a distinct confirm token, never a bare yes."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Your orchestrator is a manager, not a macro. A good brief has four parts: <strong>the goal</strong> (outcome, not steps), <strong>the constraints</strong> (repo, boundaries, conventions), <strong>the budget</strong> (token caps, rough time), and <strong>the deliverable</strong> (the artifact that proves "done"). Then <strong>let Michael staff it</strong> — he decomposes, assigns, wires dependencies, and escalates only spend, destructive ops, and scope changes to your approvals queue. Steer mid-run without killing sessions, ask for status in plain language, and do all of it <strong>by voice with Talk mode</strong> if typing feels slow.</p></div>++<video controls preload="none" playsinline poster="/media/demo/orchestrator-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/orchestrator.mp4" type="video/mp4" />+</video>++Munder Difflin puts one agent between you and the floor: the GOD orchestrator — Michael — who reads every request, decomposes it, routes work to the right agents, and escalates only critical items back to you. (The full mechanics are in [how the GOD orchestrator works](/blog/how-the-god-orchestrator-works/).) That design has one implication people keep missing: **the quality of what the floor ships is mostly the quality of your brief.**++Here's how to brief well.++## Rule one: state the goal, not the steps++The most common failure mode is treating the orchestrator like a very slow keyboard: "open file X, change function Y, then run Z." That works, but you've just done the planning yourself and hired a manager to be your typist.++Michael's job is decomposition. He turns a goal into tasks on a dependency-aware kanban board, assigns them to agents (each in its own git worktree, so nobody collides), and adjudicates the results. When you pre-chew the steps, you get no parallelism, no routing, and full ownership of every mistake in your own plan.++State the outcome and the definition of done. Let the plan be his problem.++## The four parts of a good brief++**1. The goal.** One or two sentences describing the end state. "Users can reset their password over email" beats "add a route, then a token table, then a mailer."++**2. The constraints.** What must not change, where the work lives, what conventions apply. Which repo (the floor works over your registered repos), which directories are off-limits, "follow the existing design tokens," "don't touch the migration history." Constraints are cheap to write and expensive to omit — this is [context engineering](/blog/context-engineering-for-ai-agents/) at the human layer.++**3. The budget.** Munder Difflin supports per-agent token budgets with live fleet monitoring, backed by a circuit breaker that nudges, constrains, then stops runaways. Say what the work is worth: "keep this under N tokens total" or "this is an overnight job, not a sprint." A budget in the brief becomes a budget on the floor.++**4. The deliverable.** Name the artifact that proves completion: a PR against main, a green test suite, a markdown report, a rendered page. "Done" without an artifact is a vibe; agents ship vibes enthusiastically.++## Bad brief, good brief++**Bad:** "Fix the login bug."+No goal state, no repro, no deliverable. Michael will staff *something*, and you'll spend the review round discovering what he guessed.++**Good:** "Login fails with a 500 when the email has a `+` in it — repro is in issue #214. Goal: that case passes. Constraints: fix in the auth service only, don't touch the session store. Budget: one worker, small. Deliverable: a PR with a regression test."++**Bad:** "Refactor the settings page, and also while you're there improve performance and maybe update the docs."+Three goals in a trench coat. Split them — the task board handles dependencies; your sentence shouldn't have to.++**Good:** "Goal: the settings page uses the shared form components everywhere. Constraint: no visual changes — screenshots before/after should match. Deliverable: one PR. If you find perf problems, file them as tasks, don't fix them."++That last sentence is the pro move: telling the orchestrator what to do with *adjacent* discoveries, so scope stays fixed without discoveries getting lost.++## Let it staff++Don't specify which agent does what unless you have a real reason. Michael assigns work across the roster, and each hire can run a different engine — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, or GitHub Copilot CLI — so routing is part of the value. If you *do* care ("use the cheap local-model worker for the boilerplate"), say it as a constraint, not by micromanaging assignments.++## Mid-run: steering, status, approvals++A brief is not a launch-and-pray. Three controls matter while the floor runs:++**Steering.** Munder Difflin has a mid-run steer and a graceful stop driven through Claude Code hook returns — you redirect an agent without killing its session. You can also type into any agent's terminal directly, or message Michael to re-plan: "drop the docs task, the API changed."++**Status.** Ask Michael in plain language — "what's the state of the floor?" — or read it yourself: the Command Center's Tasks kanban, live fleet monitoring, real token and cost telemetry, and the activity log.++**Approvals.** Michael resolves routine requests himself and escalates only critical items — spend, destructive ops, scope changes — into an approvals queue you act on. Answer those promptly; a stalled approval is a stalled floor. More on this pattern in [approving AI agents](/blog/human-in-the-loop-approving-ai-agents/).++## Briefing by voice: Talk mode++Everything above works typed into Michael's terminal. Since v0.3.2 it also works spoken. Press **Talk** and Realtime Michael (OpenAI Realtime API over WebRTC, bring-your-own key) listens and *acts*: he reads the hive, creates and assigns tasks, dispatches agents, spawns and kills workers — with every destructive verb gated behind a spoken echo-back confirmation, never a bare "yes." He speaks task completions the moment they land, and the session runs under a live cost meter with a hard spend cap and idle auto-disconnect.++The same brief discipline applies out loud. "Michael, goal: the changelog is updated for the release. Constraint: docs only. Deliverable: a commit on the release branch" is a complete voice brief. (Full details in the [v0.3.2 launch post](/blog/launching-munder-difflin-v0-3-2/).)++## The habit++Goal, constraints, budget, deliverable. Say it once, let Michael staff it, steer when reality changes, and answer your approvals. That's the whole skill — and it's the difference between a floor that looks busy and a floor that ships.++[Download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) and brief your first floor — and if it ships something, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) is appreciated.diff --git a/blog/src/posts/how-to-use-the-built-in-monaco-ide.md b/blog/src/posts/how-to-use-the-built-in-monaco-ide.mdnew file mode 100644index 00000000..bde79524--- /dev/null+++ b/blog/src/posts/how-to-use-the-built-in-monaco-ide.md@@ -0,0 +1,81 @@+---+title: "How to Use the Built-in Monaco IDE"+description: "A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "built-in monaco ide"+secondaryKeywords: ["review ai agent code changes", "monaco editor electron app", "side-by-side git diff vs head", "munder difflin ide walkthrough", "human review workflow for ai agents"]+tags: ["Guides", "IDE", "Git", "Human-in-the-Loop", "Local-First"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "How do I open the built-in IDE in Munder Difflin?"+ a: "Click the IDE button in the title bar. It toggles a full-window Monaco editor overlay on top of the office floor — the floor, terminals, and voice UX keep running underneath, untouched. Click the button again to drop back to the floor. It shipped in v0.3.3."+ - q: "How do I see what an agent changed?"+ a: "Open the IDE and look at the git CHANGES rail on the left. It lists every file with uncommitted changes in the workspace; click a file and you get a read-only side-by-side diff against HEAD, so you see exactly what the agent wrote next to what was there before."+ - q: "Can I edit files in the built-in IDE, not just read diffs?"+ a: "Yes. The left rail also has the workspace file tree — clicking a file there opens it in a real editable Monaco tab. Tabs show a dirty-state dot when you have unsaved edits, and Cmd/Ctrl+S saves the active tab. Saves are hardened so keystrokes typed while a save is still writing are never silently dropped."+ - q: "Which folder does the IDE open — how is the workspace root chosen?"+ a: "The workspace root snapshots from an agent's working directory when the overlay opens: the selected agent's cwd if one is selected, otherwise the GOD agent's, otherwise the first agent's. So selecting the agent whose work you want to review before clicking IDE puts you in the right repo."+ - q: "Does Monaco load from a CDN? Does the renderer touch my disk?"+ a: "No and no. Monaco — the same editor engine VS Code uses — is fully self-hosted and bundled with the app, with no CDN involved, so it works offline. And the renderer holds no filesystem or git access at all: every read, write, and diff is brokered through main-process IPC via the preload bridge."+ - q: "Why build an IDE into an agent harness instead of using VS Code?"+ a: "Because the review loop is faster when it lives where the agents live. An agent finishes, you click IDE, read the side-by-side diff vs HEAD, fix small things in place, and go approve — no context switch to another app, no hunting for the right worktree. For heavy editing sessions your regular editor is still there; the built-in IDE is optimized for reviewing agent output."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Munder Difflin v0.3.3 ships a <strong>built-in Monaco IDE</strong> — the VS Code editor engine, fully self-hosted, no CDN. A title-bar <strong>IDE</strong> button toggles a full-window overlay above the office floor: a <strong>git CHANGES rail</strong> where clicking a file opens a <strong>side-by-side diff vs HEAD</strong>, a workspace <strong>file tree</strong>, <strong>editor tabs with dirty-state dots</strong>, and <strong>Cmd/Ctrl+S</strong> save. The workspace root snapshots from the <strong>selected → god → first agent's cwd</strong>, and <strong>all fs/git access goes through main-process IPC</strong> — the renderer never touches disk. The point: <em>agent finishes → open IDE → read the diff → tweak → approve</em>, without leaving the app.</p></div>++You hired a floor of agents, one of them just announced it's done, and now comes the part that actually matters: **reading what it changed before you bless it.** Until v0.3.3, that meant alt-tabbing to your editor, finding the right directory, and running `git diff` by hand. Now the review surface is built in. This is a practical walkthrough of the Monaco IDE that shipped in [v0.3.3](/blog/launching-munder-difflin-v0-3-3/) — what each piece does and the workflow it's designed around.++## Opening it: the title-bar IDE button++There's an **IDE** button in the title bar. Click it and a full-window Monaco editor overlays the office floor — same fullscreen-overlay pattern as the rest of the app, so the floor, the terminals, and the voice UX keep running underneath, untouched. Click it again and you're back watching avatars.++Monaco is the editor engine inside VS Code, and here it's **fully self-hosted**: bundled workers, no CDN, themed to the harness's light palette. That's not a vanity detail — it means the IDE works offline and nothing about your code round-trips through a third-party host just to render syntax highlighting. Local-first, like everything else in the app.++## The left rail: CHANGES first, tree second++The left rail has two jobs, in priority order.++**The git CHANGES list** is the headline. It shows every file with uncommitted changes in the workspace. Click one and you get a **read-only side-by-side diff against HEAD** — the agent's version on one side, what was committed before on the other. This is the "what did my agent actually do" view, and it's deliberately read-only: a diff is for reading, not for accidentally editing the wrong pane.++**The workspace file tree** sits alongside it. Click any file there and it opens as a normal, *editable* Monaco tab. So the rail gives you both motions: *review* (CHANGES → diff) and *fix* (tree → edit).++## Tabs, dirty dots, and Cmd/Ctrl+S++Open files stack up as **editor tabs** on the right, each with a **dirty-state dot** when it has unsaved edits, plus save and close. **Cmd/Ctrl+S** saves the active tab.++One hardening detail worth knowing because it's the kind of thing that silently eats work in lesser editors: saves are protected against the in-flight race. If you keep typing while a save is still writing to disk, those keystrokes are **not** dropped when the save completes. v0.3.3 fixed this explicitly.++## Which folder am I looking at? The workspace root++The IDE has to pick a repo to show, and it snapshots the workspace root from an agent's working directory when the overlay opens, in this order:++1. the **selected agent's** cwd, if you have one selected;+2. otherwise the **GOD agent's** cwd;+3. otherwise the **first agent's** cwd.++Practical consequence: **select the agent whose work you want to review, then click IDE.** That drops you straight into its directory — which matters on a floor where [each agent can run in its own isolated git worktree](/blog/claude-code-git-worktrees-vs-hive/), so "the repo" isn't one place.++## The security posture: the renderer never touches disk++Everything the IDE does — listing the tree, reading files, writing saves, computing diffs — is **brokered through main-process IPC**. The diff view rides a `git:diff` IPC channel plus the preload bridge; the renderer process holds no filesystem or git access of its own. That's the same architecture as the rest of the harness: the sandboxed renderer asks, the main process does, and the attack surface of "web content with disk access" simply doesn't exist here.++## The workflow it's built for: finish → diff → tweak → approve++Here's the loop the whole feature is shaped around:++1. **An agent finishes.** You get the desktop notification, or Michael tells you.+2. **Select that agent, click IDE.** You're in its workspace.+3. **Read the CHANGES rail.** Click through each touched file, read the side-by-side diff vs HEAD. This is the honest answer to "what did it do," straight from git — not the agent's summary of itself.+4. **Tweak in place.** Wrong variable name, missing edge case, comment you'd phrase differently — open the file from the tree, fix it, Cmd/Ctrl+S. No editor switch.+5. **Approve.** Now that you've *seen* the change, act on it — answer the approval-queue escalation, tell the agent to commit, or dispatch the follow-up.++That last step is the point. [Human-in-the-loop approval](/blog/human-in-the-loop-approving-ai-agents/) is only as good as the human's view of the change, and "I skimmed the agent's summary" is not a view. A diff vs HEAD is. The built-in IDE closes the gap between *the agent says it's done* and *you know what done contains* — inside the same window where the work happened.++## Try it++The IDE ships in v0.3.3 for macOS, Windows, and Linux — [grab the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest), or start with the [install guide](/blog/how-to-install-and-use-munder-difflin/) if you're new. If the review loop saves you an alt-tab, a [GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/blog/src/posts/loop-engineering-for-ai-agents.md b/blog/src/posts/loop-engineering-for-ai-agents.mdnew file mode 100644index 00000000..229469f0--- /dev/null+++ b/blog/src/posts/loop-engineering-for-ai-agents.md@@ -0,0 +1,87 @@+---+title: "Loop Engineering: Designing Agent Loops That Converge"+description: "Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away."+date: 2026-07-03+category: concepts+categoryLabel: Concepts+type: Technical+primaryKeyword: "agent loop engineering"+secondaryKeywords: ["agentic loop", "runaway ai agent", "stop conditions for ai agents", "agent circuit breaker", "long-running ai agents", "no-progress detection"]+tags: ["Concepts", "Reliability", "Multi-Agent", "Autonomy", "Guardrails"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is an agentic loop?"+ a: "It's the cycle an autonomous agent runs: gather context, take action, verify the result, repeat. Anthropic uses this framing for Claude Code and the Claude Agent SDK — an LLM autonomously using tools in a loop. The inner loop is what the model does each turn; the outer loop is everything the harness wraps around it: when to continue, when to retry, when to escalate, and when to stop."+ - q: "What makes an agent loop converge instead of running away?"+ a: "Three properties borrowed from ordinary loop design: a progress measure that actually moves toward done (verified state, not the model's own claim), hard bounds (iteration caps, token budgets, wall-clock limits), and real exits (task verified done, budget exhausted, or a human gate). A loop with any of the three missing is a runaway waiting for a quiet weekend."+ - q: "What is a drain loop?"+ a: "A pattern for keeping an agent working through a queue without a human re-prompting it. In Claude Code it's built on the Stop hook: when the agent tries to end its turn, the hook checks the inbox, and if mail is waiting it blocks the stop and continues the session with the next item as the prompt. The stop_hook_active flag exists precisely so this pattern can't recurse into an infinite forced continuation."+ - q: "How do you detect a runaway agent loop?"+ a: "By measuring progress from the outside, not by asking the agent. Signals include repeated near-identical tool calls, error storms (the same failure N times in a row), token spend rising while verified state doesn't change, and turns that end without any file, test, or board delta. A breaker watching those signals can intervene long before the budget does."+ - q: "Why are budgets part of loop design rather than just cost control?"+ a: "Because a budget is a loop bound — the guaranteed-termination clause. Even if every other signal fails and the agent loops plausibly forever, a per-agent token budget means the loop halts at a ceiling you chose in advance. Cost control is the side effect; bounded iteration is the point."+ - q: "Should a stopped agent loop end at a human?"+ a: "For the failure cases, yes. A converging loop has graduated responses — steer first, constrain next, stop last — and the terminal state of a stopped loop should be an approvals queue a human acts on, not a silent dead process. Escalation to a person is the exit condition of last resort, and it should be explicit in the design, not an accident."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Prompt engineering shapes one turn. Loop engineering shapes whether ten thousand turns converge.</strong> The inner agentic loop — gather context, act, verify — comes with the model. The outer loop is yours to build: <strong>stop conditions</strong> that check verified state, <strong>drain loops</strong> that feed queued work back in, <strong>retry with backoff</strong>, <strong>compaction cycles</strong> that keep context bounded, a <strong>breaker ladder</strong> (steer → constrain → stop), <strong>no-progress detection</strong>, <strong>budgets as loop bounds</strong>, and <strong>human gates as exits</strong>. That's the difference between an agent floor that runs for days and one that melts by morning.</p></div>++There are two loops in every autonomous agent, and we only ever talk about one of them.++The inner loop is the famous one. Anthropic describes it as the agentic loop: **gather context → take action → verify work → repeat**. The model reads files, edits, runs the tests, reads the output, goes again. That loop ships with Claude Code, Codex, Copilot CLI — you don't build it, you rent it.++The outer loop is the one you build. It answers the questions the inner loop can't: should this agent keep going? On what? For how much? And who gets told when it shouldn't? Get the outer loop wrong and the inner loop's competence doesn't matter — you either stop too early and leave work stranded, or you don't stop and produce the classic runaway: an agent burning tokens at 3 a.m., confidently retrying the same failing command for the 40th time.++I think of this as **loop engineering**, and it deserves the same rigor we give prompts and context. (It's the sibling of [context engineering](/blog/context-engineering-for-ai-agents/) — that discipline shapes what's *in* the window; this one shapes what happens *between* windows.)++## Converging loops vs runaway loops++Borrow the checklist from ordinary programming. A `while` loop terminates when three things are true, and an agent loop is no different:++1. **A progress measure that moves.** Something external must get closer to done each iteration — tests passing, board cards moving, diffs landing. Crucially it must be *verified* state, not the model's self-report. Anthropic's guidance on long-running harnesses makes the same point: don't let the agent declare victory; keep an explicit feature list and only mark items done after real verification.+2. **Bounds.** Max iterations, max tokens, max wall-clock. A loop without a bound isn't autonomous, it's unattended.+3. **Exits.** Defined terminal states: done-and-verified, budget-exhausted, escalated-to-human. Every path out of the loop should be one you chose.++A runaway loop is just a loop missing one of these — usually the first. The agent is *doing things*, tokens are flowing, avatars are walking around, and nothing external is changing. Motion without progress.++## The outer-loop toolbox++Here's the toolbox as it actually exists in [Munder Difflin](/), where the design constraint is blunt: a floor of CLI agents has to run for days without a human babysitting it, and without melting.++**Stop conditions.** The naive stop condition is "the model stopped talking." The engineered one checks state: is the task's definition of done verified? In Munder Difflin, workers don't self-certify — the GOD orchestrator reads results, adjudicates, and moves the board (see [how the GOD orchestrator works](/blog/how-the-god-orchestrator-works/)).++**Drain loops.** The most useful outer-loop pattern in Claude Code is built on the Stop hook: when an agent tries to end its turn, the hook checks its mailbox — and if mail is waiting, it blocks the stop and continues the session with the next message as the prompt. The agent drains its queue instead of dying with a full inbox. Claude Code's own hooks reference builds in the guardrail this pattern needs: a `stop_hook_active` flag, so a blocked stop can't recurse into an infinite forced continuation. That's loop engineering *inside* the primitive — one continuation per real stop, not a hall of mirrors.++**Retry with backoff.** Transient failures (rate limits, flaky network, a wedged terminal) deserve a retry; identical immediate retries deserve suspicion. Munder Difflin's wake-reliability layer takes the same stance at floor scale: revive wedged terminals, catch up missed schedules, re-arm the message router — recover the *loop*, don't just replay the failure. More in [recovering from agent failures](/blog/recovering-from-agent-failures/).++**Compaction cycles.** Long loops fill context windows, and a full window degrades every subsequent iteration. So compaction has to be part of the cycle, not an emergency. Munder Difflin runs a dedicated auto-compact maintenance schedule, decoupled from missions, and the floor even shows a *compacting* avatar state — because a maintenance pause that looks like a hang gets killed by nervous humans.++**Breaker escalation: steer → constrain → stop.** Binary kill switches are a bad fit for agents, because most divergence is recoverable. Munder Difflin's circuit breaker is a ladder: first *steer* (a corrective nudge into the session), then *constrain* (tighten what the agent may do), then *stop* — triggered by looping, error storms, or a blown budget. Graduated response preserves the work that a hard kill would throw away.++**No-progress detection.** The breaker needs a tripwire, and "is it looping?" can't be answered by asking the looper. External signals work: repeated near-identical actions, the same error N times, spend rising while verified state stays flat. There's also a quieter failure — the *silent* stall — which Munder Difflin catches with a PTY-quiescence backstop: an agent pinned `working` but producing no output gets flipped back to idle, where the inbox-wake nudge can restart its drain loop.++**Budgets as loop bounds.** Per-agent token budgets, tracked live against real telemetry, are the guaranteed-termination clause. If every other signal misses, the loop still halts at a ceiling you set while calm.++**Human gates as loop exits.** The final exit isn't a dead process; it's a person. Spend, scope changes, and destructive operations escalate into an approvals queue rather than resolving inside the loop — the human is a designed exit condition, not an interrupt handler. That's the heart of [human-in-the-loop agent design](/blog/human-in-the-loop-approving-ai-agents/).++## The bottom line++The model gives you the inner loop; the outer loop is the product. Verified stop conditions, drain loops with anti-recursion guards, backoff, scheduled compaction, a breaker ladder, progress tripwires, budget bounds, and human exits — stacked together, they're why a floor of agents can run for days and converge on finished work instead of a bill.++Munder Difflin ships this outer loop as a free, MIT-licensed, local-first desktop app for the agent CLIs you already run. [Download it](https://github.com/chaitanyagiri/munder-difflin/releases/latest), and if the loop-nerdery resonates, a [GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.++## FAQ++**What is an agentic loop?** The cycle an agent runs each turn: gather context, act, verify, repeat. The outer loop is everything the harness wraps around it — continue, retry, escalate, stop.++**What makes a loop converge?** A verified progress measure, hard bounds, and designed exits. Missing any one of the three, you've built a runaway.++**What is a drain loop?** A Stop-hook pattern: when the agent tries to end its turn with mail waiting, the hook blocks the stop and continues the session with the next item — bounded by `stop_hook_active` so it can't recurse forever.++**How do you catch a runaway?** External signals only: repeated actions, error storms, spend without state change, silent stalls. Then respond on a ladder — steer, constrain, stop — with a human approvals queue as the terminal exit.++Sources: [Anthropic — Building agents with the Claude Agent SDK](https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk);+[Anthropic — Effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents);+[Claude Code — Hooks reference](https://code.claude.com/docs/en/hooks).diff --git a/blog/src/posts/orca-vs-munder-difflin.md b/blog/src/posts/orca-vs-munder-difflin.mdnew file mode 100644index 00000000..9ecd9c53--- /dev/null+++ b/blog/src/posts/orca-vs-munder-difflin.md@@ -0,0 +1,86 @@+---+title: "Orca vs Munder Difflin: Agent IDE or Agent Office?"+description: "Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick."+date: 2026-07-03+category: comparisons+categoryLabel: Comparisons+type: Non-technical+primaryKeyword: "orca vs munder difflin"+secondaryKeywords: ["orca agent ide", "agent development environment", "orca alternative", "multi-agent orchestrator", "run coding agents in parallel", "autonomous coding agents"]+tags: ["Comparisons", "Orca", "Multi-Agent", "Local-First", "Orchestration"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is Orca (onorca.dev)?"+ a: "Orca is a free, MIT-licensed Agent Development Environment (ADE) from the YC-backed team at Stably AI. It's a cross-platform desktop IDE built for running coding agent CLIs — Claude Code, Codex, OpenCode, Gemini, Copilot, and dozens more — side by side, each in its own isolated git worktree, with Ghostty-inspired terminals, a VS Code-based editor, an embedded browser with Design Mode, GitHub and Linear integration, and iOS/Android companion apps."+ - q: "How is Munder Difflin different from Orca?"+ a: "They sit at different altitudes. Orca is an IDE you sit in: you send prompts, compare agents, annotate diffs, and steer. Munder Difflin is an office that runs itself: a GOD orchestrator routes work between agents, agents share long-term memory and mailboxes, and work arrives via Slack, webhooks, schedules, or voice — with approval gates, budgets, and a circuit breaker so it can run for days without you watching."+ - q: "Is Orca better than Munder Difflin?"+ a: "For interactive, editor-centric work, honestly, often yes. Orca's editing, diff-annotation, per-worktree browser preview, and mobile companion are more polished for hands-on driving. Munder Difflin wins when you want autonomy: orchestration, shared memory, external triggers, scheduling, and guardrails that let a team of agents work while you're away. They solve different problems."+ - q: "Can I use Orca and Munder Difflin together?"+ a: "Yes, and it's a sensible split. Both are free, MIT-licensed, local-first desktop apps that drive the same agent CLIs on your own subscriptions, so nothing conflicts. Use Orca when you're at the keyboard iterating on a feature; use Munder Difflin as the always-on layer that handles routed, scheduled, and Slack-triggered work in the background."+ - q: "Do both tools use git worktrees for agent isolation?"+ a: "Yes. Orca is built around worktree isolation — every agent task gets its own worktree so parallel agents never collide. Munder Difflin has the same per-agent worktree isolation as a toggle, but layers a coordination system on top: a hive of mailboxes, a shared blackboard, single-committer git, and an orchestrator that routes messages between the isolated agents."+ - q: "Are Orca and Munder Difflin both free and open source?"+ a: "Yes. Both are MIT-licensed, free, local-first desktop apps for macOS, Windows, and Linux, and both are bring-your-own-subscription — they wrap the agent CLIs and accounts you already have rather than reselling model access."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Orca is an Agent IDE; Munder Difflin is an agent office.</strong> Orca (from YC-backed Stably AI) is the polished cockpit for <strong>driving coding agents interactively</strong> — parallel worktrees, great terminals, a VS Code editor, diff annotation, and a genuinely useful mobile companion. Munder Difflin is the layer above the cockpit: a <strong>GOD orchestrator</strong> that routes work, <strong>shared long-term memory</strong>, triggers from <strong>Slack, webhooks, schedules, and voice</strong>, and guardrails (approvals, budgets, circuit breaker) that make <strong>days-long autonomy</strong> safe. Both are free, MIT-licensed, local-first, BYO-subscription. Pick Orca to <em>sit and steer</em>; pick Munder Difflin to <em>delegate and walk away</em>. They coexist fine.</p></div>++If you're evaluating tools for running multiple coding agents, Orca and Munder Difflin will both show up in your search — and on paper they rhyme. Both are free, MIT-licensed desktop apps. Both run on macOS, Windows, and Linux. Both wrap the agent CLIs you already pay for — Claude Code, Codex, OpenCode, and more — instead of reselling model access. Both isolate agents in git worktrees so parallel work doesn't collide.++But they are not the same product, and pretending otherwise would help nobody. One is an IDE. The other is an office. Here's the honest version of that boundary.++## What Orca actually is++[Orca](https://www.onorca.dev/) calls itself an **Agent Development Environment (ADE)** — an IDE rebuilt from the ground up around agents rather than retrofitted for them. It comes from Stably AI, a Y Combinator-backed team, and it shows: the product is fast, focused, and clearly built by people who drive agents all day.++The core idea is **parallel agents in isolated worktrees**. Spin up a task and Orca creates a worktree for it; run Claude Code, Codex, OpenCode, Grok, Gemini, Copilot — it lists 25+ preconfigured agents and accepts any CLI — side by side, even firing one prompt at several agents at once and comparing what comes back. Around that core it builds a serious cockpit:++- A **Ghostty-inspired terminal** with WebGL rendering, infinite splits, and scrollback search.+- **VS Code's editor** with autosave and quick-open.+- An **embedded Chromium browser per worktree**, plus a Design Mode where you click any UI element to send its HTML, CSS, and a cropped screenshot straight into the agent's context.+- **Diff annotation** — drop markdown comments on any diff line and send them back to the agent.+- Native **GitHub and Linear** integration, SSH worktrees for remote machines, and **iOS/Android companion apps** to monitor and steer agents from your phone.++That mobile companion and the editor-centric review flow are genuinely ahead of what Munder Difflin offers today. If your workflow is "I'm at my desk, I want to run three agents on a feature and pick the best diff," Orca is excellent at exactly that.++Notice, though, what the workflow assumes: **you**. You send the prompts. You compare the results. You annotate the diffs. You steer. Orca's own docs describe an interactive loop, and there's no orchestrator, scheduler, or external trigger in it. That's not a flaw — it's the product. An IDE is a place you sit.++## What Munder Difflin actually is++Munder Difflin starts from the opposite question: what if you *don't* sit there?++It's a local-first Electron app that turns the same agent CLIs — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — into a **coordinated office**. Each agent is a real CLI process in its own pseudo-terminal and isolated worktree (same isolation idea as Orca — we've written about [how worktrees and the hive fit together](/blog/claude-code-git-worktrees-vs-hive/)), visualized as an affectionate parody of The Office cast on a pixel-art floor. The differences stack up above that:++- A **GOD orchestrator** ("Michael") is the one agent you talk to. It routes tasks between workers, adjudicates their messages, resolves routine questions itself, and escalates only critical items to you. ([How the GOD orchestrator works.](/blog/how-the-god-orchestrator-works/))+- Agents share **long-term memory** — markdown-first, with a semantic recall index — so what one agent learns, the office remembers across sessions.+- Work arrives without you: **Slack messages** ([which can spawn ephemeral workers that reply in-thread](/blog/trigger-ai-agents-from-slack/)), **webhooks**, **scheduled missions** with a heartbeat that re-engages a quiet floor, GitHub issue ingestion, and **voice** — Talk mode connects you to Michael over the OpenAI Realtime API.+- Autonomy is bounded by **guardrails**: [human approval gates](/blog/human-in-the-loop-approving-ai-agents/) on spend, scope, and destructive operations; per-agent token budgets; a cost/runaway circuit breaker; and OpenTelemetry observability with real per-agent cost attribution.++v0.3.3 did add a built-in Monaco IDE — file tree, tabs, side-by-side diffs vs HEAD — but let's be honest about what it's for: it's a **review surface for what your agents changed**, not a place you live. Orca's editing experience is deeper. Munder Difflin's bet is that you'll spend less time in an editor at all, because the office handles the routing, memory, and follow-through that would otherwise pull you back to the keyboard.++## The boundary, drawn plainly++| | **Orca** | **Munder Difflin** |+|---|---|---|+| Category | Agent IDE / ADE | Autonomous agent office |+| You are the… | Driver | Manager |+| Coordination | You, interactively | GOD orchestrator routes work |+| Memory | Per-session | Shared long-term + semantic recall |+| Triggers | You send prompts | Typing, Slack, webhooks, schedules, voice |+| Away-from-desk | Mobile app (monitor + steer) | Runs autonomously with approval gates |+| Editor flow | VS Code editor, Design Mode, diff annotation — stronger | Monaco review surface — lighter |+| Guardrails | Your judgment | Approvals, budgets, circuit breaker, OTel |+| License / cost | MIT, free, BYO subscription | MIT, free, BYO subscription |++## When to pick which++**Pick Orca** if your bottleneck is interactive throughput: you're at the keyboard, you want several agents on one problem, and you want first-class tools for comparing, annotating, and shipping their diffs — plus a phone app to check in from the couch.++**Pick Munder Difflin** if your bottleneck is *you being required at all*: you want work triggered from Slack or a schedule, routed by an orchestrator, informed by shared memory, and bounded by budgets and approval gates while it runs overnight.++And genuinely: **you can run both.** Same CLIs, same subscriptions, same machine, no conflict. Orca for the sessions you drive; Munder Difflin for the office that keeps working when you stop. (For the broader decision framework, see [how to choose a multi-agent tool](/blog/how-to-choose-a-multi-agent-tool/).)++If the office side sounds like your bottleneck, [grab the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — and if it earns it, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/blog/src/posts/review-agent-work-where-it-happens.md b/blog/src/posts/review-agent-work-where-it-happens.mdnew file mode 100644index 00000000..fbe46f69--- /dev/null+++ b/blog/src/posts/review-agent-work-where-it-happens.md@@ -0,0 +1,71 @@+---+title: "Review Agent Work Where It Happens"+description: "AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor."+date: 2026-07-03+category: concepts+categoryLabel: Concepts+type: Technical+primaryKeyword: "review ai agent code changes"+secondaryKeywords: ["ai agent code review bottleneck", "review agent diffs in place", "built-in monaco ide", "supervising ai coding agents", "human in the loop code review", "multi-agent git workflow"]+tags: ["Concepts", "Code Review", "Monaco IDE", "Human-in-the-Loop", "Git"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Why is code review the bottleneck in multi-agent coding?"+ a: "Because generation scaled and review didn't. A floor of CLI agents can produce diffs across several worktrees in parallel, but every change still has to pass through one human's judgment before it ships. The constraint on a supervised agent fleet is no longer how fast the agents write code — it's how fast you can read, verify, and accept what they wrote."+ - q: "What is review-in-place?"+ a: "Reviewing agent output inside the same tool where you supervise the agents, instead of alt-tabbing to an external editor. In Munder Difflin, a title-bar IDE button opens a built-in Monaco editor over the office floor: a git CHANGES rail lists what the agents touched, clicking a file shows a side-by-side diff against HEAD, and the file tree lets you open and edit anything with Cmd/Ctrl+S save. You never leave the app where the agents, terminals, and approvals live."+ - q: "Is the built-in IDE a full VS Code replacement?"+ a: "No, and it isn't trying to be. It's Monaco — the same editor engine VS Code uses, fully self-hosted with no CDN — scoped to the supervision loop: see what changed via the CHANGES rail, read the side-by-side diff vs HEAD, and make small corrections with editor tabs and Cmd/Ctrl+S. For deep multi-hour editing sessions your usual editor is still the right tool; for reviewing and touching up agent work, in-place is faster."+ - q: "How does the single-committer git pattern make review safer?"+ a: "In Munder Difflin, no agent ever runs git against the shared hive repo — agents write plain files to their outbox and one harness-owned committer does all the git operations. That prevents index.lock corruption from concurrent commits and gives you a serialized, auditable history. Combined with per-agent worktrees for code changes, it means the diff you review is exactly what one agent did, not an interleaving of several."+ - q: "Where do human approval gates fit into reviewing agent work?"+ a: "The GOD orchestrator resolves routine requests itself and escalates only critical items — spend, destructive operations, scope changes — into an approvals queue you act on. That's decision-level review. The IDE's diff view is code-level review. Together they cover both halves: you approve what the fleet is allowed to do, and you verify what it actually did, without leaving the app."+ - q: "Does the IDE give the renderer direct filesystem access?"+ a: "No. All filesystem and git access is brokered through the Electron main process over IPC — the renderer holds no fs or git access of its own. The diff comes from a main-process git bridge, saves go through the same brokered path, and a v0.3.3 fix ensures keystrokes typed during an in-flight save are never silently lost."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Agents write diffs faster than you can review them</strong> — and every alt-tab to an external editor breaks the supervision loop you're supposed to be running. The fix is <strong>review-in-place</strong>: Munder Difflin v0.3.3 ships a <strong>built-in Monaco IDE</strong> (the VS Code editor engine, self-hosted) over the office floor — a <strong>git CHANGES rail</strong>, <strong>side-by-side diffs vs HEAD</strong>, a file tree, and <strong>Cmd/Ctrl+S</strong> edits — so you verify agent work where the agents actually are. Pair it with the <strong>single-committer git pattern</strong> (clean, serialized, reviewable history) and <strong>human approval gates</strong> (decision-level review), and the review bottleneck stops being the reason your fleet idles.</p></div>++Here's the uncomfortable math of running a floor of coding agents: generation scaled, review didn't. One [GOD orchestrator](/blog/how-the-god-orchestrator-works/) dispatching work to a handful of CLI agents in isolated worktrees can produce more diffs in an hour than most engineers review in a day. The agents aren't the bottleneck anymore. **You are.**++That's not an insult — it's the design constraint. A supervised fleet is only as fast as its slowest verification step, and for code, verification means a human actually reading the change. So the question worth engineering is: how do you make the reading step cheap?++## Alt-tabbing is where supervision goes to die++The default answer is "open the repo in your editor." It works, and it's also quietly terrible for this job.++When you supervise agents, you're running a loop: watch the floor, read an escalation, check what an agent changed, answer, move on. Every hop out to an external editor breaks that loop. You alt-tab, find the right window, find the right worktree (each agent has its own), pull up a diff, and by the time you've read it, the context that prompted the check — which agent, which task, what it claimed — has evaporated. Then you tab back and reconstruct it.++Multiply that by every agent, every task, all day. The cost isn't the seconds per switch; it's that switching makes review feel expensive, so you do less of it, so agent work merges less verified than it should. The bottleneck doesn't just slow you down — it degrades the quality of the supervision itself.++## Review-in-place: the IDE comes to the floor++This is the problem the v0.3.3 built-in IDE exists to solve. A title-bar **IDE** button opens a full-window **Monaco** editor — the same editor engine VS Code runs on, fully self-hosted with no CDN — as an overlay on the office floor. The floor, the terminals, and everything else stay untouched underneath; you toggle in, review, toggle out.++The layout is built around the review loop, not general-purpose editing:++- **A git CHANGES rail** on the left lists exactly what changed in the workspace. This is the "what did my agents just do" view, one click from the floor.+- **Click a changed file** and you get a read-only **side-by-side diff vs HEAD** — the honest before/after, not a summary the agent wrote about itself.+- **A workspace file tree** below it opens any file for real editing, with **editor tabs**, dirty-state dots, and **Cmd/Ctrl+S** save. Spot a wrong variable name in review? Fix it there. No round-trip through another app, no "hey agent, please rename x to y" for a two-character change.++The workspace root snapshots from the selected agent's cwd (falling back to the GOD agent's, then the first agent's), so the IDE opens onto the code you were just looking at, not a generic project picker.++One architectural note that matters more than it sounds: **the renderer holds no filesystem or git access.** Every read, diff, and save is brokered through the Electron main process over IPC. The pretty editor window is just a view; the privileged operations happen in one audited place. And a v0.3.3 fix hardened the save path so keystrokes typed while a save is still writing are never silently dropped — a small thing, exactly the kind of small thing that erodes trust in an in-app editor if it's wrong.++## The diff is only trustworthy because of how it was made++A side-by-side diff vs HEAD is only useful if HEAD means something. In a naive multi-agent setup — several agents committing to one repo — it doesn't: histories interleave, `index.lock` collisions corrupt state, and "what did agent B change" has no clean answer.++Munder Difflin avoids this with two structural choices. For the shared hive, **no agent ever touches git**: agents write plain files to their `outbox/`, the router delivers mail, and a single harness-owned committer performs every git operation — the [single-committer git pattern](/blog/single-committer-git-pattern/), which trades a theoretical bottleneck for a serialized, corruption-free, auditable history. For code, **each agent gets its own isolated worktree** (see [worktrees vs the hive](/blog/claude-code-git-worktrees-vs-hive/)), so the diff you review is one agent's coherent work, not a merge puzzle.++Review-in-place sits on top of that foundation. The CHANGES rail is legible *because* the git story underneath is disciplined.++## The other half: gates for decisions, diffs for code++Reading diffs is code-level review. But half of supervising agents is **decision-level** review: should this agent spend that much, delete that thing, expand that scope? The GOD orchestrator handles the routine traffic itself and escalates only critical items — spend, destructive ops, scope changes — into an approvals queue you act on. That's the [human-in-the-loop gate](/blog/human-in-the-loop-approving-ai-agents/), and it's deliberately the same shape as the IDE: the decision comes to you, in the app, with context attached.++Put together, the review story has two lanes and zero alt-tabs. Approvals catch the *should we* questions before damage happens; the IDE's diff rail catches the *what actually happened* questions before code merges. Both live where the agents live. The supervision loop stays unbroken, review stays cheap, and cheap review is review that actually happens.++Agents got fast. The winning move isn't reviewing less — it's moving review to where the work is. [Grab the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest) and try the IDE button, and if the floor earns it, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/blog/src/posts/run-a-mixed-engine-office.md b/blog/src/posts/run-a-mixed-engine-office.mdnew file mode 100644index 00000000..07e95386--- /dev/null+++ b/blog/src/posts/run-a-mixed-engine-office.md@@ -0,0 +1,77 @@+---+title: "Run a Mixed-Engine Office: the Right CLI for Every Desk"+description: "A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "mixed-engine ai agent office"+secondaryKeywords: ["mix ai coding agents", "claude code orchestrator", "byok agent engines", "local llm coding agents", "per-agent engine picker", "multi-engine agent harness"]+tags: ["Guides", "Multi-Agent", "Engines", "Local-First", "Cost"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Which agent engines can Munder Difflin run on one floor?"+ a: "Seven CLI engines plus a local provider: Claude Code, Antigravity (Gemini), OpenAI Codex, OpenCode, Crush, pi.dev, and GitHub Copilot CLI, which joined in v0.3.3 as the first community-contributed engine. You pick the engine per hire from a visual picker in Add Agent, and they all participate in the same hive on the same office floor."+ - q: "Can any engine be the GOD orchestrator?"+ a: "Michael's engine is swappable from onboarding or a change-engine flow, and OpenCode, Crush, and pi.dev are god-eligible alongside Claude Code, Antigravity, and Codex. Claude Code is the strongest default because it has the native hook bridge and the deepest hive integration. Copilot CLI is a worker-only engine: its print mode exits per turn, so it can't run the floor."+ - q: "Where do API keys and local model endpoints go?"+ a: "Settings -> AI Engines. Per-provider keys (Anthropic, OpenAI, Google, OpenRouter, Groq) are stored write-only in the encrypted secret broker — they're never read back into the renderer and are materialized main-only at spawn. The same panel holds per-engine local base-URLs for Ollama, LM Studio, or vLLM, plus default-model fields that OpenCode, Crush, and pi.dev pick up when they spawn."+ - q: "How do I run some desks on local or open-source models?"+ a: "Hire a worker on a local-capable engine — OpenCode, Crush, or pi.dev — and the Add Agent modal surfaces curated OSS-model quick-picks: a Local bucket of Mac-runnable Ollama tags (gpt-oss, Qwen3, DeepSeek-R1, Mistral Small, Llama 3.3 70B) and a BYOK bucket via Groq or OpenRouter. Clicking one fills the engine-correct model slug and rebuilds the spawn command for you."+ - q: "Why is GitHub Copilot CLI limited to dispatched tasks?"+ a: "Copilot CLI runs in its documented non-interactive print mode (copilot -p), which exits after each turn and exposes no hook bridge. That means Copilot workers can't drain hive inbox mail — routed messages bounce to the GOD orchestrator instead of silently dropping. They're excellent for self-contained dispatched work, and they authenticate with your existing GitHub Copilot login, no new keys."+ - q: "What happens if a chosen engine's CLI isn't installed?"+ a: "The harness self-heals: it runs that engine's installer in the terminal, then automatically restarts and continues into the freshly installed binary in place. There's no dead-end and no manual step, and the flow is idempotent so the installer never fires twice."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>You don't have to pick one agent CLI. Munder Difflin runs <strong>seven engines on one floor</strong> — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — chosen <strong>per hire</strong> from a visual picker. The winning layout: <strong>Claude Code as the GOD orchestrator</strong> and hive-aware senior workers, <strong>Codex for coding bursts</strong>, <strong>Copilot for dispatched, self-contained tasks</strong>, and <strong>OpenCode / Crush / pi.dev on BYOK keys or local models</strong> for the routine majority. Keys and local endpoints live in <strong>Settings → AI Engines</strong>; OSS-model quick-picks fill the right slug for you.</p></div>++Most multi-agent setups are a clone army: five copies of the same CLI on the same model, paying the same rate for wildly different jobs. That's like staffing an office entirely with regional managers. A real office has a manager, a couple of closers, and a lot of people doing solid routine work at a sensible salary.++Munder Difflin is built for that second shape. Every hire — and Michael, the [GOD orchestrator](/blog/how-the-god-orchestrator-works/) himself — runs on a pluggable engine, picked from a visual provider picker at hire time. Here's how to lay out the floor.++## The engine roster, honestly++Seven engines can sit on one floor today, and they're not interchangeable — that's the point:++- **Claude Code** — the deepest hive citizen. Native hooks drive lifecycle events, inbox draining, HITL gates, and mid-run steering. The natural orchestrator.+- **Antigravity (Gemini)** — full hive participation via the native `agy-hook` bridge.+- **OpenAI Codex** — receives the hive protocol as its initial prompt and participates through inbox/outbox routing. A strong pure-coding worker.+- **OpenCode, Crush, pi.dev** — the BYOK trio (shipped in v0.3.1), wired in via native-plugin, proxy, and hooks bridges respectively. Each works as a worker *and* as Michael, and each can point at your own keys or a local model.+- **GitHub Copilot CLI** — new in [v0.3.3](/blog/launching-munder-difflin-v0-3-3/), the first community-contributed engine (PR #101). Runs in documented print mode (`copilot -p`) with a model picker and `--resume`, authenticated by your existing Copilot login.++One honest caveat up front: Copilot's print mode exits per turn and has no hook bridge, so its workers can't drain hive inbox mail — routed mail bounces to the orchestrator instead of disappearing. That's by design, and it tells you exactly where Copilot desks belong.++## The layout that works++**Michael's office: Claude Code.** The orchestrator reads every request, adjudicates traffic, scribes the blackboard, and escalates only critical items to you. That's sustained, stateful, judgment-heavy work — give it the engine with native hooks and the tightest harness integration. (Michael's engine is swappable from onboarding or the change-engine flow if you want to experiment; OpenCode, Crush, and pi.dev are all god-eligible, backstopped by a provider-agnostic idle fallback.)++**Senior desks: Claude Code or Antigravity, hive-aware.** Work that involves conversation — replying to routed messages, coordinating with other agents, long multi-step missions — needs engines that drain a mailbox. These are your closers.++**Coding bursts: Codex.** Scoped, well-defined implementation work — "build this component, tests included" — plays to Codex's strengths. It gets the protocol injected as its initial prompt and reports back through outbox routing.++**Dispatched tasks: Copilot CLI.** Self-contained jobs that arrive, execute, and finish — perfect for print mode. Hire a Copilot worker, pick its model (Claude Sonnet 4.5 by default, GPT-5.4, or auto), and dispatch. No new keys; your existing GitHub Copilot seat covers it.++**The routine majority: OpenCode, Crush, or pi.dev on cheap or local models.** Formatting passes, doc updates, changelog grooming, triage — most fleet work doesn't need frontier reasoning, and this is where the money is. This is [capability routing](/blog/do-more-with-less-model-routing/) made physical: the desk itself is the routing decision.++## Wiring it: Settings → AI Engines++All the credentials for the BYOK trio live in one panel. **Settings → AI Engines** collects per-provider API keys — Anthropic, OpenAI, Google, OpenRouter, Groq — stored **write-only** in the encrypted secret broker. They're never read back into the renderer; the main process materializes them into the environment only at spawn. The same panel takes per-engine **local base-URLs** (Ollama, LM Studio, vLLM) and default-model fields, which OpenCode, Crush, and pi.dev pick up automatically.++Then hire. In Add Agent, choosing a local-capable engine surfaces **OSS-model quick-picks**: a *Local* bucket of Mac-runnable Ollama tags (gpt-oss 20B/120B, Qwen3, DeepSeek-R1, Mistral Small, Llama 3.3 70B) and a *third-party OSS provider* bucket via Groq or OpenRouter. Click one and it fills the engine-correct slug — `local/<tag>` for OpenCode, `ollama/<tag>` for Crush and pi — and rebuilds the spawn command. If the engine's CLI binary is missing, the harness runs its installer in the terminal and auto restart-and-continues into the fresh binary. No dead-ends.++The full local-model walkthrough is in [run Munder Difflin on open models](/blog/run-munder-difflin-on-open-models/).++## Keeping the mixed floor affordable and sane++A mixed floor is a cost instrument, but only if you can see and cap what each desk spends. Munder Difflin gives every agent a **token budget** with live fleet monitoring, real token and cost telemetry per agent per session, and a **circuit breaker** that steers, constrains, then stops any agent that loops or blows its budget. The expensive Claude Code desks carry tight scopes; the local desks can grind all night for electricity. The routing logic — which work deserves which price — is the whole subject of [the multi-agent cost playbook](/blog/the-multi-agent-cost-playbook/).++Isolation keeps them from colliding: each hire gets its own pseudo-terminal and, with the git-isolation toggle, its own worktree — seven engines, zero branch fights.++## Start with three desks++Don't design the org chart up front. Hire Claude Code as Michael, add one Codex or Copilot desk for a real coding task, and one OpenCode desk on a Groq or Ollama model for something routine. Watch what each engine is actually good at on *your* work, then grow the floor around the evidence.++Munder Difflin is free, MIT-licensed, and local-first. [Grab the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest) and try a mixed floor — and if it earns a spot in your toolkit, a [GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/blog/src/posts/tmux-and-scripts-vs-an-agent-harness.md b/blog/src/posts/tmux-and-scripts-vs-an-agent-harness.mdnew file mode 100644index 00000000..9458b050--- /dev/null+++ b/blog/src/posts/tmux-and-scripts-vs-an-agent-harness.md@@ -0,0 +1,70 @@+---+title: "Running Agents in tmux vs an Agent Harness"+description: "tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates."+date: 2026-07-03+category: comparisons+categoryLabel: Comparisons+type: Technical+primaryKeyword: "tmux vs agent harness"+secondaryKeywords: ["run claude code in tmux", "multiple claude code sessions tmux", "git worktrees parallel agents", "diy multi-agent setup", "agent harness vs shell scripts"]+tags: ["Comparisons", "tmux", "Claude Code", "Multi-Agent", "Git Worktrees"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Can I run multiple Claude Code sessions with just tmux and git worktrees?"+ a: "Yes, and it works well at small scale. Give each session its own tmux pane or window and its own git worktree so branches never collide, then detach and reattach as you like. This is a widely used pattern — Claude Code's own creators endorse worktrees for parallel sessions. The pain starts when you go past two or three agents: no routing between sessions, no shared memory, no budgets, and you become the coordination layer."+ - q: "What does an agent harness add over tmux plus shell scripts?"+ a: "The parts you'd otherwise build by hand: a router that moves messages between agents, an orchestrator that assigns and adjudicates work, shared long-term memory across sessions, per-agent token budgets with a circuit breaker, approval gates for destructive operations, triggers from Slack, webhooks, and schedules, and a live view of every agent instead of scrollback archaeology. Munder Difflin does all of this while still running the same CLI processes you'd run in tmux."+ - q: "Does using a harness mean giving up the terminal?"+ a: "No. In Munder Difflin every agent is still a real CLI process — claude, codex, copilot, and others — running in a genuine pseudo-terminal via node-pty. You can open any agent's live terminal and type into it directly, exactly like a tmux pane. The harness sits around the terminals, not instead of them."+ - q: "Is the DIY tmux approach ever the right choice?"+ a: "Often, yes. If you run one or two parallel sessions, review everything yourself, and don't need triggers or unattended operation, tmux plus worktrees is simple, transparent, and has zero new dependencies. The harness earns its keep when agents need to hand work to each other, run while you're away, remember across sessions, or stay inside a budget."+ - q: "Do tmux-based agents share memory between sessions?"+ a: "No. Each CLI session starts with a fresh context, and anything one agent learned dies with its scrollback unless you manually paste it into another session or a file. A harness like Munder Difflin gives every agent markdown-first long-term memory plus a shared semantic index, so what one agent learns is recallable by all of them across restarts."+ - q: "Is Munder Difflin free if I already pay for Claude Code?"+ a: "Yes. It's MIT-licensed and free, and it drives the CLI subscriptions you already have — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — so there's no extra platform fee on top of your existing model spend."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>tmux + git worktrees + shell scripts is a real, respectable way to run several Claude Code sessions in parallel</strong> — it's the setup half the community uses, and at two or three agents it's genuinely fine. What breaks at scale is everything <em>between</em> the panes: <strong>no routing, no shared memory, no budgets, no crash recovery, coordination via copy-paste, and scrollback archaeology to find out what happened overnight</strong>. An agent harness automates exactly that layer while still running the same CLI processes. <strong>Munder Difflin is, roughly, the tmux setup you would have built yourself after six months</strong> — free, open source, and local-first.</p></div>++Let's start by giving the DIY path its due, because it deserves it.++The standard recipe — tmux for sessions, [git worktrees](https://git-scm.com/docs/git-worktree) for isolation, a shell script to spin everything up, maybe cron for the nightly run — is not a hack. Worktrees give each agent its own working directory and branch while sharing one repository, so parallel sessions never fight over a checkout. tmux gives you named, detachable sessions that survive a closed laptop lid on a remote box. Boris Cherny, one of Claude Code's creators, has called parallel worktree sessions the ["single biggest productivity unlock"](https://www.mindstudio.ai/blog/claude-code-git-worktrees-parallel-branches), and Claude Code has since added native worktree support. Tools like [Claude Squad](https://github.com/smtg-ai/claude-squad) exist precisely because this pattern is popular enough to be worth wrapping in a TUI.++If you're running two agents on two branches and reviewing everything yourself, stop reading — you don't have a problem. The problem shows up when you try to make the panes into a *team*.++## What breaks at scale++**No routing.** tmux panes are strangers to each other. When agent A finishes the API change agent B is waiting on, nothing tells B. *You* notice, *you* copy the relevant output, *you* paste it into the other pane. You are the message bus, and the message bus goes to sleep at night. Community writeups on parallel sessions consistently land on the same ceiling — [two to three sessions is sustainable, five is cognitively expensive](https://www.codewithseb.com/blog/parallel-claude-code-sessions-git-worktrees-guide) — and the ceiling is you.++**No shared memory.** Each session starts cold. The bug agent A root-caused on Tuesday is unknown to agent B on Wednesday; the knowledge lives in a scrollback buffer that will eventually be truncated. There's no place where "things this project has learned" accumulates. (This is exactly the gap a [semantic memory layer](/blog/semantic-memory-for-ai-agents/) exists to fill.)++**No budgets, no brakes.** A looping agent in pane 4 will happily burn tokens until you happen to switch to pane 4. There's no per-agent budget, no circuit breaker, no gate before a destructive command — the safety rail is *hope* plus however often you cycle through panes.++**Scrollback archaeology.** "What did the fleet do overnight?" becomes an hour of `Ctrl+B [` and paging through six buffers, reconstructing a timeline by hand. There's no event log, no board, no cost attribution — just bytes.++**Crash recovery is manual.** A wedged session, a dead pane after a reboot, a cron job that fired while the machine slept — each is a small manual rebuild: recreate the worktree, relaunch the CLI, re-explain the task. Nothing [resumes or self-heals](/blog/recovering-from-agent-failures/).++**Cron is a trigger with no feedback loop.** Cron can start a session on a schedule, but it can't watch the result, retry a failure, or route the output anywhere. And there's no path at all from "a teammate posted in Slack" or "a webhook fired" to "an agent picked it up."++None of these are tmux's fault. tmux is a terminal multiplexer, and it's excellent at multiplexing terminals. Everything above is a *coordination* problem, and coordination is a different program — one you end up writing yourself, script by script, incident by incident.++## What a harness automates++This is the layer [Munder Difflin](/) is. Our landing page has a [full comparison table](/#compare), but it maps almost one-to-one onto the breakage list:++- **Routing and orchestration.** Agents get mailboxes; a router moves messages between them; a [GOD orchestrator](/blog/how-the-god-orchestrator-works/) assigns work, adjudicates, and escalates only what genuinely needs a human. Coordination by copy-paste becomes envelopes flying between desks — literally, on the office floor.+- **Worktrees, provisioned for you.** The same git-worktree isolation you'd script by hand is a toggle: each agent gets a dedicated worktree on spawn, torn down on kill. (Deeper dive: [worktrees vs the hive](/blog/claude-code-git-worktrees-vs-hive/).)+- **Shared long-term memory.** Markdown-first memory per agent, mined into a shared semantic index, recalled in milliseconds across sessions and restarts.+- **Budgets and brakes.** Per-agent token budgets, real token/cost telemetry, and a circuit breaker with a steer → constrain → stop ladder for loops and runaway spend — plus human approval gates on spend, scope, and destructive ops.+- **Observability instead of archaeology.** A live floor, a Command Center with a kanban board, an activity log, and OpenTelemetry spans per agent. The overnight question takes a glance, not an excavation.+- **Triggers with a feedback loop.** [Scheduled missions](/blog/scheduling-autonomous-agent-missions/) with a heartbeat, Slack ingress that replies in-thread, webhooks, voice — and wake-reliability hardening that catches up missed schedules and revives wedged terminals when the machine wakes.++Crucially, the terminals are still terminals. Every agent is the real CLI — Claude Code, Codex, Copilot CLI, and four others — running in a real pseudo-terminal you can pop open and type into, exactly like the pane you left behind.++## The honest framing++The DIY path isn't wrong; it's version one. Every feature above started life as somebody's shell script, and if you kept iterating on your tmux setup — add a router script, a memory file, a budget checker, a Slack bridge, a recovery script — you'd converge on a harness. Munder Difflin is that convergence, already built, MIT-licensed, and local-first, so the six months of scripting goes into your actual work instead.++If you're at two panes, enjoy them. If you're at five and tired of being the message bus, [download the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — and if it saves you a script or two, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) is appreciated.diff --git a/blog/src/posts/voice-as-a-control-plane-for-agent-fleets.md b/blog/src/posts/voice-as-a-control-plane-for-agent-fleets.mdnew file mode 100644index 00000000..5a93d469--- /dev/null+++ b/blog/src/posts/voice-as-a-control-plane-for-agent-fleets.md@@ -0,0 +1,75 @@+---+title: "Voice Is a Control Plane, Not a Gimmick"+description: "Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study."+date: 2026-07-03+category: concepts+categoryLabel: Concepts+type: Technical+primaryKeyword: "voice control for ai agents"+secondaryKeywords: ["voice agent orchestration", "talk to ai agents by voice", "openai realtime api agents", "voice commands for agent fleets", "hands-free agent orchestration", "voice approvals for ai agents"]+tags: ["Concepts", "Voice", "Orchestration", "Multi-Agent", "Human-in-the-Loop"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Why is voice bad for writing code but good for orchestrating agents?"+ a: "Because the bandwidth is mismatched in one direction and matched in the other. Code is dense, precise, and positional — dictating a diff by voice is slower and more error-prone than typing it. Orchestration commands are the opposite: short, intent-shaped utterances like assign this, what's the status, kill that worker. A sentence of intent fans out into minutes of agent work, so voice carries the command and the agents carry the density."+ - q: "What can you actually do by voice in Munder Difflin's Talk mode?"+ a: "Press Talk and you get a low-latency voice channel to the GOD orchestrator over the OpenAI Realtime API. Michael reads the hive — tasks, board, memory, agents, activity, cost — and can create and assign tasks, dispatch agents, pause, steer, halt, spawn or hire workers, kill them, and edit schedules. Destructive verbs are gated behind spoken echo-back confirmation, and completions are spoken back the moment they land."+ - q: "How does Talk mode prevent a misheard command from killing the wrong agent?"+ a: "Every destructive verb is held behind a spoken echo-back confirmation: Michael repeats the exact action back and requires a distinct confirm token, never a bare yes. There are also hard refusals — he will not kill the GOD agent or target all agents at once, no matter what he heard. Task matching by voice is normalized and scored, and close matches trigger a spoken which-one disambiguation instead of silently mutating the wrong card."+ - q: "Can a forgotten-open voice session run up a bill?"+ a: "No — that failure mode is engineered out. Voice sessions run under a live cost meter with a hard spend cap that auto-disconnects when hit, plus a configurable idle auto-disconnect (default 3 minutes) so an open mic in an empty room shuts itself off. Realtime voice is metered, so both guards exist precisely because the channel costs money while it is open."+ - q: "Are voice-issued actions auditable?"+ a: "Yes. Every action taken by voice is attributed to a distinct michael-voice actor in messages, the board, and the activity log, and it notifies the GOD terminal. A voice-driven dispatch never silently impersonates a worker or blends into typed commands — you can always tell, after the fact, which changes to the floor came in through the microphone."+ - q: "What do I need to use Talk mode?"+ a: "Your own OpenAI key with Realtime API access — it's bring-your-own-key, set in Settings → AI Engines. The key is decrypted only in the Electron main process and minted into short-lived ephemeral session tokens; it never reaches the renderer. Without a key the Talk button stays visibly disabled with a needs-OpenAI-key cue rather than failing silently."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Voice is a terrible interface for writing code and a genuinely good interface for running a fleet.</strong> The trick is bandwidth: code is high-bandwidth and precise, but orchestration — <strong>delegation, status, approvals</strong> — is a stream of short, intent-shaped commands that fan out into minutes of agent work. Munder Difflin's <strong>Talk mode</strong> (v0.3.2) is the case study: a realtime voice channel to the GOD orchestrator with <strong>spoken echo-back confirmation</strong> for destructive verbs, a distinct <strong>michael-voice</strong> audit identity, a <strong>hard spend cap</strong>, <strong>idle auto-disconnect</strong>, and <strong>completions spoken back</strong> the moment they land. Voice done as a control plane, not a party trick.</p></div>++Every few months someone demos "coding by voice" and the reaction is always the same: neat, and nobody wants it. Dictating a diff is strictly worse than typing one. So the whole category gets filed under gimmick, and that's a mistake — because the demo was testing voice against the wrong workload.++## The bandwidth argument++Think of any interface as a channel, and ask whether the channel's bandwidth matches the payload.++Code is a high-bandwidth, high-precision payload. It's dense with symbols, whitespace-sensitive, positional. Speaking it means serializing structure through a lossy audio channel and hoping transcription preserves `!==` versus `!=`. Typing wins. It's not close.++But **orchestration is a different payload entirely.** When you're running a fleet of agents, the things *you* actually emit are tiny:++- **Delegation** — "have someone fix the flaky auth test."+- **Status** — "what's Dwight working on? what's on the board?"+- **Approvals** — "yes, kill it" / "no, hold that."++Each of these is a sentence. Each fans out into minutes or hours of high-bandwidth work that the *agents* perform — reading files, running builds, writing diffs. That's the asymmetry that makes voice fit: **low-bandwidth commands over high-bandwidth work.** You supply intent; the fleet supplies density. It's the same division of labor a [GOD orchestrator](/blog/how-the-god-orchestrator-works/) already imposes on typed input — voice just removes the keyboard from the loop when the keyboard was barely being used anyway.++The other half of the fit: orchestration is naturally *ambient*. You're across the room while an overnight mission grinds. A status question shouldn't cost you a walk to the desk, and a completion shouldn't wait until you happen to glance at a terminal.++## Case study: Talk mode++Munder Difflin shipped this thesis as a feature in v0.3.2 (the [launch post](/blog/launching-munder-difflin-v0-3-2/) has the full tour). Press **Talk** and you get a low-latency voice channel — OpenAI Realtime API over WebRTC, bring-your-own key — to Michael, the GOD orchestrator, running *alongside* the async terminal floor, not replacing it.++Michael listens, answers, and acts. The read side covers the hive: tasks, board, memory, agents, activity, cost. The action side is the full orchestration verb set: create and assign tasks, dispatch agents, pause / steer / halt, spawn and hire workers, kill them, edit schedules. Notice what's *not* in that list: writing code. The voice channel never touches an editor. It only moves work around — exactly the payload the channel can carry.++And the loop closes in both directions. Voice-dispatched work reports back on its own: a completion watcher detects when a task lands and pushes the event into the live session so **Michael speaks it unprompted** — "respond when done" as a first-class behavior, with an on-screen toast, and a queue-to-notification path if the session is already closed. That's the ambient half delivered: you delegated by sentence, and the result comes back as a sentence.++## A control plane needs guardrails, not vibes++Here's where "control plane" stops being a metaphor and starts being an engineering standard. A microphone is a noisy, spoofable, mishearable input device wired to verbs like *kill*. If you treat that casually, you've built a gimmick with a blast radius. Talk mode's guardrails are the interesting part:++**Echo-back confirmation for destructive verbs.** Every destructive action is gated behind a *spoken* echo-back: Michael repeats exactly what he's about to do and requires a distinct confirm token — never a bare "yes," which a stray utterance could trip. On top of that sit hard refusals: he will not kill the GOD agent, and he will not target all agents at once, period. Even task *matching* is defensive — spoken phrases are normalized and scored against stored titles, and a close call triggers a spoken "which one?" instead of silently mutating the wrong card. This is the same discipline as any [human-in-the-loop approval gate](/blog/human-in-the-loop-approving-ai-agents/), adapted to a channel where the human's "click" is a phrase.++**michael-voice as a distinct actor.** Everything done by voice is attributed to a separate **michael-voice** identity in messages, the board, and the activity log, and it pings the GOD terminal. A voice dispatch is auditable and never impersonates a worker — which matters enormously when you're later reconstructing *why* the floor did something (the case for that paper trail is the whole [observability argument](/blog/observability-for-agent-fleets/)).++**Spend cap and idle disconnect.** Realtime voice is metered, so the session runs under a live cost HUD with a **hard spend cap** that auto-disconnects when hit, plus a configurable **idle auto-disconnect** (default 3 minutes) so a forgotten-open mic can't quietly run a bill. A control plane you're afraid to leave enabled isn't a control plane.++**Key hygiene.** It's BYOK, and the OpenAI key is decrypted main-process-only, minted into short-lived ephemeral session tokens — the real key never reaches the renderer. No key? The Talk button is visibly disabled with a "needs OpenAI key" cue instead of a dead click.++None of these guardrails would matter for a demo. All of them matter for a control plane you use daily — and the whole path (connect, ask, confirm, spawn, kill, dispatch, completion spoken back) was human-verified end-to-end on a real key before it shipped.++## The takeaway++Judge voice by the payload you put on it. As an authoring channel for code, it loses to a keyboard every time. As a **control plane** for a fleet — delegation, status, approvals, completions — it's the natural interface, *provided* it's built like infrastructure: confirmations for anything destructive, a distinct audit identity, caps on spend, and a timeout on silence. That's the difference between a gimmick and a plane you'd actually fly.++If you want to try the case study, [download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — free, MIT-licensed, local-first — and if the idea resonates, a [star on GitHub](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/blog/src/posts/what-is-an-agent-development-environment.md b/blog/src/posts/what-is-an-agent-development-environment.mdnew file mode 100644index 00000000..a9233e78--- /dev/null+++ b/blog/src/posts/what-is-an-agent-development-environment.md@@ -0,0 +1,77 @@+---+title: "What Is an Agent Development Environment (ADE)?"+description: "ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick."+date: 2026-07-03+category: concepts+categoryLabel: Concepts+type: Non-technical+primaryKeyword: "agent development environment"+secondaryKeywords: ["what is an ADE", "agentic development environment", "agent IDE vs agent CLI", "multi-agent coding tools 2026", "agent harness vs ADE", "parallel coding agents"]+tags: ["Concepts", "ADE", "Multi-Agent", "Tooling Landscape", "CLI Agents"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is an Agent Development Environment (ADE)?"+ a: "The term has two meanings in 2026. In Letta's original sense, an ADE is a platform for building and debugging AI agents themselves — inspecting context windows, memory, and reasoning. In the coding-tools sense that Orca popularized, an ADE is a desktop workspace for running multiple coding agents in parallel, each in its own isolated git worktree, with the tooling to review and ship what they produce. Most people saying ADE today mean the second sense."+ - q: "How is an ADE different from an AI IDE like Cursor?"+ a: "An AI IDE is editor-first: you write and steer, and agents assist inside your editing session — Cursor's Agent mode, Composer, and background agents all orbit the file you have open. An ADE is agent-first: the primary objects on screen are agents and their tasks, not files, and you delegate whole goals rather than steering each step. The rough inflection point is when work spans many files or needs several agents running in parallel."+ - q: "Is Munder Difflin an ADE?"+ a: "It's adjacent but a different category: a multi-agent harness, or an agent office. Like an ADE it runs many real CLI agents in parallel worktrees. Unlike most ADEs it adds an orchestrator agent (Michael) that routes work between agents, shared long-term memory, mailboxes so agents message each other, triggers (Slack, webhooks, schedules, voice), and guardrails like budgets, approval gates, and a circuit breaker. An ADE optimizes for you driving N agents; a harness optimizes for the agents coordinating each other while you supervise."+ - q: "Why did Munder Difflin add an IDE if it's not an ADE?"+ a: "Because whatever runs your agents, you still need to read what they wrote. v0.3.3 added a built-in Monaco editor (the VS Code editor engine, self-hosted) over the office floor: a file tree, editor tabs with save, and a side-by-side git diff of every agent change against HEAD. It's a review surface inside the harness, not a pivot to being an editor — the floor, orchestrator, and hive remain the product."+ - q: "Do agent CLIs like Claude Code and Codex compete with ADEs?"+ a: "No — they're the layer underneath. Claude Code and OpenAI Codex CLI are single-agent terminal programs, and they're what ADEs and harnesses actually run. Orca runs your existing CLI agents in parallel worktrees; Munder Difflin spawns them as real node-pty processes and coordinates them. Your CLI subscription is the engine; the ADE or harness is the chassis around it."+ - q: "How do I choose between a chat IDE, an agent CLI, an ADE, and a harness?"+ a: "Match the tool to how much you delegate. Staying in the loop on one change: an AI IDE. Delegating one task end-to-end: an agent CLI. Personally driving several agents in parallel on one repo: an ADE. Running an always-on team that routes work among itself, shares memory, and answers triggers while you supervise: a multi-agent harness like Munder Difflin."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>"ADE" means two different things in 2026.</strong> Letta coined <em>Agent Development Environment</em> for a platform to <strong>build and debug agents themselves</strong>. The coding world then adopted it for something else: a workspace for <strong>shipping software with fleets of coding agents</strong> — Orca is the flagship example. The map now has four layers: <strong>AI IDEs</strong> (Cursor — editor-first, you steer), <strong>agent CLIs</strong> (Claude Code, Codex — one agent, one terminal, full delegation), <strong>agent IDEs / ADEs</strong> (Orca, JetBrains Air — you drive N parallel agents), and <strong>agent harnesses</strong> (Munder Difflin — the agents coordinate <em>each other</em> under an orchestrator, with shared memory, triggers, and guardrails). The categories are blurring from every direction — v0.3.3 even put a Monaco IDE <em>inside</em> the harness — but the question that picks your tool hasn't changed: <strong>how much are you delegating?</strong></p></div>++Every few months the agent-tooling world mints a new acronym, and 2026's is **ADE**. It's a genuinely useful term — once you notice it's being used for two different things.++## Two meanings, one acronym++The original coinage belongs to [Letta](https://www.letta.com/blog/introducing-the-agent-development-environment), which uses *Agent Development Environment* for a visual platform to **build and debug agents themselves**: inspect an agent's context window, edit its memory blocks, watch its reasoning, wire its tools. In that sense, an ADE is to agents what an IDE is to code — the artifact under development *is the agent*.++Then the coding-tools world borrowed the acronym for something adjacent but distinct. [Orca](https://github.com/stablyai/orca) calls itself "the ADE for working with a fleet of parallel agents," and [Augment Code's guides](https://www.augmentcode.com/guides/what-is-an-agentic-development-environment) describe an *agentic development environment* as an agent-first workspace where developers delegate whole goals instead of steering an editor. In this sense the artifact under development is still **your software** — the ADE is where a fleet of coding agents builds it.++Most people saying "ADE" in a dev-tools context mean the second sense. That's the sense this post maps.++## The 2026 landscape: four layers of delegation++The clean way to sort the tools is not by feature list but by **how much you hand over**.++**1. AI IDEs — you steer every step.** [Cursor](https://cursor.com/) is the archetype: an editor-first workspace where agents live inside your editing session. Its Agent mode reads the codebase, edits files, runs commands, and iterates; Composer produces reviewable multi-file diffs; background and cloud agents run tasks off to the side. It's excellent at what it optimizes for — a developer who stays in the loop, file by file, with agents as force multipliers. The center of gravity is still *you, in an editor*.++**2. Agent CLIs — you delegate one task.** [Claude Code](https://claude.com/claude-code) and [OpenAI Codex CLI](https://github.com/openai/codex) are single-agent terminal programs: give one a goal and it reads files, runs builds and tests, uses git, and verifies its own work by executing it. This is the layer with real terminal-level power — we wrote about [why CLI agents are so capable](/blog/why-cli-agents-are-powerful/) — but each session is one agent, one terminal, one task.++**3. Agent IDEs / ADEs — you drive N agents in parallel.** Once you're running four CLI sessions at once, tab-juggling breaks down, and this is the gap ADEs fill. Orca runs your existing CLI agents — Claude Code, Codex, and others, on your own subscriptions — in parallel, each task in an **isolated git worktree** with its own terminal and context, plus review tooling to merge the results. JetBrains is in the same lane with Air, a standalone multi-agent workspace. The defining trait: *you* are still the dispatcher. You assign every task, watch every lane, and merge every result.++**4. Agent harnesses / offices — the agents coordinate each other.** This is where **Munder Difflin** sits, and it's a different bet. Like an ADE, it runs real CLI agents (seven engines as of v0.3.3, including GitHub Copilot CLI) in isolated worktrees and real pseudo-terminals. Unlike an ADE, you don't dispatch to each agent yourself: a GOD orchestrator — Michael — routes work, agents message each other through mailboxes, share [long-term semantic memory](/blog/semantic-memory-for-ai-agents/), and get woken by triggers — typing, Slack, webhooks, schedules, even voice. Guardrails (approval gates, per-agent budgets, a circuit breaker, OTel observability) make it safe to leave running. The mental model isn't "my editor got agents" or "my agents got lanes" — it's *an office you supervise*. We've written a fuller definition in [what is a multi-agent harness](/blog/what-is-a-multi-agent-harness/).++## Where the categories blur++Nobody stays in their lane, and the direction of travel is telling.++Cursor grew a CLI and cloud agents — the editor reaching toward delegation. ADEs like Orca embed browsers and diff tooling — the dispatcher growing verification surfaces. And Munder Difflin's v0.3.3 added a **built-in Monaco IDE** — the VS Code editor engine, self-hosted, one click over the office floor, with a file tree, tabs, and side-by-side git diffs of every agent change against HEAD. A harness growing an editor, precisely because the bottleneck in agent-heavy work shifts from *writing* code to *reviewing* it.++Everyone is converging on the same shape: **many agents, isolated workspaces, and a first-class place to review what they did.** The categories differ in what they treat as the primary object — the file (IDE), the task (CLI), the lane (ADE), or the *team* (harness).++## How to choose++Match the tool to your delegation level, not the hype cycle:++- Reviewing every edit as it happens → an **AI IDE**.+- Handing off one well-scoped task → an **agent CLI**.+- Personally running several parallel agents on one repo → an **ADE**.+- Running an always-on team that routes its own work while you supervise → a **harness**.++These stack rather than compete — Orca and Munder Difflin both *run* Claude Code and Codex; your CLI subscription is the engine either way. For a decision framework with sharper questions (team size, autonomy appetite, budget controls), see [how to choose a multi-agent tool](/blog/how-to-choose-a-multi-agent-tool/).++And if the office model sounds like your level of delegation: Munder Difflin is free, MIT-licensed, and local-first — [grab the latest release](https://github.com/chaitanyagiri/munder-difflin/releases/latest), and if it earns it, a [GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.++Sources: [Letta — Introducing the Agent Development Environment](https://www.letta.com/blog/introducing-the-agent-development-environment);+[Orca (stablyai/orca)](https://github.com/stablyai/orca); [Orca — onorca.dev](https://www.onorca.dev/);+[Augment Code — What is an agentic development environment?](https://www.augmentcode.com/guides/what-is-an-agentic-development-environment);+[Cursor](https://cursor.com/); [OpenAI Codex CLI](https://github.com/openai/codex).diff --git a/blog/src/posts/what-is-harness-engineering.md b/blog/src/posts/what-is-harness-engineering.mdnew file mode 100644index 00000000..3aac818f--- /dev/null+++ b/blog/src/posts/what-is-harness-engineering.md@@ -0,0 +1,77 @@+---+title: "What Is Harness Engineering?"+description: "Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin."+date: 2026-07-03+category: concepts+categoryLabel: Concepts+type: Technical+primaryKeyword: "harness engineering"+secondaryKeywords: ["what is harness engineering", "agent harness", "ai agent reliability", "the model is a commodity", "agent infrastructure", "multi-agent harness"]+tags: ["Concepts", "Harness Engineering", "Reliability", "Multi-Agent", "Architecture"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is harness engineering?"+ a: "Harness engineering is the discipline of building the environment around an AI model that turns it into a reliable agent: the process plumbing, lifecycle hooks, message routing, memory, budgets, human approval gates, observability, and recovery mechanics. The working equation is agent = model + harness. The model supplies raw capability; the harness determines whether that capability shows up predictably, safely, and repeatably in production."+ - q: "Who coined the term harness engineering?"+ a: "The term was popularized by Mitchell Hashimoto, co-founder of HashiCorp, in a February 2026 blog post about his AI adoption journey. His core premise: any time an agent makes a mistake, you engineer a solution so the agent never makes that mistake again. The 2026 agent-engineering discourse has since adopted it as the phase that follows prompt engineering and context engineering."+ - q: "Why is the harness more important than the model?"+ a: "Because models are increasingly interchangeable commodities and their failure modes are structural, not intelligence-limited. An agent that loops, forgets, overspends, or silently drops a message doesn't need a smarter model — it needs a circuit breaker, a memory layer, a budget, and a mailbox with delivery guarantees. Reported results back this up: teams have climbed agent benchmarks significantly by changing only the harness, with the model held constant."+ - q: "What are the components of an agent harness?"+ a: "A production harness typically covers: real execution plumbing (PTYs or sandboxes the agent acts through), lifecycle hooks (structured signals for turn start/end and tool use), inter-agent messaging with delivery guarantees, long-term memory, token budgets and cost controls, human-in-the-loop gates for destructive or expensive actions, observability (traces, costs, per-agent telemetry), and session resume so a restart doesn't destroy state."+ - q: "Is harness engineering the same as prompt engineering?"+ a: "No, but it absorbs it. Prompt engineering shapes a single model call; context engineering shapes what the model sees across a task; harness engineering shapes the entire system the model operates inside — including what happens when a call fails, a process dies, a budget is exceeded, or two agents need to hand off work. Prompts are one component of the harness, not a substitute for it."+ - q: "Is Munder Difflin a harness?"+ a: "Yes — that's the category. Munder Difflin is a free, MIT-licensed, local-first multi-agent harness: it wraps the agent CLIs you already run (Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, GitHub Copilot CLI) in node-pty pseudo-terminals, wires them into a hive with mailboxes, shared memory, budgets, a circuit breaker, human approval gates, and observability, and puts a GOD orchestrator in charge."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Harness engineering is the discipline of building everything around the model</strong> — the PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability, and session resume that turn a capable model into a <strong>reliable agent</strong>. The 2026 consensus, popularized by Mitchell Hashimoto: <strong>the model is a commodity; the harness is where reliability comes from</strong>. Every time an agent fails, you engineer the harness so that failure becomes structurally impossible. Munder Difflin is this discipline shipped as a product — and its hook shim, node-pty layer, MemPalace, and circuit breaker are worked examples.</p></div>++Ask why an agent failed and you'll almost never hear "the model wasn't smart enough." You'll hear: it looped for forty minutes, it forgot what it learned yesterday, it blew the budget overnight, it dropped a message and nobody noticed, the process died and took the session with it.++None of those are model problems. All of them are **harness problems**. And in 2026, fixing them got a name.++## The term, and where it came from++**Harness engineering** was popularized by Mitchell Hashimoto (co-founder of HashiCorp) in a February 2026 post on [his AI adoption journey](https://mitchellh.com/writing/my-ai-adoption-journey). His formulation is disarmingly simple: *any time you find an agent makes a mistake, you take the time to engineer a solution such that the agent never makes that mistake again.* Not a better prompt. Not a smarter model. A structural fix in the environment the agent operates in, so the failure class is closed permanently.++The broader discourse picked the term up fast, and a rough consensus formed: harness engineering is the **third phase of agent-engineering maturity** — after prompt engineering (shape one call) and context engineering (shape what the model sees), you shape *the entire system the model operates inside*. Industry write-ups like [Faros AI's guide](https://www.faros.ai/blog/harness-engineering) converge on the same anatomy — tool orchestration, verification loops, context and memory, guardrails, observability — and point at the evidence that motivates it: teams have jumped whole leaderboards on agent benchmarks (Faros cites LangChain climbing Terminal Bench 2.0 from 30th to 5th) **without changing the model at all**. Same model, different harness, different outcome.++That's the whole thesis in one line: **the model is a commodity input; the harness is the differentiated system.** Frontier models leapfrog each other every quarter, and every serious agent product supports several of them interchangeably. What doesn't come off a shelf is the machinery that makes any of them dependable.++## What a harness actually contains++Strip the buzzwords and a production harness is a specific list of unglamorous subsystems:++- **Execution plumbing.** A real place for the agent to act — a pseudo-terminal, a sandbox, a worktree — not a simulated one.+- **Lifecycle hooks.** Structured signals for turn start, turn end, and tool use, so the harness *knows* what the agent is doing rather than guessing from stdout.+- **Mailboxes and routing.** Inter-agent messages with delivery guarantees; a dropped handoff must bounce somewhere visible, never vanish.+- **Memory.** Durable, recallable knowledge that survives the session, so agents stop re-deriving the same facts.+- **Budgets and breakers.** Hard ceilings on tokens and cost, plus a mechanism that intervenes when an agent runs away.+- **Human gates.** Approval checkpoints on spend, scope changes, and destructive operations — human-in-the-loop by design.+- **Observability.** Traces, per-agent cost attribution, live telemetry — [you can't operate a fleet you can't see](/blog/observability-for-agent-fleets/).+- **Session resume.** A restart — of the app, the machine, or one agent — must reattach state, not destroy it.++Notice what's absent: anything about making the model smarter. Harness engineering takes model capability as given and engineers everything else. (For how this differs from a single-agent wrapper, see [what a multi-agent harness is](/blog/what-is-a-multi-agent-harness/).)++## Four case studies from inside Munder Difflin++Munder Difflin is this discipline shipped as a product, so its internals make good worked examples.++**The hook shim — lifecycle truth instead of stdout guessing.** Every provider speaks lifecycle differently: Claude Code has native hooks, Antigravity needed a purpose-built `agy-hook` bridge, Codex gets the protocol injected as its initial prompt. The harness normalizes all of them into one hook server (`hooks.ts`) that receives structured POST payloads — so "the agent finished its turn" is a *signal*, not an inference from a quiet terminal. And where a provider has no bridge at all, the harness engineers around the gap honestly: GitHub Copilot CLI's print mode can't drain an inbox, so routed mail **bounces to the GOD orchestrator** instead of silently dropping. That is Hashimoto's rule applied — the "silently lost message" failure class is closed structurally.++**node-pty — real terminals, not string simulations.** Each agent is a real CLI process in its own pseudo-terminal, byte-for-byte authentic, with full read/write/resize/kill — paired with per-agent git worktrees so agents never collide on branches. The unglamorous plumbing (a `PtyManager`, per-id IPC streams, a postinstall that rebuilds the native addon against Electron's ABI) is exactly the kind of work the model can never do for you, and exactly what makes the agent's terminal access *real*.++**MemPalace — memory as infrastructure.** Agents write markdown-first long-term memory, mined into a shared semantic index for instant recall, with a MemoryReflector that condenses it so it doesn't grow without bound. "The agent forgot" stops being a shrug and becomes a subsystem with behavior you can engineer — the deep dive is in [semantic memory for AI agents](/blog/semantic-memory-for-ai-agents/).++**The circuit breaker — graduated intervention, not a kill switch.** The cost/runaway guard runs a **steer → constrain → stop** ladder: nudge an agent that's looping, constrain it if it persists, stop it if it storms errors or blows its per-agent token budget. Paired with approval gates on spend and destructive ops, this is what makes 24/7 autonomy something you can actually sleep through — part of the larger practice of [building reliable AI agents](/blog/building-reliable-ai-agents/).++## Why this is a discipline, not a feature list++The pattern across all four: **reliability was engineered into the environment, not prompted into the model.** Each subsystem exists because a specific failure mode exists, and each closes that failure mode for every model, every provider, permanently. Swap Claude for Codex or a local model tomorrow — the breaker still breaks, the mail still routes, the memory still recalls. That's what "the model is a commodity" means in practice: the harness is the part that compounds.++If you want to see a harness rather than read about one, [download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — free, MIT-licensed, local-first — and if the idea resonates, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.++Sources: [Mitchell Hashimoto — My AI Adoption Journey](https://mitchellh.com/writing/my-ai-adoption-journey);+[Faros AI — Harness Engineering: Making AI Coding Agents Work in 2026](https://www.faros.ai/blog/harness-engineering).diff --git a/blog/src/posts/your-first-hour-with-munder-difflin.md b/blog/src/posts/your-first-hour-with-munder-difflin.mdnew file mode 100644index 00000000..1f2d90fd--- /dev/null+++ b/blog/src/posts/your-first-hour-with-munder-difflin.md@@ -0,0 +1,84 @@+---+title: "Your First Hour With Munder Difflin"+description: "A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running."+date: 2026-07-03+category: guides+categoryLabel: Guides+type: Non-technical+primaryKeyword: "munder difflin onboarding"+secondaryKeywords: ["getting started with munder difflin", "multi-agent harness tutorial", "first hour with a multi-agent harness", "god orchestrator first brief", "ai agent approval queue", "scheduled agent missions"]+tags: ["Guides", "Onboarding", "Getting Started", "Multi-Agent", "Local-First"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "How long does it take to get Munder Difflin running?"+ a: "About five minutes if you already have Node.js 18+ and one supported agent CLI installed. You clone the repo, run npm install and npm run dev, and the onboarding wizard walks you through the rest: harness home, registered repos, default command, and auto-mode. Signed macOS, Windows, and Linux builds are also available on the releases page."+ - q: "What do I need before installing Munder Difflin?"+ a: "Node.js 18+ with npm, a C/C++ toolchain for node-pty's native addon (Xcode Command Line Tools on macOS), and at least one supported terminal-agent CLI on your PATH — Claude Code, Antigravity, OpenAI Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. If a chosen engine's binary is missing, the harness runs its installer in the terminal and restarts into it automatically."+ - q: "Who is Michael and how do I give him work?"+ a: "Michael is the GOD orchestrator — the one agent you talk to. You type a brief into his terminal (or use the Talk voice channel with your own OpenAI Realtime key) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in Michael's office automatically on first launch."+ - q: "Do I have to approve everything the agents do?"+ a: "No. The GOD orchestrator resolves routine requests itself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest."+ - q: "How do I review what an agent actually changed?"+ a: "Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD — the VS Code editor engine, fully self-hosted, with all filesystem and git access brokered through the main process. There's also a per-agent git tab with status, log, and commit graph."+ - q: "Can Munder Difflin keep working after I walk away?"+ a: "Yes — that's the point. The Schedules tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs 24/7 on hardware you already own."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>You can go from zero to a running AI office in one hour.</strong> Minute 0: install. Minute 5: the <strong>onboarding wizard</strong> (harness home, repos, auto-mode, orchestrator engine). Minute 10: your <strong>first brief to Michael</strong>, the GOD orchestrator. Minute 20: watch avatars work the floor and open a real desk terminal. Minute 40: your <strong>first approval</strong> and a side-by-side diff in the built-in <strong>Monaco IDE</strong>. Minute 60: set a <strong>schedule</strong> and walk away — the office keeps working.</p></div>++<video controls preload="none" playsinline poster="/media/demo/intro-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/intro.mp4" type="video/mp4" />+</video>++Most tools ask you to learn them before they do anything. Munder Difflin is the other kind: within an hour you've briefed an orchestrator, watched agents work, approved a real change, and left the office running without you. Here's that hour, minute by minute.++## Minute 0 — Install++Two paths: grab a signed build (macOS, Windows, Linux) from the [releases page](https://github.com/chaitanyagiri/munder-difflin/releases/latest), or clone and run from source with `npm install && npm run dev`. You need Node.js 18+, a C/C++ toolchain for `node-pty`, and at least one supported agent CLI on your `PATH` — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI.++I won't repeat the details here; the [install and usage guide](/blog/how-to-install-and-use-munder-difflin/) covers prerequisites, troubleshooting, and the `node-pty` rebuild gotcha. Budget five minutes.++## Minute 5 — The onboarding wizard++First launch drops you into a short wizard, and the four choices it asks for are the actual shape of the product:++- **Harness home** — the folder where the hive lives: per-agent memory, mailboxes, the blackboard, the event log. Plain files in a local git repo, relocatable later.+- **Registered repos** — the codebases your agents will work on. This is what feeds GitHub issue ingestion and the CI watcher later.+- **Default command / auto-mode** — which agent CLI new hires run by default, and whether the floor runs in auto-mode (agents proceed without per-tool prompts; the approval gate still catches critical items).+- **Orchestrator engine** — Michael himself runs on a pluggable engine. Claude Code is the natural default, but the wizard lets you pick, and you can change it later.++Finish the wizard and you land on the floor: a pixel-art office, empty except for Michael, who seats himself in his office automatically.++## Minute 10 — Your first brief to Michael++You don't manage the workers. You talk to one agent — the GOD orchestrator — and he runs the floor. Click into Michael's terminal and type a brief the way you'd brief a colleague: what you want, which repo, what "done" looks like.++Michael adjudicates. He creates tasks on the kanban, assigns them, and routes messages between agent inboxes. Workers you hire via **Add agent** each get a real CLI process in its own pseudo-terminal and, with the git-isolation toggle, their own worktree — so nobody collides on branches. How he decides what to route, resolve, or escalate is its own post: [how the GOD orchestrator works](/blog/how-the-god-orchestrator-works/).++A good first brief is small and self-contained: "read this repo and write a REPORT.md summarizing the architecture" beats "refactor everything" for hour one.++## Minute 20 — Watch the floor, then open a desk++Now the part that makes the product legible: the floor is not a decoration, it's the state of the system. Avatars walk to stations as they work. When the hive routes a message, an envelope flies from sender to recipient; escalations fly to the door. The cast is an affectionate parody of The Office, and every movement maps to a real event.++Click any agent and you get their desk: the live terminal (you can type back into it), a sandboxed file browser, and a git tab with status, log, and commit graph. This is the moment the abstraction clicks — that avatar is a real `claude` process, and you're reading its actual stdout.++## Minute 40 — Your first approval, and the diff++Sometime in the first hour, something lands in the approvals queue — a spend threshold, a destructive operation, a scope change. This is by design: Michael resolves routine requests himself and escalates only critical items, so the queue stays short and every item in it deserves your attention. (The philosophy behind that gate: [approving AI agents without babysitting them](/blog/human-in-the-loop-approving-ai-agents/).)++Before you click approve, look at the work. Hit the title-bar **IDE** button and the built-in Monaco editor — the VS Code editor engine, fully self-hosted — opens over the floor. The git CHANGES rail lists what changed; click a file for a read-only side-by-side diff against HEAD. Read the diff, approve the item, watch the envelope fly.++## Minute 60 — Leave it running++The last move of the hour is the one that changes your relationship with the tool: schedule something. The Command Center's **Schedules** tab takes a label, an interval, a target agent, and a mission body — "every morning, triage new GitHub issues," say — and a heartbeat re-engages the floor if it goes quiet. Last-fired and next-fired times are right there in the tab.++Close the laptop. It's local-first, so tomorrow the office is exactly where you left it — probably with mail in your queue. For patterns on what's worth automating, see [scheduling autonomous agent missions](/blog/scheduling-autonomous-agent-missions/).++## The hour, in one line++Install, answer four wizard questions, brief one agent, watch the floor, read one diff, set one schedule — and you've gone from "a CLI in a terminal" to "an office that works while you don't."++[Download Munder Difflin](https://github.com/chaitanyagiri/munder-difflin/releases/latest) — free, MIT-licensed, local-first — and if the first hour earns it, [a GitHub star](https://github.com/chaitanyagiri/munder-difflin) helps more people find it.diff --git a/docs/blog/agent-security-and-sandboxing/index.html b/docs/blog/agent-security-and-sandboxing/index.htmlindex 23a78de5..7151d23e 100644--- a/docs/blog/agent-security-and-sandboxing/index.html+++ b/docs/blog/agent-security-and-sandboxing/index.html@@ -271,56 +271,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/agents-rule-of-two/index.html b/docs/blog/agents-rule-of-two/index.htmlindex aee6bc43..b4ba9b1d 100644--- a/docs/blog/agents-rule-of-two/index.html+++ b/docs/blog/agents-rule-of-two/index.html@@ -275,56 +275,56 @@ open source.</p><h2>Related in Concepts</h2><div class="post-grid"><article class="card">- <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/ai-agent-glossary/index.html b/docs/blog/ai-agent-glossary/index.htmlindex 215a0c09..8965a200 100644--- a/docs/blog/ai-agent-glossary/index.html+++ b/docs/blog/ai-agent-glossary/index.html@@ -247,56 +247,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/best-ai-coding-agents/index.html b/docs/blog/best-ai-coding-agents/index.htmlindex 1a94e3ba..1b8e2140 100644--- a/docs/blog/best-ai-coding-agents/index.html+++ b/docs/blog/best-ai-coding-agents/index.html@@ -319,56 +319,56 @@ source.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/claude-code-orchestration-tools-compared/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-orchestration-tools-compared/">Claude Code Orchestration Tools, Compared</a></h3>- <p class="dek">Claude Code orchestration tools compared on memory, messaging, visibility, control, and local-first — across Claude Squad, Conductor, Crystal, and more.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/claude-code-orchestration-tools-compared/" aria-label="Read: Claude Code Orchestration Tools, Compared">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/best-claude-code-multi-agent-tools/index.html b/docs/blog/best-claude-code-multi-agent-tools/index.htmlindex d2914ace..84d8b5fe 100644--- a/docs/blog/best-claude-code-multi-agent-tools/index.html+++ b/docs/blog/best-claude-code-multi-agent-tools/index.html@@ -354,56 +354,56 @@ real team of agents.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/claude-code-orchestration-tools-compared/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-orchestration-tools-compared/">Claude Code Orchestration Tools, Compared</a></h3>- <p class="dek">Claude Code orchestration tools compared on memory, messaging, visibility, control, and local-first — across Claude Squad, Conductor, Crystal, and more.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/claude-code-orchestration-tools-compared/" aria-label="Read: Claude Code Orchestration Tools, Compared">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/building-reliable-ai-agents/index.html b/docs/blog/building-reliable-ai-agents/index.htmlindex f66728f8..0cdb148c 100644--- a/docs/blog/building-reliable-ai-agents/index.html+++ b/docs/blog/building-reliable-ai-agents/index.html@@ -302,56 +302,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex 201864d5..e5119ead 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@@ -285,56 +285,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex c46ea712..db6cf9e2 100644--- a/docs/blog/claude-code-automation-while-you-sleep/index.html+++ b/docs/blog/claude-code-automation-while-you-sleep/index.html@@ -290,56 +290,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex da7509ad..97415c5a 100644--- a/docs/blog/claude-code-multi-agent-setup-tutorial/index.html+++ b/docs/blog/claude-code-multi-agent-setup-tutorial/index.html@@ -279,56 +279,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/claude-code-orchestration-tools-compared/index.html b/docs/blog/claude-code-orchestration-tools-compared/index.htmlindex af24e0e5..be18b54e 100644--- a/docs/blog/claude-code-orchestration-tools-compared/index.html+++ b/docs/blog/claude-code-orchestration-tools-compared/index.html@@ -276,56 +276,56 @@ Linux.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">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.htmlindex 2fee50b4..db1a420f 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@@ -319,56 +319,56 @@ open source.</p><h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/claude-squad-alternative/index.html b/docs/blog/claude-squad-alternative/index.htmlindex 65e65400..236d36c2 100644--- a/docs/blog/claude-squad-alternative/index.html+++ b/docs/blog/claude-squad-alternative/index.html@@ -214,56 +214,56 @@ on macOS, Windows, and Linux.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/claude-squad-vs-munder-difflin/index.html b/docs/blog/claude-squad-vs-munder-difflin/index.htmlindex ed95f025..a2168466 100644--- a/docs/blog/claude-squad-vs-munder-difflin/index.html+++ b/docs/blog/claude-squad-vs-munder-difflin/index.html@@ -301,56 +301,56 @@ local-first.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/cline-vs-munder-difflin/index.html b/docs/blog/cline-vs-munder-difflin/index.htmlindex 0f8bc20c..140fc7b7 100644--- a/docs/blog/cline-vs-munder-difflin/index.html+++ b/docs/blog/cline-vs-munder-difflin/index.html@@ -292,56 +292,56 @@ licensed.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/claude-code-orchestration-tools-compared/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-orchestration-tools-compared/">Claude Code Orchestration Tools, Compared</a></h3>- <p class="dek">Claude Code orchestration tools compared on memory, messaging, visibility, control, and local-first — across Claude Squad, Conductor, Crystal, and more.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/claude-code-orchestration-tools-compared/" aria-label="Read: Claude Code Orchestration Tools, Compared">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/command-center-guide/index.html b/docs/blog/command-center-guide/index.htmlnew file mode 100644index 00000000..2553f32b--- /dev/null+++ b/docs/blog/command-center-guide/index.html@@ -0,0 +1,339 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>The Command Center: Kanban, Fleet, and Budgets in One Place — Munder Difflin Blog</title>+<meta name="description" content="A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor." />+<link rel="canonical" href="https://munderdiffl.in/blog/command-center-guide/" />++<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 Command Center: Kanban, Fleet, and Budgets in One Place — Munder Difflin Blog" />+<meta property="og:description" content="A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor." />+<meta property="og:url" content="https://munderdiffl.in/blog/command-center-guide/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Command Center" />+<meta property="article:tag" content="Kanban" />+<meta property="article:tag" content="Cost" />+<meta property="article:tag" content="Observability" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="The Command Center: Kanban, Fleet, and Budgets in One Place — Munder Difflin Blog" />+<meta name="twitter:description" content="A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<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 Command Center: Kanban, Fleet, and Budgets in One Place",+ "description": "A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/command-center-guide/" },+ "keywords": "ai agent command center, agent task kanban, monitor ai agent fleet, per-agent token budgets, ai agent cost tracking, multi-agent dashboard",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/command-center-guide/"+}+</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 Command Center: Kanban, Fleet, and Budgets in One Place", "item": "https://munderdiffl.in/blog/command-center-guide/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is the Command Center in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "It's Michael's control surface — the management view of the whole hive. It has tabs for the orchestrator Terminal, the Floor (roster, dispatch, per-agent model selector, live fleet monitoring), Memory (semantic search plus a memory graph), Activity (event log, board, real token telemetry, observability, and a CI watcher), Tasks (a dependency-aware kanban board), and Schedules (recurring missions with last/next-fired times)." } },+ { "@type": "Question", "name": "How does the task kanban work?", "acceptedAnswer": { "@type": "Answer", "text": "The Tasks tab is a dependency-aware kanban board. You assign tasks to agents and track them across todo, doing, blocked, and done. Because tasks can declare dependencies, downstream work waits until its prerequisites finish, so a chain of related tasks starts in the right order without you babysitting the handoffs." } },+ { "@type": "Question", "name": "How do per-agent budgets and cost tracking work?", "acceptedAnswer": { "@type": "Answer", "text": "You set a token budget per agent, and live fleet monitoring tracks consumption across the roster. Cost numbers are real, not estimates from vibes: the Activity tab reads the JSONL transcripts Claude Code writes and surfaces actual token counts plus estimated USD cost per agent per session, backed by a durable cost ledger that survives restarts. The budget pairs with a circuit breaker that steers, then constrains, then stops an agent that loops or blows its cap." } },+ { "@type": "Question", "name": "When should I watch the office floor versus the Command Center?", "acceptedAnswer": { "@type": "Answer", "text": "The floor is for ambient awareness and single-agent moments — seeing who's working, watching envelopes fly, dropping into one terminal. The Command Center is for management questions: what's queued and blocked, what each agent has spent, whether CI is green, and what fires next on the schedule. Roughly: floor for one agent right now, board for the whole fleet over time." } },+ { "@type": "Question", "name": "Does the Command Center include observability?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The Activity tab includes a live OpenTelemetry collector with per-model cost attribution, a fleet grid, and a per-agent tool-span waterfall, so you can see exactly what every agent is doing and what it costs in real time. Each agent card also carries a context-window gauge showing how much of the model's context that agent has consumed." } },+ { "@type": "Question", "name": "Can the Command Center pull in work from GitHub?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. You can ingest open issues from any registered repo via the gh CLI and assign them to agents with one click, and a CI status watcher shows live pass/fail/in-progress state for GitHub Actions runs in the Activity tab. Work flows in from GitHub, gets tracked on the kanban, and its CI result lands back in the same view." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>The Command Center: Kanban, Fleet, and Budgets in One Place</h1>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>The office floor is fun to watch, but you don't manage a team by staring at desks. Munder Difflin's <strong>Command Center</strong> is the management view: a <strong>dependency-aware task kanban</strong>, <strong>live fleet monitoring with per-agent token budgets</strong>, <strong>real cost telemetry</strong> backed by a durable ledger, <strong>OpenTelemetry observability</strong> with a per-agent tool-span waterfall, plus GitHub issue ingestion, a CI watcher, and a Schedules tab. Rule of thumb: <strong>watch the floor for one agent right now, watch the board for the whole fleet over time</strong>.</p></div>+<video controls preload="none" playsinline poster="/media/demo/features-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/features.mp4" type="video/mp4" />+</video>+<p>Munder Difflin has two ways of looking at the same hive. The <strong>office floor</strong> is the ambient view: avatars at desks, envelopes flying between them, speech bubbles when a tool fires. The <strong>Command Center</strong> is the management view — Michael’s control surface, the place you go when the question stops being “what is Dwight doing?” and becomes “what is <em>everyone</em> doing, what has it cost, and what’s next?”</p>+<p>This guide walks through what’s in it and how the pieces fit together.</p>+<h2 id="whats-in-the-command-center" tabindex="-1">What’s in the Command Center <a class="anchor" href="#whats-in-the-command-center" aria-hidden="true">#</a></h2>+<p>Six tabs, one control surface:</p>+<ul>+<li><strong>Terminal</strong> — Michael’s own terminal, the <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> you talk to directly.</li>+<li><strong>Floor</strong> — the roster and dispatch controls: hire, dispatch work, pick a model per agent, and watch live fleet monitoring across everyone at once.</li>+<li><strong>Memory</strong> — semantic search over the shared memory palace, plain text search, and a memory graph.</li>+<li><strong>Activity</strong> — the append-only event log, the blackboard, real token telemetry, the observability view, and a CI watcher.</li>+<li><strong>Tasks</strong> — the kanban board.</li>+<li><strong>Schedules</strong> — recurring missions and the adaptive heartbeat, with last/next-fired times.</li>+</ul>+<p>You could run the hive from the floor alone. But once you have more than two or three agents, the Command Center is where the actual decisions happen.</p>+<h2 id="the-task-kanban-work-as-a-board-not-a-chat-log" tabindex="-1">The task kanban: work as a board, not a chat log <a class="anchor" href="#the-task-kanban-work-as-a-board-not-a-chat-log" aria-hidden="true">#</a></h2>+<p>The Tasks tab is a <strong>dependency-aware kanban board</strong>. Tasks move across four columns — todo, doing, blocked, done — and each task is assigned to a specific agent.</p>+<p>The load-bearing word is <em>dependency-aware</em>. Real work has ordering: the refactor has to land before the tests get updated; the schema migration comes before the endpoint. On the board you wire those dependencies explicitly, and downstream tasks wait until their prerequisites finish. You’re not the sequencer anymore — the board is.</p>+<p>Work gets onto the board a few ways: you create tasks yourself, Michael creates and assigns them as he routes requests, and you can <strong>pull open GitHub issues from any registered repo</strong> (via the <code>gh</code> CLI) and assign them to agents with one click. Issue in, task tracked, agent dispatched — and when the work ships, the <strong>CI status watcher</strong> in the Activity tab shows live pass/fail/in-progress for the repo’s GitHub Actions runs. The loop closes in the same window it opened in.</p>+<h2 id="fleet-status-the-roster-at-a-glance" tabindex="-1">Fleet status: the roster at a glance <a class="anchor" href="#fleet-status-the-roster-at-a-glance" aria-hidden="true">#</a></h2>+<p>The Floor tab is where the fleet stops being a set of individual terminals and becomes a roster. Each agent card shows what that agent is up to, and the card’s progress bar doubles as a <strong>context-window gauge</strong> — a glanceable read on how much of the model’s context each agent has burned. An agent near the top of its gauge is an agent about to compact or slow down; you can see it coming instead of discovering it.</p>+<p>Dispatch also lives here: pick an agent, pick a model (the <strong>per-agent model selector</strong> means your cheap-tier worker and your frontier-tier reviewer are one dropdown apart), and send work. Routine tasks go to the cheap tier; the frontier tier is reserved for the reasoning that needs it.</p>+<h2 id="budgets-and-cost-real-numbers-not-vibes" tabindex="-1">Budgets and cost: real numbers, not vibes <a class="anchor" href="#budgets-and-cost-real-numbers-not-vibes" aria-hidden="true">#</a></h2>+<p>This is the part that makes a 24/7 fleet safe to leave running.</p>+<p><strong>Per-agent token budgets.</strong> You set a budget per agent, and live fleet monitoring tracks consumption across the whole roster against it. Budgets pair with the <strong>circuit breaker</strong>, which handles the runaway case on a ladder: <em>steer</em> (nudge the agent), then <em>constrain</em>, then <em>stop</em>. An agent that loops, storms errors, or blows through its cap gets caught by machinery, not by you noticing the bill.</p>+<p><strong>Real telemetry.</strong> The Activity tab doesn’t estimate from message counts — it reads the JSONL transcripts Claude Code writes to <code>~/.claude/projects/</code> and surfaces <strong>actual token counts and estimated USD cost per agent, per session</strong>, backed by a <strong>durable cost ledger</strong> that survives app restarts. Yesterday’s spend is still there this morning, attributed to the agent that spent it.</p>+<p><strong>Observability.</strong> Also in Activity: a live <strong>OpenTelemetry collector</strong> with per-model cost attribution, a fleet grid, and a <strong>per-agent tool-span waterfall</strong> — the “what exactly is this agent doing, step by step, and what does each step cost” view. It’s the same discipline we covered in <a href="/blog/observability-for-agent-fleets/">observability for agent fleets</a>, built into the harness instead of bolted on.</p>+<h2 id="schedules-the-boards-fourth-dimension" tabindex="-1">Schedules: the board’s fourth dimension <a class="anchor" href="#schedules-the-boards-fourth-dimension" aria-hidden="true">#</a></h2>+<p>The kanban answers “what’s in flight.” The <strong>Schedules tab</strong> answers “what happens next without me.” Recurring missions carry a label, an interval, a target agent, and a body, and the tab shows last-fired and next-fired times, so drift is visible. A scheduler <strong>heartbeat</strong> re-engages the floor when it goes quiet. Together with the board, it turns the hive from something you drive into something you supervise — the full pattern is in <a href="/blog/scheduling-autonomous-agent-missions/">scheduling autonomous agent missions</a>.</p>+<h2 id="floor-or-board-a-simple-rule" tabindex="-1">Floor or board? A simple rule <a class="anchor" href="#floor-or-board-a-simple-rule" aria-hidden="true">#</a></h2>+<p>Both views are the same hive, so this is about attention, not data:</p>+<ul>+<li><strong>Watch the floor</strong> when you care about <em>one agent right now</em> — you just dispatched something, you want to type into a session, or you want ambient awareness while doing other work. (Also: it’s charming.)</li>+<li><strong>Watch the board</strong> when you care about <em>the fleet over time</em> — what’s queued, what’s blocked on what, who’s near budget, whether CI is green, what fires tonight.</li>+</ul>+<p>In practice: floor open while you work, Command Center when you check in. Morning check-in is the board — done column, spend per agent, blocked tasks, next scheduled missions. That’s a two-minute read that would take twenty minutes of terminal-scrolling without it. And when something needs a human decision, escalations land in the <a href="/blog/human-in-the-loop-approving-ai-agents/">approvals queue</a> rather than hiding in a scrollback buffer.</p>+<h2 id="try-it" tabindex="-1">Try it <a class="anchor" href="#try-it" aria-hidden="true">#</a></h2>+<p>The Command Center ships in the current release, free and open source. <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Download Munder Difflin</a> — and if the board earns its place in your morning routine, a <a href="https://github.com/chaitanyagiri/munder-difflin">star on GitHub</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is the Command Center in Munder Difflin?</p>+ <p class="a">It's Michael's control surface — the management view of the whole hive. It has tabs for the orchestrator Terminal, the Floor (roster, dispatch, per-agent model selector, live fleet monitoring), Memory (semantic search plus a memory graph), Activity (event log, board, real token telemetry, observability, and a CI watcher), Tasks (a dependency-aware kanban board), and Schedules (recurring missions with last/next-fired times).</p>+ </div>++ <div class="qa">+ <p class="q">How does the task kanban work?</p>+ <p class="a">The Tasks tab is a dependency-aware kanban board. You assign tasks to agents and track them across todo, doing, blocked, and done. Because tasks can declare dependencies, downstream work waits until its prerequisites finish, so a chain of related tasks starts in the right order without you babysitting the handoffs.</p>+ </div>++ <div class="qa">+ <p class="q">How do per-agent budgets and cost tracking work?</p>+ <p class="a">You set a token budget per agent, and live fleet monitoring tracks consumption across the roster. Cost numbers are real, not estimates from vibes: the Activity tab reads the JSONL transcripts Claude Code writes and surfaces actual token counts plus estimated USD cost per agent per session, backed by a durable cost ledger that survives restarts. The budget pairs with a circuit breaker that steers, then constrains, then stops an agent that loops or blows its cap.</p>+ </div>++ <div class="qa">+ <p class="q">When should I watch the office floor versus the Command Center?</p>+ <p class="a">The floor is for ambient awareness and single-agent moments — seeing who's working, watching envelopes fly, dropping into one terminal. The Command Center is for management questions: what's queued and blocked, what each agent has spent, whether CI is green, and what fires next on the schedule. Roughly: floor for one agent right now, board for the whole fleet over time.</p>+ </div>++ <div class="qa">+ <p class="q">Does the Command Center include observability?</p>+ <p class="a">Yes. The Activity tab includes a live OpenTelemetry collector with per-model cost attribution, a fleet grid, and a per-agent tool-span waterfall, so you can see exactly what every agent is doing and what it costs in real time. Each agent card also carries a context-window gauge showing how much of the model's context that agent has consumed.</p>+ </div>++ <div class="qa">+ <p class="q">Can the Command Center pull in work from GitHub?</p>+ <p class="a">Yes. You can ingest open issues from any registered repo via the gh CLI and assign them to agents with one click, and a CI status watcher shows live pass/fail/in-progress state for GitHub Actions runs in the Activity tab. Work flows in from GitHub, gets tracked on the kanban, and its CI result lands back in the same view.</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/command-center/">Command Center</a><a class="tag" href="/blog/tags/kanban/">Kanban</a><a class="tag" href="/blog/tags/cost/">Cost</a><a class="tag" href="/blog/tags/observability/">Observability</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="#whats-in-the-command-center">What’s in the Command Center</a></li><li class="lvl-2"><a href="#the-task-kanban-work-as-a-board-not-a-chat-log">The task kanban: work as a board, not a chat log</a></li><li class="lvl-2"><a href="#fleet-status-the-roster-at-a-glance">Fleet status: the roster at a glance</a></li><li class="lvl-2"><a href="#budgets-and-cost-real-numbers-not-vibes">Budgets and cost: real numbers, not vibes</a></li><li class="lvl-2"><a href="#schedules-the-boards-fourth-dimension">Schedules: the board’s fourth dimension</a></li><li class="lvl-2"><a href="#floor-or-board-a-simple-rule">Floor or board? A simple rule</a></li><li class="lvl-2"><a href="#try-it">Try it</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/crewai-autogen-vs-a-local-agent-harness/"><span class="k">← Older</span><span class="t">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</span></a>+ <span></span>+ </div>+ <section class="related">+ <h2>Related in Guides</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/conductor-claude-code-alternative/index.html b/docs/blog/conductor-claude-code-alternative/index.htmlindex f484b2d8..1ca66693 100644--- a/docs/blog/conductor-claude-code-alternative/index.html+++ b/docs/blog/conductor-claude-code-alternative/index.html@@ -215,56 +215,56 @@ coordinated team locally — it’s free and open source.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">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.htmlindex add9f303..9169db46 100644--- a/docs/blog/context-engineering-for-ai-agents/index.html+++ b/docs/blog/context-engineering-for-ai-agents/index.html@@ -307,56 +307,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/crewai-autogen-vs-a-local-agent-harness/index.html b/docs/blog/crewai-autogen-vs-a-local-agent-harness/index.htmlnew file mode 100644index 00000000..8ce56bc5--- /dev/null+++ b/docs/blog/crewai-autogen-vs-a-local-agent-harness/index.html@@ -0,0 +1,338 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>CrewAI and AutoGen vs a Local Agent Harness: Framework or App? — Munder Difflin Blog</title>+<meta name="description" content="CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need." />+<link rel="canonical" href="https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/" />++<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="CrewAI and AutoGen vs a Local Agent Harness: Framework or App? — Munder Difflin Blog" />+<meta property="og:description" content="CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need." />+<meta property="og:url" content="https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Comparisons" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="CrewAI" />+<meta property="article:tag" content="AutoGen" />+<meta property="article:tag" content="LangGraph" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="CrewAI and AutoGen vs a Local Agent Harness: Framework or App? — Munder Difflin Blog" />+<meta name="twitter:description" content="CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need." />+<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": "CrewAI and AutoGen vs a Local Agent Harness: Framework or App?",+ "description": "CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/crewai-autogen-vs-a-local-agent-harness/" },+ "keywords": "crewai vs autogen vs agent harness, multi-agent framework vs harness, crewai alternative, autogen alternative, langgraph vs harness, microsoft agent framework, multi-agent orchestration app",+ "articleSection": "Comparisons",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/"+}+</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": "CrewAI and AutoGen vs a Local Agent Harness: Framework or App?", "item": "https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What's the difference between a multi-agent framework and a multi-agent harness?", "acceptedAnswer": { "@type": "Answer", "text": "A framework is a library — CrewAI, Microsoft Agent Framework, and LangGraph are Python (and .NET/JS) packages you import to build your own agent system, which means you also build the UI, guardrails, memory, and triggers around it. A harness is a finished application: you download it, point it at your repos, and a coordinated team of agents runs with orchestration, approvals, budgets, and memory already built in. Same underlying idea, opposite division of labor." } },+ { "@type": "Question", "name": "Is CrewAI free and open source?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The CrewAI Python framework is MIT-licensed and open source, with agents organized into Crews (autonomous role-based teams) and Flows (event-driven workflows with precise control). You bring an LLM API key — OpenAI by default, with local models via Ollama supported — and CrewAI also sells an enterprise platform (AMP) for managed deployment, observability, and governance." } },+ { "@type": "Question", "name": "What happened to Microsoft AutoGen?", "acceptedAnswer": { "@type": "Answer", "text": "Microsoft merged AutoGen with Semantic Kernel into the Microsoft Agent Framework, which reached its production-ready 1.0 release in April 2026 for Python and .NET. AutoGen and Semantic Kernel are now in maintenance mode — bug fixes and security patches, but new feature work happens in Agent Framework. It combines AutoGen's agent abstractions with Semantic Kernel's enterprise features plus graph-based workflows." } },+ { "@type": "Question", "name": "Do frameworks like CrewAI or LangGraph require API keys?", "acceptedAnswer": { "@type": "Answer", "text": "Generally yes — they call model provider APIs directly, so you supply keys (or point at a local model server). A harness like Munder Difflin instead drives the agent CLIs you already run — Claude Code, Codex, Copilot CLI and others — so it can ride the subscriptions you already pay for, with BYO keys and local LLMs as options rather than requirements." } },+ { "@type": "Question", "name": "When should I pick a framework instead of a harness?", "acceptedAnswer": { "@type": "Answer", "text": "Pick a framework when the agent system is a component of your product: a support pipeline inside your SaaS, a document-processing workflow, anything that needs custom logic, your own deployment, and tight integration with your stack. CrewAI, Agent Framework, and LangGraph are excellent at exactly that. Pick a harness when the goal is a team of coding agents working your repos today, with no code to write." } },+ { "@type": "Question", "name": "Is Munder Difflin a framework I can import into my own app?", "acceptedAnswer": { "@type": "Answer", "text": "No. It's a local-first, MIT-licensed Electron desktop app for macOS, Windows, and Linux — the harness itself is the product. You download it, spawn agents that run as real CLI processes in isolated git worktrees, and a GOD orchestrator routes work between them while you watch, with approvals, budgets, a circuit breaker, and shared memory already wired in." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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/comparisons/">Comparisons</a>+ </nav>+ <h1>CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</h1>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 min read</span>+ <span class="tag kind">Comparisons</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks</strong> — Python you import to <em>build</em> a multi-agent system, which means you also build the UI, guardrails, memory, and triggers yourself. <strong>A multi-agent harness is the finished app</strong>: Munder Difflin is a free, local-first desktop app that drives the agent CLIs you already have — Claude Code, Codex, Copilot CLI — as a coordinated team, with an orchestrator, approval gates, budgets, and shared memory built in. <strong>Frameworks win when agents are a component of your product. A harness wins when you want a team working your repos today, with no code.</strong></p></div>+<p>“Which multi-agent framework should I use?” is usually the wrong first question. The right first question is: <strong>are you building an agent system, or do you want to use one?</strong></p>+<p>Those are different jobs, and the tools for them belong to different categories. CrewAI, Microsoft’s Agent Framework, and LangGraph sit in one; a multi-agent harness like Munder Difflin sits in the other. This post draws the line honestly, because both sides of it are good at what they’re for.</p>+<h2 id="what-the-frameworks-actually-are" tabindex="-1">What the frameworks actually are <a class="anchor" href="#what-the-frameworks-actually-are" aria-hidden="true">#</a></h2>+<p><strong>CrewAI</strong> is an MIT-licensed Python framework for orchestrating role-based agents. You define agents, tasks, and workflows in code: <em>Crews</em> for autonomous collaborative teams, <em>Flows</em> for event-driven workflows with conditional branching and state management. You bring an LLM API key (OpenAI by default; local models via Ollama work too), and there’s a commercial platform (AMP) layered on top for managed deployment, observability, and governance. It’s a genuinely well-designed library with serious enterprise adoption.</p>+<p><strong>AutoGen</strong> — the Microsoft research project that popularized conversational multi-agent patterns — has been merged with Semantic Kernel into the <strong>Microsoft Agent Framework</strong>, which shipped its production-ready 1.0 in April 2026 for Python and .NET. AutoGen and Semantic Kernel themselves are in maintenance mode; Agent Framework carries the torch, combining AutoGen’s agent abstractions with Semantic Kernel’s enterprise plumbing (state management, middleware, telemetry) plus graph-based workflows. If you’re on Azure and building agents into a product, it’s the obvious pick.</p>+<p><strong>LangGraph</strong> hit a stable 1.0 in late 2025 and is used in production at companies like Klarna, LinkedIn, Uber, and Replit. It models agent workflows as graphs with cycles — loop, retry, reflect — with checkpointing and a first-class <code>interrupt()</code> primitive for human-in-the-loop. For complex stateful pipelines where you want explicit control over every branch, it’s the default answer.</p>+<p>Notice what all three have in common. They’re <strong>libraries</strong>. <code>pip install</code>, import, write Python. That’s not a criticism — it’s the point. A framework’s job is to give a developer building blocks.</p>+<h2 id="what-a-framework-doesnt-give-you" tabindex="-1">What a framework doesn’t give you <a class="anchor" href="#what-a-framework-doesnt-give-you" aria-hidden="true">#</a></h2>+<p>Here’s the part the comparison charts skip: when you pick a framework, <strong>you’ve signed up to build the harness yourself.</strong> The agent loop is maybe a fifth of a working multi-agent system. Around it you still need:</p>+<ul>+<li><strong>A UI</strong> — some way to see what N agents are doing right now, not just logs.</li>+<li><strong>Guardrails</strong> — approval gates for spend and destructive operations, budgets, something that stops a looping agent before it burns $200.</li>+<li><strong>Memory</strong> — persistence across sessions, so Tuesday’s agent knows what Monday’s learned.</li>+<li><strong>Triggers</strong> — Slack, webhooks, schedules, so work arrives without you typing it.</li>+<li><strong>Isolation</strong> — so two agents editing the same repo don’t destroy each other’s work.</li>+</ul>+<p>Frameworks are adding pieces of this (LangGraph’s interrupts, CrewAI’s memory and tracing, Agent Framework’s telemetry), and their commercial platforms sell more of it. But the assembled, running system is still your project. That’s a great deal if the agent system <em>is</em> your product. It’s a terrible deal if what you wanted was help with your repos this afternoon.</p>+<h2 id="what-a-harness-is-instead" tabindex="-1">What a harness is instead <a class="anchor" href="#what-a-harness-is-instead" aria-hidden="true">#</a></h2>+<p>A <a href="/blog/what-is-a-multi-agent-harness/">multi-agent harness</a> is the other answer: the system, already assembled, as an app. Munder Difflin is a free, MIT-licensed, local-first desktop app (macOS/Windows/Linux) where every agent is a <strong>real CLI process</strong> — Claude Code, OpenAI Codex, Antigravity, OpenCode, Crush, pi.dev, GitHub Copilot CLI — running in its own pseudo-terminal and its own isolated git worktree. A <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> routes work between them; agents share long-term memory; triggers include typing, Slack, webhooks, schedules, and voice.</p>+<p>The pieces you’d have built around a framework are already there: <a href="/blog/human-in-the-loop-approving-ai-agents/">human approval gates</a> on spend, scope, and destructive ops; a circuit breaker with a steer → constrain → stop ladder; per-agent token budgets; OpenTelemetry observability; a Command Center with a kanban board and live fleet monitoring. And because it drives CLIs rather than calling model APIs, it rides the <strong>subscriptions you already pay for</strong> — no mandatory API key, with BYO keys and local LLMs as options.</p>+<p>The honest flip side: you can’t <code>import</code> Munder Difflin into your SaaS. It won’t run your custom document pipeline inside your product. It’s an app for a specific job — a team of agents working your repositories, visible on one screen — not a toolkit for arbitrary agent systems.</p>+<h2 id="the-honest-decision-rule" tabindex="-1">The honest decision rule <a class="anchor" href="#the-honest-decision-rule" aria-hidden="true">#</a></h2>+<p><strong>Choose a framework (CrewAI, Agent Framework, LangGraph) when:</strong></p>+<ul>+<li>Agents are a <em>component of something you’re shipping</em> — embedded in your product, your pipeline, your infrastructure.</li>+<li>You need custom orchestration logic, your own deployment story, or deep integration with your stack (Azure, LangSmith, your data layer).</li>+<li>You have engineering time to build and maintain the surrounding harness, and that investment pays off because the system is core to your business.</li>+</ul>+<p><strong>Choose a harness (Munder Difflin) when:</strong></p>+<ul>+<li>The goal is “a team working my repos today” — coding, reviewing, fixing issues — with zero glue code.</li>+<li>You want guardrails, memory, isolation, and a UI on day one, not as a Q3 project.</li>+<li>You want it local and driving the CLI subscriptions you already have, rather than metering API calls through code you wrote.</li>+</ul>+<p>There’s no loser here. It’s the same distinction as Rails vs. a deployed app: nobody asks which is “better,” because one is for builders of systems and the other is a system. If you’re still weighing categories, <a href="/blog/how-to-choose-a-multi-agent-tool/">how to choose a multi-agent tool</a> walks the wider field, and <a href="/blog/local-first-vs-cloud-agent-sdks/">local-first vs cloud agent SDKs</a> covers the deployment axis.</p>+<h2 id="try-the-harness-side-in-five-minutes" tabindex="-1">Try the harness side in five minutes <a class="anchor" href="#try-the-harness-side-in-five-minutes" aria-hidden="true">#</a></h2>+<p>If your answer was “I just want the team,” that’s the job Munder Difflin exists for. <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Download the latest release</a> — free, open source, local-first — and if it earns it, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>+<p>Sources: <a href="https://github.com/crewAIInc/crewAI">CrewAI on GitHub</a>; <a href="https://learn.microsoft.com/en-us/agent-framework/overview/">Microsoft Agent Framework overview</a>; <a href="https://devblogs.microsoft.com/agent-framework/migrate-your-semantic-kernel-and-autogen-projects-to-microsoft-agent-framework-release-candidate/">Migrating Semantic Kernel and AutoGen to Agent Framework</a>; <a href="https://www.langchain.com/langgraph">LangGraph</a>.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What's the difference between a multi-agent framework and a multi-agent harness?</p>+ <p class="a">A framework is a library — CrewAI, Microsoft Agent Framework, and LangGraph are Python (and .NET/JS) packages you import to build your own agent system, which means you also build the UI, guardrails, memory, and triggers around it. A harness is a finished application: you download it, point it at your repos, and a coordinated team of agents runs with orchestration, approvals, budgets, and memory already built in. Same underlying idea, opposite division of labor.</p>+ </div>++ <div class="qa">+ <p class="q">Is CrewAI free and open source?</p>+ <p class="a">Yes. The CrewAI Python framework is MIT-licensed and open source, with agents organized into Crews (autonomous role-based teams) and Flows (event-driven workflows with precise control). You bring an LLM API key — OpenAI by default, with local models via Ollama supported — and CrewAI also sells an enterprise platform (AMP) for managed deployment, observability, and governance.</p>+ </div>++ <div class="qa">+ <p class="q">What happened to Microsoft AutoGen?</p>+ <p class="a">Microsoft merged AutoGen with Semantic Kernel into the Microsoft Agent Framework, which reached its production-ready 1.0 release in April 2026 for Python and .NET. AutoGen and Semantic Kernel are now in maintenance mode — bug fixes and security patches, but new feature work happens in Agent Framework. It combines AutoGen's agent abstractions with Semantic Kernel's enterprise features plus graph-based workflows.</p>+ </div>++ <div class="qa">+ <p class="q">Do frameworks like CrewAI or LangGraph require API keys?</p>+ <p class="a">Generally yes — they call model provider APIs directly, so you supply keys (or point at a local model server). A harness like Munder Difflin instead drives the agent CLIs you already run — Claude Code, Codex, Copilot CLI and others — so it can ride the subscriptions you already pay for, with BYO keys and local LLMs as options rather than requirements.</p>+ </div>++ <div class="qa">+ <p class="q">When should I pick a framework instead of a harness?</p>+ <p class="a">Pick a framework when the agent system is a component of your product: a support pipeline inside your SaaS, a document-processing workflow, anything that needs custom logic, your own deployment, and tight integration with your stack. CrewAI, Agent Framework, and LangGraph are excellent at exactly that. Pick a harness when the goal is a team of coding agents working your repos today, with no code to write.</p>+ </div>++ <div class="qa">+ <p class="q">Is Munder Difflin a framework I can import into my own app?</p>+ <p class="a">No. It's a local-first, MIT-licensed Electron desktop app for macOS, Windows, and Linux — the harness itself is the product. You download it, spawn agents that run as real CLI processes in isolated git worktrees, and a GOD orchestrator routes work between them while you watch, with approvals, budgets, a circuit breaker, and shared memory already wired in.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/comparisons/">Comparisons</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/crewai/">CrewAI</a><a class="tag" href="/blog/tags/autogen/">AutoGen</a><a class="tag" href="/blog/tags/langgraph/">LangGraph</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-frameworks-actually-are">What the frameworks actually are</a></li><li class="lvl-2"><a href="#what-a-framework-doesnt-give-you">What a framework doesn’t give you</a></li><li class="lvl-2"><a href="#what-a-harness-is-instead">What a harness is instead</a></li><li class="lvl-2"><a href="#the-honest-decision-rule">The honest decision rule</a></li><li class="lvl-2"><a href="#try-the-harness-side-in-five-minutes">Try the harness side in five minutes</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/"><span class="k">← Older</span><span class="t">GitHub Copilot CLI vs Claude Code as Hive Workers</span></a>+ <a class="pn next" href="/blog/command-center-guide/"><span class="k">Newer →</span><span class="t">The Command Center: Kanban, Fleet, and Budgets in One Place</span></a>+ </div>+ <section class="related">+ <h2>Related in Comparisons</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/crystal-claude-code-alternative/index.html b/docs/blog/crystal-claude-code-alternative/index.htmlindex 465c7b4b..d9314b22 100644--- a/docs/blog/crystal-claude-code-alternative/index.html+++ b/docs/blog/crystal-claude-code-alternative/index.html@@ -212,56 +212,56 @@ actually remember — free and open source.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/debugging-multi-agent-systems/index.html b/docs/blog/debugging-multi-agent-systems/index.htmlindex 2e7cb308..f50654bc 100644--- a/docs/blog/debugging-multi-agent-systems/index.html+++ b/docs/blog/debugging-multi-agent-systems/index.html@@ -270,56 +270,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/do-more-with-less-model-routing/index.html b/docs/blog/do-more-with-less-model-routing/index.htmlindex d666cfce..9cf82ed9 100644--- a/docs/blog/do-more-with-less-model-routing/index.html+++ b/docs/blog/do-more-with-less-model-routing/index.html@@ -274,56 +274,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex 8e4e8cbb..2103beae 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@@ -265,56 +265,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/evaluating-ai-agent-reliability/index.html b/docs/blog/evaluating-ai-agent-reliability/index.htmlindex f87d10ad..f9b76d47 100644--- a/docs/blog/evaluating-ai-agent-reliability/index.html+++ b/docs/blog/evaluating-ai-agent-reliability/index.html@@ -273,56 +273,56 @@ your bar.</p><h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/feed.xml b/docs/blog/feed.xmlindex 01e6006d..7857da5c 100644--- a/docs/blog/feed.xml+++ b/docs/blog/feed.xml@@ -7,6 +7,62 @@<updated>2026-07-03T00:00:00.000Z</updated><id>https://munderdiffl.in/blog/</id><author><name>Chaitanya Giri</name><uri>https://munderdiffl.in</uri></author>+ <entry>+ <title>The Command Center: Kanban, Fleet, and Budgets in One Place</title>+ <link href="https://munderdiffl.in/blog/command-center-guide/" />+ <id>https://munderdiffl.in/blog/command-center-guide/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</summary>+ </entry>+ <entry>+ <title>CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</title>+ <link href="https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/" />+ <id>https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Comparisons" />+ <summary>CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</summary>+ </entry>+ <entry>+ <title>GitHub Copilot CLI vs Claude Code as Hive Workers</title>+ <link href="https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/" />+ <id>https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Comparisons" />+ <summary>How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</summary>+ </entry>+ <entry>+ <title>How to Add a GitHub Copilot CLI Agent to Your Floor</title>+ <link href="https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-agent/" />+ <id>https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-agent/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</summary>+ </entry>+ <entry>+ <title>How to Hire From the Agent Gallery</title>+ <link href="https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/" />+ <id>https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</summary>+ </entry>+ <entry>+ <title>How to Brief Your Orchestrator (So the Floor Actually Ships)</title>+ <link href="https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/" />+ <id>https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</summary>+ </entry>+ <entry>+ <title>How to Use the Built-in Monaco IDE</title>+ <link href="https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/" />+ <id>https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</summary>+ </entry><entry><title>Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support</title><link href="https://munderdiffl.in/blog/launching-munder-difflin-v0-3-3/" />@@ -15,6 +71,78 @@<updated>2026-07-03T00:00:00.000Z</updated><category term="Story" /><summary>Munder Difflin v0.3.3 adds a full Monaco IDE — file tree, editor tabs, save, and side-by-side git diffs of your agents' changes — plus GitHub Copilot CLI as a first-class agent engine, our first community-contributed provider.</summary></entry>+ <entry>+ <title>Loop Engineering: Designing Agent Loops That Converge</title>+ <link href="https://munderdiffl.in/blog/loop-engineering-for-ai-agents/" />+ <id>https://munderdiffl.in/blog/loop-engineering-for-ai-agents/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Concepts" />+ <summary>Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</summary>+ </entry>+ <entry>+ <title>Orca vs Munder Difflin: Agent IDE or Agent Office?</title>+ <link href="https://munderdiffl.in/blog/orca-vs-munder-difflin/" />+ <id>https://munderdiffl.in/blog/orca-vs-munder-difflin/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Comparisons" />+ <summary>Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</summary>+ </entry>+ <entry>+ <title>Review Agent Work Where It Happens</title>+ <link href="https://munderdiffl.in/blog/review-agent-work-where-it-happens/" />+ <id>https://munderdiffl.in/blog/review-agent-work-where-it-happens/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Concepts" />+ <summary>AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</summary>+ </entry>+ <entry>+ <title>Run a Mixed-Engine Office: the Right CLI for Every Desk</title>+ <link href="https://munderdiffl.in/blog/run-a-mixed-engine-office/" />+ <id>https://munderdiffl.in/blog/run-a-mixed-engine-office/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</summary>+ </entry>+ <entry>+ <title>Running Agents in tmux vs an Agent Harness</title>+ <link href="https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/" />+ <id>https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Comparisons" />+ <summary>tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</summary>+ </entry>+ <entry>+ <title>Voice Is a Control Plane, Not a Gimmick</title>+ <link href="https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/" />+ <id>https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Concepts" />+ <summary>Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</summary>+ </entry>+ <entry>+ <title>What Is an Agent Development Environment (ADE)?</title>+ <link href="https://munderdiffl.in/blog/what-is-an-agent-development-environment/" />+ <id>https://munderdiffl.in/blog/what-is-an-agent-development-environment/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Concepts" />+ <summary>ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</summary>+ </entry>+ <entry>+ <title>What Is Harness Engineering?</title>+ <link href="https://munderdiffl.in/blog/what-is-harness-engineering/" />+ <id>https://munderdiffl.in/blog/what-is-harness-engineering/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Concepts" />+ <summary>Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</summary>+ </entry>+ <entry>+ <title>Your First Hour With Munder Difflin</title>+ <link href="https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" />+ <id>https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/</id>+ <published>2026-07-03T00:00:00.000Z</published>+ <updated>2026-07-03T00:00:00.000Z</updated><category term="Guides" />+ <summary>A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</summary>+ </entry><entry><title>Launching Munder Difflin v0.3.2: Talk to Michael, a Realtime Voice Orchestrator</title><link href="https://munderdiffl.in/blog/launching-munder-difflin-v0-3-2/" />@@ -359,132 +487,4 @@<updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" /><summary>The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</summary></entry>- <entry>- <title>How AI Answer Engines Choose What to Cite</title>- <link href="https://munderdiffl.in/blog/how-ai-answer-engines-choose-sources/" />- <id>https://munderdiffl.in/blog/how-ai-answer-engines-choose-sources/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Comparisons" />- <summary>How ChatGPT, Claude, Perplexity, and Google AI Overviews actually pick and cite sources in 2026 — the per-engine signals, and why there's no single rank.</summary>- </entry>- <entry>- <title>Approving AI Agents: Human-in-the-Loop Without a Queue</title>- <link href="https://munderdiffl.in/blog/human-in-the-loop-approving-ai-agents/" />- <id>https://munderdiffl.in/blog/human-in-the-loop-approving-ai-agents/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />- <summary>How to approve what AI agents do without a parallel approval queue: native permission prompts, routing 'to: human' to the orchestrator, remote approval.</summary>- </entry>- <entry>- <title>Keep Your Agent's Semantic Memory Clean: Don't Index the Config</title>- <link href="https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/" />- <id>https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Memory" />- <summary>A semantic memory layer is only as good as what you feed it — how an agent's recall got swamped by config and logs, and the .gitignore + prune fix.</summary>- </entry>- <entry>- <title>Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</title>- <link href="https://munderdiffl.in/blog/local-first-ai-agent-orchestration/" />- <id>https://munderdiffl.in/blog/local-first-ai-agent-orchestration/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Orchestration" />- <summary>How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</summary>- </entry>- <entry>- <title>Local-First vs Cloud Agent SDKs: Which Wins in 2026?</title>- <link href="https://munderdiffl.in/blog/local-first-vs-cloud-agent-sdks/" />- <id>https://munderdiffl.in/blog/local-first-vs-cloud-agent-sdks/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Comparisons" />- <summary>Local-first agent hives vs the 2026 cloud agent SDK wave (OpenAI, Google ADK, Microsoft, MCP/A2A): what each optimizes for, and when to pick which.</summary>- </entry>- <entry>- <title>Long-Running Agents: The 2026 Shift from Minutes to Hours</title>- <link href="https://munderdiffl.in/blog/long-running-agents-the-2026-shift/" />- <id>https://munderdiffl.in/blog/long-running-agents-the-2026-shift/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />- <summary>Agents used to answer in seconds; now they run for hours. The data behind the shift — and why a longer agent is a different problem, not just a bigger one.</summary>- </entry>- <entry>- <title>Observability for Agent Fleets: Seeing What Your Agents Do</title>- <link href="https://munderdiffl.in/blog/observability-for-agent-fleets/" />- <id>https://munderdiffl.in/blog/observability-for-agent-fleets/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Internals" />- <summary>Agent fleet observability: the four questions your dashboard must answer about who's working, what they're doing, what it costs, and what they know.</summary>- </entry>- <entry>- <title>Building AI Dev Tools in the Open, On Purpose</title>- <link href="https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/" />- <id>https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />- <summary>Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</summary>- </entry>- <entry>- <title>Overnight AI Coding: What's Realistic (and What's Not)</title>- <link href="https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/" />- <id>https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Use Cases" />- <summary>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.</summary>- </entry>- <entry>- <title>Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</title>- <link href="https://munderdiffl.in/blog/prompt-caching-for-ai-agents/" />- <id>https://munderdiffl.in/blog/prompt-caching-for-ai-agents/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />- <summary>An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</summary>- </entry>- <entry>- <title>Recovering From Agent Failures: Resilience Patterns for a Hive</title>- <link href="https://munderdiffl.in/blog/recovering-from-agent-failures/" />- <id>https://munderdiffl.in/blog/recovering-from-agent-failures/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Internals" />- <summary>How multi-agent systems survive partial failure: retry with stale-lock recovery, poison-message quarantine, hop-cap circuit breaking, idempotent handling.</summary>- </entry>- <entry>- <title>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</title>- <link href="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />- <id>https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Orchestration" />- <summary>How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</summary>- </entry>- <entry>- <title>Security for AI Coding Agents: A Practical Guide</title>- <link href="https://munderdiffl.in/blog/security-for-ai-coding-agents/" />- <id>https://munderdiffl.in/blog/security-for-ai-coding-agents/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />- <summary>How to run AI coding agents safely: contain the blast radius, scope every task, treat agent input as untrusted, and gate the irreversible behind a human.</summary>- </entry>- <entry>- <title>A Small-Team Playbook for AI Coding Agents</title>- <link href="https://munderdiffl.in/blog/small-team-ai-agents-playbook/" />- <id>https://munderdiffl.in/blog/small-team-ai-agents-playbook/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />- <summary>How a small team adopts a hive of AI coding agents without chaos — the roles to assign, the cadence to run, and the guardrails that keep it safe.</summary>- </entry>- <entry>- <title>The Hook Shim Pattern: Wiring Agent Hooks to a Live Process</title>- <link href="https://munderdiffl.in/blog/the-hook-shim-pattern/" />- <id>https://munderdiffl.in/blog/the-hook-shim-pattern/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Internals" />- <summary>How a tiny shim bridges Claude Code's lifecycle hooks to one live process over a Unix socket, turning per-event hooks into a telemetry and control channel.</summary>- </entry>- <entry>- <title>The Lethal Trifecta for Coding Agents</title>- <link href="https://munderdiffl.in/blog/the-lethal-trifecta-for-coding-agents/" />- <id>https://munderdiffl.in/blog/the-lethal-trifecta-for-coding-agents/</id>- <published>2026-06-04T00:00:00.000Z</published>- <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />- <summary>A coding agent reads private code, ingests untrusted content, and runs commands — the lethal trifecta. How a poisoned dependency leaks your secrets.</summary>- </entry></feed>diff --git a/docs/blog/generative-engine-optimization-techniques/index.html b/docs/blog/generative-engine-optimization-techniques/index.htmlindex e9845ad5..cf03f2cf 100644--- a/docs/blog/generative-engine-optimization-techniques/index.html+++ b/docs/blog/generative-engine-optimization-techniques/index.html@@ -279,56 +279,56 @@ 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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/github-copilot-cli-vs-claude-code-for-hive-work/index.html b/docs/blog/github-copilot-cli-vs-claude-code-for-hive-work/index.htmlnew file mode 100644index 00000000..7bb6c714--- /dev/null+++ b/docs/blog/github-copilot-cli-vs-claude-code-for-hive-work/index.html@@ -0,0 +1,382 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>GitHub Copilot CLI vs Claude Code as Hive Workers — Munder Difflin Blog</title>+<meta name="description" content="How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both." />+<link rel="canonical" href="https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/" />++<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="GitHub Copilot CLI vs Claude Code as Hive Workers — Munder Difflin Blog" />+<meta property="og:description" content="How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both." />+<meta property="og:url" content="https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Comparisons" />+<meta property="article:tag" content="Claude Code" />+<meta property="article:tag" content="Copilot CLI" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Engines" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="GitHub Copilot CLI vs Claude Code as Hive Workers — Munder Difflin Blog" />+<meta name="twitter:description" content="How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both." />+<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": "GitHub Copilot CLI vs Claude Code as Hive Workers",+ "description": "How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/github-copilot-cli-vs-claude-code-for-hive-work/" },+ "keywords": "github copilot cli vs claude code, copilot cli multi-agent, claude code multi-agent harness, copilot cli print mode, agent engine comparison, copilot cli automation, claude code hooks",+ "articleSection": "Comparisons",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/"+}+</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": "GitHub Copilot CLI vs Claude Code as Hive Workers", "item": "https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Can GitHub Copilot CLI work as an agent in a multi-agent system?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, with a specific shape. Copilot CLI's documented programmatic mode (copilot -p) executes one prompt and exits after completion, which makes it excellent for dispatched, self-contained tasks: hand it a scoped job, it runs autonomously with --allow-all-tools and --no-ask-user, returns a result, and terminates. What it can't do in that mode is stay resident and react to incoming messages, because there is no long-lived process to deliver them to." } },+ { "@type": "Question", "name": "Why is Claude Code better suited to long-lived hive work?", "acceptedAnswer": { "@type": "Answer", "text": "Claude Code exposes lifecycle hooks that an external harness can attach to. In Munder Difflin, those hooks let the harness see every turn, gate actions for human approval, steer mid-run, and — critically — drain the agent's inbox at the end of each turn via the Stop hook, so a Claude worker picks up new mail without being respawned. That persistent, observable lifecycle is what makes it eligible to be a worker that converses, or the GOD orchestrator itself." } },+ { "@type": "Question", "name": "What happens when you send a message to a Copilot CLI worker in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "It doesn't silently disappear — it bounces to the GOD orchestrator. Because Copilot's print mode exits per turn, there's no resident process with a hook bridge to drain an inbox, so the provider is registered with canReceiveInbox set to false and routed mail is redirected to the orchestrator, which can re-dispatch the work as a fresh Copilot task or hand it to a hive-aware worker." } },+ { "@type": "Question", "name": "Does GitHub Copilot CLI have hooks of its own?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Copilot CLI supports hooks defined in JSON files (in .github/hooks/ per repo or ~/.copilot/hooks/ personally), including sessionStart and sessionEnd events, plus MCP servers and custom instructions. Munder Difflin's v0.3.3 integration doesn't bridge those into the hive yet — it drives the documented print mode, where the process exits after each prompt — so within the harness a Copilot worker is non-hive-aware by design." } },+ { "@type": "Question", "name": "How is Copilot CLI billed compared to Claude Code?", "acceptedAnswer": { "@type": "Answer", "text": "Copilot CLI authenticates with your existing GitHub Copilot login and consumes premium requests from your Copilot plan — GitHub documents one premium request per prompt on the default model, multiplied by the model's rate for others. Claude Code runs on your Anthropic plan or API key. Practically, that means a mixed hive spreads work across two subscriptions you may already be paying for." } },+ { "@type": "Question", "name": "Should I pick one engine or mix them?", "acceptedAnswer": { "@type": "Answer", "text": "Mix them. Use Claude Code for the orchestrator and long-lived workers that need to receive mail, converse across turns, and run under hook-driven guardrails. Use Copilot CLI workers for burst work: scoped, self-contained tasks dispatched by the orchestrator that finish in one shot. Munder Difflin lets you choose the engine per hire, so this is a per-agent decision, not a platform decision." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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/comparisons/">Comparisons</a>+ </nav>+ <h1>GitHub Copilot CLI vs Claude Code as Hive Workers</h1>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 min read</span>+ <span class="tag kind">Comparisons</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p>Inside a multi-agent harness, the engine question isn't "which CLI writes better code" — it's <strong>what lifecycle the process exposes</strong>. <strong>Claude Code</strong> runs as a long-lived session with native hooks, so Munder Difflin can gate it, steer it, <strong>drain its inbox on the Stop hook</strong>, and even make it the GOD orchestrator. <strong>GitHub Copilot CLI</strong> (new in v0.3.3) runs in its documented print mode — <code>copilot -p</code> — which <strong>exits after every prompt</strong>: brilliant for dispatched, self-contained tasks on your existing Copilot subscription, but with no resident process to receive mail, routed messages <strong>bounce to the orchestrator</strong> instead. Verdict: <strong>mix them</strong> — Claude as orchestrator and long-lived workers, Copilot for burst tasks.</p></div>+<p>Munder Difflin v0.3.3 added GitHub Copilot CLI as its seventh agent engine — the project’s first community-contributed provider (<a href="https://github.com/chaitanyagiri/munder-difflin/pull/101">PR #101</a> by @anxkhn). That makes a comparison suddenly practical rather than theoretical: you can hire a Claude Code worker and a Copilot worker onto the same floor and watch them behave differently. This post is about <em>that</em> difference — not “which model is smarter,” but how each CLI behaves as a <strong>worker inside a hive</strong>.</p>+<p>Both are genuinely good tools. The differences below are lifecycle differences, and lifecycle is what a harness cares about.</p>+<h2 id="the-thing-a-harness-actually-needs-from-an-engine" tabindex="-1">The thing a harness actually needs from an engine <a class="anchor" href="#the-thing-a-harness-actually-needs-from-an-engine" aria-hidden="true">#</a></h2>+<p>A <a href="/blog/what-is-a-multi-agent-harness/">multi-agent harness</a> wraps real CLI processes and coordinates them: routing messages between inboxes, gating destructive actions, tracking turns, waking idle agents when mail arrives. To do all that, it needs answers from the engine to three questions:</p>+<ol>+<li><strong>Does the process stay alive between turns?</strong> (Can it hold a conversation, or is every invocation a fresh start?)</li>+<li><strong>Does it emit lifecycle signals a harness can attach to?</strong> (Turn ended, tool about to run, session stopped?)</li>+<li><strong>Can it be interrupted, steered, and fed new input mid-stream?</strong></li>+</ol>+<p>Claude Code and Copilot CLI give very different answers — and neither answer is wrong. They’re different shapes for different jobs.</p>+<h2 id="claude-code-the-hive-aware-resident" tabindex="-1">Claude Code: the hive-aware resident <a class="anchor" href="#claude-code-the-hive-aware-resident" aria-hidden="true">#</a></h2>+<p>Claude Code runs as a persistent interactive session in its pseudo-terminal, and it exposes native hooks — external commands fired at lifecycle points. Munder Difflin leans on those hard:</p>+<ul>+<li><strong>Turn-end inbox drain.</strong> When a Claude worker finishes a turn, the Stop hook fires and the harness checks the agent’s mailbox. If mail is waiting, the agent drains it <em>in the same session</em> — no respawn, no lost context. This is what makes a worker conversational: other agents can message it and it will actually respond.</li>+<li><strong>Hook-driven guardrails.</strong> The human-in-the-loop gate, mid-run steering, and graceful stop are all driven through Claude Code hook returns — you can intervene without killing the session.</li>+<li><strong>Orchestrator eligibility.</strong> Because the process is long-lived and observable, Claude Code can be the <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> itself — the always-on supervisor that adjudicates traffic and routes tasks.</li>+</ul>+<p>If you want the deeper treatment of driving Claude Code as a coordinated fleet, see the <a href="/blog/claude-code-orchestration-guide/">Claude Code orchestration guide</a>.</p>+<h2 id="github-copilot-cli-the-burst-specialist" tabindex="-1">GitHub Copilot CLI: the burst specialist <a class="anchor" href="#github-copilot-cli-the-burst-specialist" aria-hidden="true">#</a></h2>+<p>GitHub Copilot CLI is GitHub’s terminal agent, and its docs describe two modes: an interactive session, and a <strong>programmatic mode</strong> built for scripting — per GitHub’s own reference, <code>-p</code> will “execute a prompt programmatically (exits after completion).” That exit-per-turn behavior is the documented design, and Munder Difflin drives it exactly as documented. The spawn shape from the v0.3.3 changelog:</p>+<pre><code>copilot -p "<prompt>" -s --allow-all-tools --no-ask-user [--model <id>]+</code></pre>+<p>Piece by piece: <code>-p</code> passes the task, <code>-s</code> (silent) outputs only the agent response, <code>--allow-all-tools</code> auto-approves tool use (GitHub notes it’s required for programmatic runs — and in Munder Difflin these auto-approval flags are gated by the floor’s auto-mode toggle, like every other engine), and <code>--no-ask-user</code> disables clarifying questions so the run is fully autonomous. There’s a model picker (Claude Sonnet 4.5 by default, GPT-5.4, or <code>auto</code>) and best-effort <code>--resume</code> session continuity.</p>+<p>Two things make Copilot workers genuinely attractive:</p>+<ul>+<li><strong>It’s on your existing subscription.</strong> Copilot CLI authenticates with your GitHub Copilot login — no new API key. GitHub bills it in premium requests (one per prompt on the default model, times the model’s multiplier), drawing from the allowance you may already have.</li>+<li><strong>Exit-per-turn is a feature for dispatched work.</strong> A scoped task arrives, the process runs it to completion with no residual state, and terminates cleanly. For burst tasks, that’s exactly what you want.</li>+</ul>+<p>The honest limitation: with no resident process between turns, there’s nothing to deliver inbox mail <em>to</em>. So in Munder Difflin, Copilot’s provider is registered non-hive-aware (<code>canReceiveInbox: false</code>), and routed mail <strong>bounces to the GOD orchestrator</strong> instead of silently dropping. The orchestrator can then re-dispatch it as a fresh Copilot task or hand it to a hive-aware worker.</p>+<p>To be fair to Copilot CLI: the tool itself is more extensible than the print-mode integration uses. GitHub ships its own hooks system (JSON files in <code>.github/hooks/</code> or <code>~/.copilot/hooks/</code>, with <code>sessionStart</code>/<code>sessionEnd</code> events), MCP server support, and custom instructions. A deeper bridge is conceivable; v0.3.3 ships the documented, honest version.</p>+<h2 id="verdict-dont-pick-mix" tabindex="-1">Verdict: don’t pick — mix <a class="anchor" href="#verdict-dont-pick-mix" aria-hidden="true">#</a></h2>+<p>The comparison table writes itself once you frame it as lifecycle:</p>+<table>+<thead>+<tr>+<th></th>+<th>Claude Code</th>+<th>GitHub Copilot CLI</th>+</tr>+</thead>+<tbody>+<tr>+<td>Process lifetime</td>+<td>Long-lived session</td>+<td>Exits after each prompt (<code>-p</code>)</td>+</tr>+<tr>+<td>Harness hook bridge</td>+<td>Native hooks (incl. Stop-hook inbox drain)</td>+<td>None in print mode</td>+</tr>+<tr>+<td>Receives hive mail</td>+<td>Yes, drains inbox in-session</td>+<td>No — bounces to orchestrator</td>+</tr>+<tr>+<td>Orchestrator-eligible</td>+<td>Yes</td>+<td>No</td>+</tr>+<tr>+<td>Auth</td>+<td>Anthropic plan / API key</td>+<td>Existing GitHub Copilot login</td>+</tr>+<tr>+<td>Sweet spot</td>+<td>Orchestrator, conversational workers</td>+<td>Dispatched, self-contained burst tasks</td>+</tr>+</tbody>+</table>+<p>Because Munder Difflin makes the engine a per-hire choice, this isn’t an either/or. The pattern that works: <strong>Claude Code as the orchestrator and your long-lived workers</strong> — the agents that need to receive messages, hold context across turns, and run under hook-driven approval gates — and <strong>Copilot CLI workers for burst tasks</strong> the orchestrator dispatches: a scoped refactor, a test-writing pass, a one-shot investigation. Different engines for different roles is the general lesson of mixed fleets, and it also spreads cost across two subscriptions you likely already pay for.</p>+<p>For everything else in the release — including the built-in Monaco IDE — see the <a href="/blog/launching-munder-difflin-v0-3-3/">v0.3.3 launch post</a>.</p>+<h2 id="try-both-on-one-floor" tabindex="-1">Try both on one floor <a class="anchor" href="#try-both-on-one-floor" aria-hidden="true">#</a></h2>+<p>Hire a Claude worker and a Copilot worker side by side and watch the difference yourself — <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">download Munder Difflin</a> (free, MIT, local-first), and if it’s useful, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>+<p>Sources: <a href="https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-command-reference">GitHub Docs — Copilot CLI command reference</a>;+<a href="https://docs.github.com/en/copilot/how-tos/copilot-cli/automate-copilot-cli/run-cli-programmatically">GitHub Docs — Running Copilot CLI programmatically</a>;+<a href="https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli">GitHub Docs — About Copilot CLI</a>;+<a href="https://docs.github.com/en/copilot/concepts/agents/hooks">GitHub Docs — Hooks for Copilot</a>;+<a href="https://docs.github.com/en/copilot/concepts/billing/copilot-requests">GitHub Docs — Copilot premium requests</a>.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Can GitHub Copilot CLI work as an agent in a multi-agent system?</p>+ <p class="a">Yes, with a specific shape. Copilot CLI's documented programmatic mode (copilot -p) executes one prompt and exits after completion, which makes it excellent for dispatched, self-contained tasks: hand it a scoped job, it runs autonomously with --allow-all-tools and --no-ask-user, returns a result, and terminates. What it can't do in that mode is stay resident and react to incoming messages, because there is no long-lived process to deliver them to.</p>+ </div>++ <div class="qa">+ <p class="q">Why is Claude Code better suited to long-lived hive work?</p>+ <p class="a">Claude Code exposes lifecycle hooks that an external harness can attach to. In Munder Difflin, those hooks let the harness see every turn, gate actions for human approval, steer mid-run, and — critically — drain the agent's inbox at the end of each turn via the Stop hook, so a Claude worker picks up new mail without being respawned. That persistent, observable lifecycle is what makes it eligible to be a worker that converses, or the GOD orchestrator itself.</p>+ </div>++ <div class="qa">+ <p class="q">What happens when you send a message to a Copilot CLI worker in Munder Difflin?</p>+ <p class="a">It doesn't silently disappear — it bounces to the GOD orchestrator. Because Copilot's print mode exits per turn, there's no resident process with a hook bridge to drain an inbox, so the provider is registered with canReceiveInbox set to false and routed mail is redirected to the orchestrator, which can re-dispatch the work as a fresh Copilot task or hand it to a hive-aware worker.</p>+ </div>++ <div class="qa">+ <p class="q">Does GitHub Copilot CLI have hooks of its own?</p>+ <p class="a">Yes. Copilot CLI supports hooks defined in JSON files (in .github/hooks/ per repo or ~/.copilot/hooks/ personally), including sessionStart and sessionEnd events, plus MCP servers and custom instructions. Munder Difflin's v0.3.3 integration doesn't bridge those into the hive yet — it drives the documented print mode, where the process exits after each prompt — so within the harness a Copilot worker is non-hive-aware by design.</p>+ </div>++ <div class="qa">+ <p class="q">How is Copilot CLI billed compared to Claude Code?</p>+ <p class="a">Copilot CLI authenticates with your existing GitHub Copilot login and consumes premium requests from your Copilot plan — GitHub documents one premium request per prompt on the default model, multiplied by the model's rate for others. Claude Code runs on your Anthropic plan or API key. Practically, that means a mixed hive spreads work across two subscriptions you may already be paying for.</p>+ </div>++ <div class="qa">+ <p class="q">Should I pick one engine or mix them?</p>+ <p class="a">Mix them. Use Claude Code for the orchestrator and long-lived workers that need to receive mail, converse across turns, and run under hook-driven guardrails. Use Copilot CLI workers for burst work: scoped, self-contained tasks dispatched by the orchestrator that finish in one shot. Munder Difflin lets you choose the engine per hire, so this is a per-agent decision, not a platform decision.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/comparisons/">Comparisons</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a><a class="tag" href="/blog/tags/copilot-cli/">Copilot CLI</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/engines/">Engines</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-thing-a-harness-actually-needs-from-an-engine">The thing a harness actually needs from an engine</a></li><li class="lvl-2"><a href="#claude-code-the-hive-aware-resident">Claude Code: the hive-aware resident</a></li><li class="lvl-2"><a href="#github-copilot-cli-the-burst-specialist">GitHub Copilot CLI: the burst specialist</a></li><li class="lvl-2"><a href="#verdict-dont-pick-mix">Verdict: don’t pick — mix</a></li><li class="lvl-2"><a href="#try-both-on-one-floor">Try both on one floor</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/how-to-add-a-github-copilot-cli-agent/"><span class="k">← Older</span><span class="t">How to Add a GitHub Copilot CLI Agent to Your Floor</span></a>+ <a class="pn next" href="/blog/crewai-autogen-vs-a-local-agent-harness/"><span class="k">Newer →</span><span class="t">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</span></a>+ </div>+ <section class="related">+ <h2>Related in Comparisons</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/how-ai-agents-verify-their-own-work/index.html b/docs/blog/how-ai-agents-verify-their-own-work/index.htmlindex 186e67e5..8e574449 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@@ -273,56 +273,56 @@ and open source.</p><h2>Related in Concepts</h2><div class="post-grid"><article class="card">- <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/how-ai-answer-engines-choose-sources/index.html b/docs/blog/how-ai-answer-engines-choose-sources/index.htmlindex 292a3460..55142a80 100644--- a/docs/blog/how-ai-answer-engines-choose-sources/index.html+++ b/docs/blog/how-ai-answer-engines-choose-sources/index.html@@ -266,56 +266,56 @@ broader map of the tooling AI engines cite, see our<h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/how-to-add-a-github-copilot-cli-agent/index.html b/docs/blog/how-to-add-a-github-copilot-cli-agent/index.htmlnew file mode 100644index 00000000..c3560357--- /dev/null+++ b/docs/blog/how-to-add-a-github-copilot-cli-agent/index.html@@ -0,0 +1,344 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>How to Add a GitHub Copilot CLI Agent to Your Floor — Munder Difflin Blog</title>+<meta name="description" content="A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do." />+<link rel="canonical" href="https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-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="How to Add a GitHub Copilot CLI Agent to Your Floor — Munder Difflin Blog" />+<meta property="og:description" content="A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do." />+<meta property="og:url" content="https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="GitHub Copilot" />+<meta property="article:tag" content="CLI Agents" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Engines" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="How to Add a GitHub Copilot CLI Agent to Your Floor — Munder Difflin Blog" />+<meta name="twitter:description" content="A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do." />+<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 Add a GitHub Copilot CLI Agent to Your Floor",+ "description": "A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/how-to-add-a-github-copilot-cli-agent/" },+ "keywords": "github copilot cli agent, add github copilot cli agent, copilot cli multi-agent, copilot -p print mode, github copilot cli munder difflin, copilot cli model picker",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-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": "How to Add a GitHub Copilot CLI Agent to Your Floor", "item": "https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-agent/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Do I need a new API key to run a GitHub Copilot CLI agent in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "No. The Copilot engine authenticates through your existing GitHub Copilot login — the same auth the copilot CLI uses in a plain terminal. There is no BYOK key to paste into Settings for this engine; if you can run copilot in your shell, you can hire it on the floor." } },+ { "@type": "Question", "name": "What models can a Copilot CLI agent use?", "acceptedAnswer": { "@type": "Answer", "text": "The Add Agent flow includes a model picker for the Copilot engine with three options: Claude Sonnet 4.5 (the default), GPT-5.4, and auto, which lets Copilot choose. Your selection is passed to the CLI via the --model flag on every turn." } },+ { "@type": "Question", "name": "Why does my Copilot agent's inbox mail go to the orchestrator instead?", "acceptedAnswer": { "@type": "Answer", "text": "By design. Copilot CLI runs in non-interactive print mode, which exits after each turn and exposes no hook bridge, so a Copilot worker cannot sit idle and drain a mailbox. Rather than letting routed mail silently drop, the harness bounces it to the GOD orchestrator, which handles or re-routes it. Use Copilot workers for dispatched, self-contained tasks and they work great." } },+ { "@type": "Question", "name": "What does the auto-mode toggle change for Copilot agents?", "acceptedAnswer": { "@type": "Answer", "text": "In auto mode the harness adds Copilot's auto-approval flags (-s --allow-all-tools --no-ask-user) so the agent can use tools without stopping to ask. With auto mode off, those flags are omitted and Copilot runs more conservatively — the same gating every other engine on the floor gets." } },+ { "@type": "Question", "name": "Does a Copilot agent keep context between turns if print mode exits every time?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, best-effort. The engine uses Copilot CLI's --resume flag to reattach the previous session on the next turn, so follow-up prompts land in the same conversation rather than starting cold. It is session continuity, not a persistent process." } },+ { "@type": "Question", "name": "Who built the Copilot engine?", "acceptedAnswer": { "@type": "Answer", "text": "It's the first community-contributed provider in Munder Difflin — PR #101 by @anxkhn, shipped in v0.3.3. The engine registers Copilot as a provider preset alongside Claude Code, Codex, Antigravity, OpenCode, Crush, and pi.dev, and comes with a self-contained registry test asserting the command shape." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 Add a GitHub Copilot CLI Agent to Your Floor</h1>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>4 min read</span>+ <span 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>As of <strong>v0.3.3</strong>, GitHub Copilot CLI is a first-class agent engine in Munder Difflin — the project's <strong>first community-contributed provider</strong> (PR #101 by @anxkhn). Install <code>@github/copilot</code> (or let the harness's missing-CLI installer do it), hit <strong>Add Agent</strong>, pick the Copilot engine, choose a model (<strong>Claude Sonnet 4.5 default, GPT-5.4, or auto</strong>), and it authenticates with your <strong>existing Copilot login — no new keys</strong>. One honest caveat: Copilot runs in <strong>print mode</strong> (<code>copilot -p</code>), which exits per turn, so its workers can't drain inbox mail — routed mail <strong>bounces to the orchestrator</strong> instead of dropping. Use Copilot workers for <strong>dispatched, self-contained tasks</strong>.</p></div>+<p>If you already pay for GitHub Copilot, you have an agent engine sitting in your subscription that most people only ever use as autocomplete. Copilot CLI is the terminal version — a real coding agent you run with <code>copilot</code> — and since <a href="/blog/launching-munder-difflin-v0-3-3/">v0.3.3</a>, Munder Difflin can hire it onto the floor next to your Claude Code, Codex, and OpenCode workers.</p>+<p>This guide walks the whole path: install, hire, model choice, what auto-mode changes, and the one behavioral caveat you should understand before you assign work.</p>+<h2 id="step-0-have-the-floor-running" tabindex="-1">Step 0: have the floor running <a class="anchor" href="#step-0-have-the-floor-running" aria-hidden="true">#</a></h2>+<p>You need Munder Difflin itself first — if you don’t, <a href="/blog/how-to-install-and-use-munder-difflin/">the install guide</a> covers it in a few minutes. Everything below assumes you’re looking at the office floor with Michael seated in his office.</p>+<h2 id="step-1-install-copilot-cli-or-dont-the-harness-will-offer" tabindex="-1">Step 1: install Copilot CLI (or don’t — the harness will offer) <a class="anchor" href="#step-1-install-copilot-cli-or-dont-the-harness-will-offer" aria-hidden="true">#</a></h2>+<p>The engine drives the official npm package:</p>+<pre class="language-bash"><code class="language-bash"><span class="token function">npm</span> <span class="token function">install</span> <span class="token parameter variable">-g</span> @github/copilot</code></pre>+<p>Then log in once with your GitHub account if you haven’t (<code>copilot</code> walks you through it on first run). That’s the entire auth story: <strong>the engine uses your existing GitHub Copilot login, no new keys</strong>, nothing to paste into Settings → AI Engines.</p>+<p>You can also skip this step entirely. Munder Difflin has a self-healing installer for missing engine CLIs: if you pick Copilot in Add Agent and the <code>copilot</code> binary isn’t on your <code>PATH</code>, the harness offers the official <code>npm install -g @github/copilot</code>, runs it in the terminal, then auto restarts-and-continues into the freshly installed binary. No dead end, no manual retry.</p>+<h2 id="step-2-add-agent-pick-copilot" tabindex="-1">Step 2: Add Agent, pick Copilot <a class="anchor" href="#step-2-add-agent-pick-copilot" aria-hidden="true">#</a></h2>+<p>Click <strong>Add Agent</strong> on the floor. The visual provider picker now lists GitHub Copilot CLI alongside the other six engines. Pick it, name your hire, choose a working directory — and if you flip the git-isolation toggle, the agent gets its own dedicated worktree so it never collides with other agents on branches (more on why that matters in <a href="/blog/claude-code-git-worktrees-vs-hive/">worktrees vs the hive</a>).</p>+<p>Here’s the whole hire flow in nineteen seconds:</p>+<video controls preload="none" playsinline poster="/media/demo/agents-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/agents.mp4" type="video/mp4" />+</video>+<p>Copilot hires also work through voice — Realtime Michael’s <code>spawn</code> action can hire one — and if you paste a raw <code>copilot ...</code> command into the custom-command field, the harness infers the binary and treats it as a Copilot engine.</p>+<h2 id="step-3-choose-a-model" tabindex="-1">Step 3: choose a model <a class="anchor" href="#step-3-choose-a-model" aria-hidden="true">#</a></h2>+<p>The Copilot engine ships with a model picker, <code>COPILOT_MODELS</code>, with three options:</p>+<ul>+<li><strong>Claude Sonnet 4.5</strong> — the default.</li>+<li><strong>GPT-5.4</strong> — if you’d rather run OpenAI’s model.</li>+<li><strong>auto</strong> — let Copilot pick per request.</li>+</ul>+<p>Whatever you choose is passed through as <code>--model <id></code> on each turn. This is a per-hire choice, so you can run one Copilot worker on Sonnet and another on GPT-5.4 and compare them on the same board.</p>+<h2 id="what-auto-mode-gates" tabindex="-1">What auto-mode gates <a class="anchor" href="#what-auto-mode-gates" aria-hidden="true">#</a></h2>+<p>Under the hood, every turn a Copilot agent takes is Copilot CLI’s documented non-interactive <strong>print mode</strong>:</p>+<pre class="language-bash"><code class="language-bash">copilot <span class="token parameter variable">-p</span> <span class="token string">"<prompt>"</span> <span class="token parameter variable">-s</span> --allow-all-tools --no-ask-user <span class="token punctuation">[</span>--model <span class="token operator"><</span>id<span class="token operator">></span><span class="token punctuation">]</span></code></pre>+<p>The auto-approval flags — <code>-s --allow-all-tools --no-ask-user</code> — are <strong>gated by the floor’s auto-mode toggle</strong>, exactly like every other engine. Auto-mode on: Copilot gets its documented allow-all flags and works without stopping to ask permission per tool call. Auto-mode off: the flags are omitted and the agent runs conservatively. The floor-level guardrails — <a href="/blog/human-in-the-loop-approving-ai-agents/">the approvals queue</a>, budgets, the circuit breaker — sit above all of that regardless of engine.</p>+<p>Session continuity is handled with <code>--resume</code> (best-effort): print mode exits after every turn, but the next turn reattaches the prior session, so follow-ups don’t start cold.</p>+<h2 id="the-honest-inbox-caveat" tabindex="-1">The honest inbox caveat <a class="anchor" href="#the-honest-inbox-caveat" aria-hidden="true">#</a></h2>+<p>This is the part worth reading twice. Print mode <strong>exits per turn and exposes no hook bridge</strong>, which means a Copilot worker can’t do the thing hive-aware engines do: sit idle, notice mail in its inbox, and drain it. The engine is registered as non-hive-aware (<code>canReceiveInbox: false</code>) on purpose.</p>+<p>So what happens when another agent routes a message to your Copilot worker? It <strong>bounces to the GOD orchestrator</strong> instead of silently dropping. Michael sees the bounced mail and handles or re-routes it — the message survives, it just doesn’t land in a mailbox nobody is checking. (If you’re new to how Michael adjudicates traffic, <a href="/blog/how-the-god-orchestrator-works/">the GOD orchestrator post</a> explains the routing model.)</p>+<p>The practical rule: <strong>use Copilot workers for dispatched, self-contained tasks.</strong> “Take this issue, fix it, report back” is their sweet spot. Long-running conversational back-and-forth between agents is not — hand that to a hive-aware engine. Shipping the limitation honestly, with a bounce path instead of a black hole, was a deliberate design call in PR #101, and it’s the right one.</p>+<h2 id="recap" tabindex="-1">Recap <a class="anchor" href="#recap" aria-hidden="true">#</a></h2>+<ol>+<li><code>npm install -g @github/copilot</code> — or let the missing-CLI installer offer it.</li>+<li><strong>Add Agent</strong> → pick the Copilot engine → optionally flip git isolation.</li>+<li>Pick a model: Claude Sonnet 4.5 (default), GPT-5.4, or auto.</li>+<li>Know the shape: print mode per turn, <code>--resume</code> continuity, auto-mode gates the approval flags.</li>+<li>Assign dispatched, self-contained tasks; let mail-heavy coordination live on hive-aware engines.</li>+</ol>+<p>That’s a seventh engine on your floor, powered by a subscription you already have.</p>+<h2 id="try-it" tabindex="-1">Try it <a class="anchor" href="#try-it" aria-hidden="true">#</a></h2>+<p>Grab the latest build from <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">the releases page</a> — and if the Copilot engine saves you a hire, a <a href="https://github.com/chaitanyagiri/munder-difflin">star on GitHub</a> is how community contributions like PR #101 keep coming.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Do I need a new API key to run a GitHub Copilot CLI agent in Munder Difflin?</p>+ <p class="a">No. The Copilot engine authenticates through your existing GitHub Copilot login — the same auth the copilot CLI uses in a plain terminal. There is no BYOK key to paste into Settings for this engine; if you can run copilot in your shell, you can hire it on the floor.</p>+ </div>++ <div class="qa">+ <p class="q">What models can a Copilot CLI agent use?</p>+ <p class="a">The Add Agent flow includes a model picker for the Copilot engine with three options: Claude Sonnet 4.5 (the default), GPT-5.4, and auto, which lets Copilot choose. Your selection is passed to the CLI via the --model flag on every turn.</p>+ </div>++ <div class="qa">+ <p class="q">Why does my Copilot agent's inbox mail go to the orchestrator instead?</p>+ <p class="a">By design. Copilot CLI runs in non-interactive print mode, which exits after each turn and exposes no hook bridge, so a Copilot worker cannot sit idle and drain a mailbox. Rather than letting routed mail silently drop, the harness bounces it to the GOD orchestrator, which handles or re-routes it. Use Copilot workers for dispatched, self-contained tasks and they work great.</p>+ </div>++ <div class="qa">+ <p class="q">What does the auto-mode toggle change for Copilot agents?</p>+ <p class="a">In auto mode the harness adds Copilot's auto-approval flags (-s --allow-all-tools --no-ask-user) so the agent can use tools without stopping to ask. With auto mode off, those flags are omitted and Copilot runs more conservatively — the same gating every other engine on the floor gets.</p>+ </div>++ <div class="qa">+ <p class="q">Does a Copilot agent keep context between turns if print mode exits every time?</p>+ <p class="a">Yes, best-effort. The engine uses Copilot CLI's --resume flag to reattach the previous session on the next turn, so follow-up prompts land in the same conversation rather than starting cold. It is session continuity, not a persistent process.</p>+ </div>++ <div class="qa">+ <p class="q">Who built the Copilot engine?</p>+ <p class="a">It's the first community-contributed provider in Munder Difflin — PR #101 by @anxkhn, shipped in v0.3.3. The engine registers Copilot as a provider preset alongside Claude Code, Codex, Antigravity, OpenCode, Crush, and pi.dev, and comes with a self-contained registry test asserting the command shape.</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/github-copilot/">GitHub Copilot</a><a class="tag" href="/blog/tags/cli-agents/">CLI Agents</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/engines/">Engines</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="#step-0-have-the-floor-running">Step 0: have the floor running</a></li><li class="lvl-2"><a href="#step-1-install-copilot-cli-or-dont-the-harness-will-offer">Step 1: install Copilot CLI (or don’t — the harness will offer)</a></li><li class="lvl-2"><a href="#step-2-add-agent-pick-copilot">Step 2: Add Agent, pick Copilot</a></li><li class="lvl-2"><a href="#step-3-choose-a-model">Step 3: choose a model</a></li><li class="lvl-2"><a href="#what-auto-mode-gates">What auto-mode gates</a></li><li class="lvl-2"><a href="#the-honest-inbox-caveat">The honest inbox caveat</a></li><li class="lvl-2"><a href="#recap">Recap</a></li><li class="lvl-2"><a href="#try-it">Try it</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/how-to-hire-from-the-agent-gallery/"><span class="k">← Older</span><span class="t">How to Hire From the Agent Gallery</span></a>+ <a class="pn next" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/"><span class="k">Newer →</span><span class="t">GitHub Copilot CLI vs Claude Code as Hive Workers</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/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/how-to-choose-a-multi-agent-tool/index.html b/docs/blog/how-to-choose-a-multi-agent-tool/index.htmlindex 70b55625..68aef3cd 100644--- a/docs/blog/how-to-choose-a-multi-agent-tool/index.html+++ b/docs/blog/how-to-choose-a-multi-agent-tool/index.html@@ -279,56 +279,56 @@ local-first.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/how-to-hire-from-the-agent-gallery/index.html b/docs/blog/how-to-hire-from-the-agent-gallery/index.htmlnew file mode 100644index 00000000..b59b4293--- /dev/null+++ b/docs/blog/how-to-hire-from-the-agent-gallery/index.html@@ -0,0 +1,331 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>How to Hire From the Agent Gallery — Munder Difflin Blog</title>+<meta name="description" content="A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself." />+<link rel="canonical" href="https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/" />++<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 Hire From the Agent Gallery — Munder Difflin Blog" />+<meta property="og:description" content="A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself." />+<meta property="og:url" content="https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Agent Design" />+<meta property="article:tag" content="Getting Started" />+<meta property="article:tag" content="Security" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="How to Hire From the Agent Gallery — Munder Difflin Blog" />+<meta name="twitter:description" content="A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself." />+<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 Hire From the Agent Gallery",+ "description": "A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/how-to-hire-from-the-agent-gallery/" },+ "keywords": "agent gallery, hire an ai agent, off-the-shelf agent roles, import agent manifest, munder difflin hires, ready-made ai coworkers",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/"+}+</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 Hire From the Agent Gallery", "item": "https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is the Agent Gallery?", "acceptedAnswer": { "@type": "Answer", "text": "It's a free gallery of ready-made agent roles for Munder Difflin at munderdiffl.in/hires — no login, no trackers. Each role, called a hire, is a small JSON manifest that packages a configured agent: name, avatar, provider, model, flags, a goal, capability tags, and a token budget. It ships with six off-the-shelf hires you can import in one click and adapt to your project." } },+ { "@type": "Question", "name": "Does importing a hire from the gallery start an agent automatically?", "acceptedAnswer": { "@type": "Answer", "text": "No. Import only pre-fills the Add-Agent modal behind an explicit imported banner. You review every field, change anything you like, and the agent spawns only when you click spawn. There is no code path that runs an agent on import — the human is always the spawn gate." } },+ { "@type": "Question", "name": "Is it safe to import a hire manifest someone sent me?", "acceptedAnswer": { "@type": "Answer", "text": "The import pipeline is built on the assumption that it isn't — every manifest is validated as untrusted input. There is no executable field, so a manifest can never name a program to run; command flags pass a default-deny allowlist; and deep-link fetches are https-only and bounded. Even after all that, you still review the pre-filled form before anything spawns. Treat the goal text with the same skepticism you'd give any file from the internet." } },+ { "@type": "Question", "name": "Can I change the engine or model a gallery hire uses?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The manifest is a starting point, not a lock. In the Add-Agent modal you can switch the hire onto any engine you have — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI — pick a different model, and on local-capable engines use the OSS-model quick-picks to run it on open models via Ollama or a BYOK provider." } },+ { "@type": "Question", "name": "What should I customize before spawning a hire?", "acceptedAnswer": { "@type": "Answer", "text": "Four things. Identity: the name and avatar you'll recognize on the floor. Workspace: the working directory it operates in, ideally with the git-isolation toggle on so it gets its own worktree. Engine: the CLI and model that match the job's difficulty and your budget. Briefing: rewrite the goal so it names your repo, your conventions, and what done means — a generic goal produces generic work." } },+ { "@type": "Question", "name": "How much does hiring from the gallery cost?", "acceptedAnswer": { "@type": "Answer", "text": "The gallery and the app are free and open source (MIT-licensed code). You pay only for the model usage of whatever CLI or key the agent runs on. Every hire carries a token budget field, and the harness pairs per-agent budgets with live fleet monitoring and a circuit breaker, so an imported role can't quietly outspend the ceiling you gave it." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 Hire From the Agent Gallery</h1>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>The <strong>Agent Gallery</strong> (<a href="https://munderdiffl.in/hires/">munderdiffl.in/hires</a>) is where you hire ready-made AI coworkers for Munder Difflin — it ships with <strong>six off-the-shelf hires</strong>. A hire is a small JSON manifest: provider, model, flags, goal, capabilities, token budget. Importing one — by <code>munderdifflin://hire</code> link or a local file — <strong>never runs anything</strong>: it only pre-fills the Add-Agent modal behind an "imported" banner, and the manifest is <strong>validated as untrusted input</strong> along the way. You review, customize the <strong>identity, workspace, engine, and briefing</strong>, and <em>you</em> click spawn. Five minutes from browsing to a working agent on your floor.</p></div>+<p>The slowest part of running a multi-agent office isn’t running the agents. It’s the blank Add-Agent form: which engine, which model, which flags, and — the one that actually stalls people — what is this thing’s <em>job</em>? The Agent Gallery exists so you never start from that blank box. You start from a role somebody already got right, and you edit.</p>+<p>This is the practical walkthrough: browse, import, review, customize, spawn. (If you haven’t installed the app yet, do <a href="/blog/how-to-install-and-use-munder-difflin/">that first</a> — the gallery assumes you have a floor to hire onto.)</p>+<h2 id="step-1-browse-the-gallery" tabindex="-1">Step 1: Browse the gallery <a class="anchor" href="#step-1-browse-the-gallery" aria-hidden="true">#</a></h2>+<p>The gallery lives at <a href="https://munderdiffl.in/hires/">munderdiffl.in/hires</a> — a static page, no login, no trackers. It’s stocked with <strong>six off-the-shelf hires</strong>, each a complete role: a PR reviewer, a docs writer, a QA enforcer, a security auditor, a token-spend auditor, and a migrations grinder, each fronted by a pixel avatar from the app’s affectionate Office parody cast.</p>+<p>Every card tells you what you’re getting before you click anything: the role’s goal, its capability tags, and which provider it’s written for. Don’t overthink the choice — you’re picking a starting point, not signing a contract. Everything on the card is editable after import.</p>+<h2 id="step-2-import-the-hire" tabindex="-1">Step 2: Import the hire <a class="anchor" href="#step-2-import-the-hire" aria-hidden="true">#</a></h2>+<p>Two ways in, both landing in the same place:</p>+<ul>+<li><strong>Deep link.</strong> Click the hire button on a card and the <code>munderdifflin://hire</code> link opens the app directly.</li>+<li><strong>Local file.</strong> Save the manifest JSON (or receive one from a teammate) and import it from disk.</li>+</ul>+<p>Either way, one thing is worth being precise about: <strong>import never spawns anything.</strong> What opens is the app’s ordinary Add-Agent modal, pre-filled with the manifest’s values and marked with an explicit <strong>“imported” banner</strong> so you know these fields came from outside. The agent starts only when you click spawn. A hire you got from the internet is inert data until a human acts on it.</p>+<p>That’s not an accident of UI — it’s a security posture. A manifest arrives by clicked link or downloaded file, which makes it attacker-controlled bytes, and the import pipeline treats it that way: there’s <strong>no executable field</strong> (the binary always comes from your own locally configured provider presets), command flags pass a <strong>default-deny allowlist</strong>, and the deep-link fetch is <strong>https-only and bounded</strong>. The full threat model is its own post: <a href="/blog/hire-manifest-untrusted-input/">treating a hire manifest as untrusted input</a>.</p>+<h2 id="step-3-actually-read-the-manifest" tabindex="-1">Step 3: Actually read the manifest <a class="anchor" href="#step-3-actually-read-the-manifest" aria-hidden="true">#</a></h2>+<p>The imported banner is your cue to slow down for thirty seconds. A hire manifest encodes the whole role — name, avatar, provider, model, command flags, goal, capability tags, and a token budget — and every one of those is now sitting in front of you as a form field. Read them like you’d read a job description before forwarding it to HR:</p>+<ul>+<li><strong>Goal text</strong> is the prompt this agent will work from. It’s free text from someone else, which makes it the one field validation can’t vouch for. If anything in it looks off, rewrite it.</li>+<li><strong>Model and flags</strong> tell you what it costs to run and how it behaves. The allowlist keeps flags safe; it doesn’t make them right for you.</li>+<li><strong>Token budget</strong> is the spend ceiling the author suggested. Set it to what <em>you</em> are comfortable with — the harness enforces per-agent budgets with live fleet monitoring and a circuit breaker behind it.</li>+</ul>+<h2 id="step-4-customize-the-four-things-that-matter" tabindex="-1">Step 4: Customize the four things that matter <a class="anchor" href="#step-4-customize-the-four-things-that-matter" aria-hidden="true">#</a></h2>+<p>A gallery hire is deliberately generic. Four edits turn it into <em>your</em> hire:</p>+<p><strong>Identity.</strong> Rename it and pick the avatar you want to see walking the floor. This sounds cosmetic; it isn’t. When six agents are working at once, you triage by face and name.</p>+<p><strong>Workspace.</strong> Point the hire at the repo it should work in, and flip on the <strong>git isolation</strong> toggle so it auto-provisions its own worktree on spawn — agents that share a checkout collide on branches; agents with worktrees don’t (<a href="/blog/claude-code-git-worktrees-vs-hive/">why worktrees, in depth</a>).</p>+<p><strong>Engine.</strong> The manifest names a provider, but the modal’s picker is yours: run the role on Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. Match the engine to the job — and if the role is routine enough, the local-capable engines surface <strong>OSS-model quick-picks</strong> so it can run on open models for pennies.</p>+<p><strong>Briefing.</strong> Rewrite the goal until it names your project, your conventions, and what “done” looks like. This is the highest-leverage sixty seconds of the whole flow: a hire that arrives with “review pull requests” leaves with “review PRs on repo X, enforce the lint config, never approve without a green typecheck.”</p>+<p>One more gate you’ll meet after spawning: hires carry a manifest of allowed <strong>skills and MCP servers</strong>, default-deny over a shared catalog. Anything the hire wants to use surfaces in a consent UI for you to grant — imported input is reviewed, never auto-granted.</p>+<h2 id="step-5-spawn-and-put-it-to-work" tabindex="-1">Step 5: Spawn, and put it to work <a class="anchor" href="#step-5-spawn-and-put-it-to-work" aria-hidden="true">#</a></h2>+<p>Click spawn. The agent appears at a desk, joins the hive with its own mailbox and long-term memory, and is immediately routable: assign it kanban tasks, or just tell the GOD orchestrator what you need and let <a href="/blog/how-the-god-orchestrator-works/">Michael route the work</a>.</p>+<p>From browsing a card to a working coworker is genuinely a five-minute path — and every minute of it kept you in the loop: you read the manifest, you set the budget, you clicked spawn.</p>+<p>Grab the latest build from the <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">releases page</a>, and if the gallery saves you a blank-form afternoon, a <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub star</a> is appreciated.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is the Agent Gallery?</p>+ <p class="a">It's a free gallery of ready-made agent roles for Munder Difflin at munderdiffl.in/hires — no login, no trackers. Each role, called a hire, is a small JSON manifest that packages a configured agent: name, avatar, provider, model, flags, a goal, capability tags, and a token budget. It ships with six off-the-shelf hires you can import in one click and adapt to your project.</p>+ </div>++ <div class="qa">+ <p class="q">Does importing a hire from the gallery start an agent automatically?</p>+ <p class="a">No. Import only pre-fills the Add-Agent modal behind an explicit imported banner. You review every field, change anything you like, and the agent spawns only when you click spawn. There is no code path that runs an agent on import — the human is always the spawn gate.</p>+ </div>++ <div class="qa">+ <p class="q">Is it safe to import a hire manifest someone sent me?</p>+ <p class="a">The import pipeline is built on the assumption that it isn't — every manifest is validated as untrusted input. There is no executable field, so a manifest can never name a program to run; command flags pass a default-deny allowlist; and deep-link fetches are https-only and bounded. Even after all that, you still review the pre-filled form before anything spawns. Treat the goal text with the same skepticism you'd give any file from the internet.</p>+ </div>++ <div class="qa">+ <p class="q">Can I change the engine or model a gallery hire uses?</p>+ <p class="a">Yes. The manifest is a starting point, not a lock. In the Add-Agent modal you can switch the hire onto any engine you have — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI — pick a different model, and on local-capable engines use the OSS-model quick-picks to run it on open models via Ollama or a BYOK provider.</p>+ </div>++ <div class="qa">+ <p class="q">What should I customize before spawning a hire?</p>+ <p class="a">Four things. Identity: the name and avatar you'll recognize on the floor. Workspace: the working directory it operates in, ideally with the git-isolation toggle on so it gets its own worktree. Engine: the CLI and model that match the job's difficulty and your budget. Briefing: rewrite the goal so it names your repo, your conventions, and what done means — a generic goal produces generic work.</p>+ </div>++ <div class="qa">+ <p class="q">How much does hiring from the gallery cost?</p>+ <p class="a">The gallery and the app are free and open source (MIT-licensed code). You pay only for the model usage of whatever CLI or key the agent runs on. Every hire carries a token budget field, and the harness pairs per-agent budgets with live fleet monitoring and a circuit breaker, so an imported role can't quietly outspend the ceiling you gave it.</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/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/agent-design/">Agent Design</a><a class="tag" href="/blog/tags/getting-started/">Getting Started</a><a class="tag" href="/blog/tags/security/">Security</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="#step-1-browse-the-gallery">Step 1: Browse the gallery</a></li><li class="lvl-2"><a href="#step-2-import-the-hire">Step 2: Import the hire</a></li><li class="lvl-2"><a href="#step-3-actually-read-the-manifest">Step 3: Actually read the manifest</a></li><li class="lvl-2"><a href="#step-4-customize-the-four-things-that-matter">Step 4: Customize the four things that matter</a></li><li class="lvl-2"><a href="#step-5-spawn-and-put-it-to-work">Step 5: Spawn, and put it to work</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/how-to-talk-to-your-orchestrator/"><span class="k">← Older</span><span class="t">How to Brief Your Orchestrator (So the Floor Actually Ships)</span></a>+ <a class="pn next" href="/blog/how-to-add-a-github-copilot-cli-agent/"><span class="k">Newer →</span><span class="t">How to Add a GitHub Copilot CLI Agent to Your Floor</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/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/how-to-install-and-use-munder-difflin/index.html b/docs/blog/how-to-install-and-use-munder-difflin/index.htmlindex ade7fb02..8a2fb3da 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@@ -26,6 +26,7 @@<meta property="article:tag" content="Tutorial" /><meta property="article:tag" content="Claude Code" /><meta property="article:tag" content="Automation" />+<meta property="article:tag" content="Video" /><!-- Twitter -->@@ -140,6 +141,8 @@ launch you'll pick a harness home, add your repos, and confirm auto mode. Then y<strong>Michael</strong> — the <a href="/#how">GOD orchestrator</a> — spin up agents with a<strong>Goal</strong>, and let the hive work <strong>ambitious, long-horizon tasks for hours ordays</strong> while you watch the floor.</p></div>+<p><em>Watch the 51-second setup walkthrough:</em>+<video controls preload="none" playsinline poster="/media/demo/setup-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;"><source src="/media/demo/setup.mp4" type="video/mp4" /></video></p><p>Most tools help you run a Claude Code agent. Munder Difflin helps you run a <em>team</em> of them —unattended, coordinated, and aimed at the big jobs: a multi-day refactor, a migration, aninvestigation that needs to grind overnight. This is the start-to-finish guide: install it, meet the@@ -380,7 +383,7 @@ task.</p><hr /><div class="share"><span class="lbl">Tags</span>- <a class="tag" href="/blog/tags/guides/">Guides</a><a class="tag" href="/blog/tags/getting-started/">Getting Started</a><a class="tag" href="/blog/tags/tutorial/">Tutorial</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a><a class="tag" href="/blog/tags/automation/">Automation</a>+ <a class="tag" href="/blog/tags/guides/">Guides</a><a class="tag" href="/blog/tags/getting-started/">Getting Started</a><a class="tag" href="/blog/tags/tutorial/">Tutorial</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/video/">Video</a></div></div>@@ -403,56 +406,56 @@ task.</p><h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex ee614fcd..6852078e 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@@ -214,56 +214,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/how-to-talk-to-your-orchestrator/index.html b/docs/blog/how-to-talk-to-your-orchestrator/index.htmlnew file mode 100644index 00000000..2065c218--- /dev/null+++ b/docs/blog/how-to-talk-to-your-orchestrator/index.html@@ -0,0 +1,335 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>How to Brief Your Orchestrator (So the Floor Actually Ships) — Munder Difflin Blog</title>+<meta name="description" content="A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode." />+<link rel="canonical" href="https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/" />++<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 Brief Your Orchestrator (So the Floor Actually Ships) — Munder Difflin Blog" />+<meta property="og:description" content="A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode." />+<meta property="og:url" content="https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Orchestration" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Talk Mode" />+<meta property="article:tag" content="Human-in-the-Loop" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="How to Brief Your Orchestrator (So the Floor Actually Ships) — Munder Difflin Blog" />+<meta name="twitter:description" content="A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode." />+<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 Brief Your Orchestrator (So the Floor Actually Ships)",+ "description": "A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/how-to-talk-to-your-orchestrator/" },+ "keywords": "how to brief an ai orchestrator, ai orchestrator prompts, multi-agent task delegation, god orchestrator briefing, steering ai agents mid-run, voice control ai agents, ai agent approvals",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/"+}+</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 Brief Your Orchestrator (So the Floor Actually Ships)", "item": "https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What should a brief to an AI orchestrator contain?", "acceptedAnswer": { "@type": "Answer", "text": "Four things: the goal (the outcome you want, not the steps), the constraints (what the agents must not touch, which repo, what conventions to follow), the budget (token caps and rough time expectations), and the deliverable (what artifact proves the work is done — a PR, a passing test suite, a document). Everything else — task breakdown, staffing, sequencing — is the orchestrator's job." } },+ { "@type": "Question", "name": "Why shouldn't I tell the orchestrator the exact steps?", "acceptedAnswer": { "@type": "Answer", "text": "Because step-by-step briefs turn a supervisor into a typist. Munder Difflin's GOD orchestrator exists to decompose work, assign it to the right agents, wire dependencies on the task board, and adjudicate results. If you pre-chew every step, you lose the parallelism and the routing — and you own every mistake in your own plan. State the goal and the definition of done; let it plan." } },+ { "@type": "Question", "name": "How do I steer the orchestrator mid-run without killing agents?", "acceptedAnswer": { "@type": "Answer", "text": "Munder Difflin has a mid-run steer and a graceful stop built on Claude Code hook returns, so you can redirect or halt an agent without killing its session. You can also type directly into any agent's terminal, message the orchestrator to re-plan, or use the circuit breaker's steer-constrain-stop ladder if something is looping or overspending." } },+ { "@type": "Question", "name": "How do I ask the orchestrator for status?", "acceptedAnswer": { "@type": "Answer", "text": "Ask it directly — 'what's the state of the floor?' — in its terminal or over Talk mode, where Michael reads the hive (tasks, board, memory, agents, activity) and answers out loud. Or read the surfaces yourself: the Command Center has a kanban Tasks tab, live fleet monitoring, token and cost telemetry, and an activity log." } },+ { "@type": "Question", "name": "What is Talk mode in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "Talk mode (Realtime Michael, shipped in v0.3.2) is a low-latency voice channel to the GOD orchestrator over the OpenAI Realtime API. Press Talk and Michael listens, answers, and acts: he creates and assigns tasks, dispatches agents, spawns and kills workers, and speaks task completions the moment they land. Destructive verbs require a spoken echo-back confirmation, and the session runs under a live cost meter with a hard spend cap. It's bring-your-own OpenAI key." } },+ { "@type": "Question", "name": "Does the orchestrator ask for my approval before risky actions?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The GOD agent resolves routine requests itself and escalates only critical items — spend, destructive operations, scope changes — into a human-in-the-loop approvals queue you act on. In Talk mode, destructive actions additionally require a spoken echo-back confirmation with a distinct confirm token, never a bare yes." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 Brief Your Orchestrator (So the Floor Actually Ships)</h1>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>Your orchestrator is a manager, not a macro. A good brief has four parts: <strong>the goal</strong> (outcome, not steps), <strong>the constraints</strong> (repo, boundaries, conventions), <strong>the budget</strong> (token caps, rough time), and <strong>the deliverable</strong> (the artifact that proves "done"). Then <strong>let Michael staff it</strong> — he decomposes, assigns, wires dependencies, and escalates only spend, destructive ops, and scope changes to your approvals queue. Steer mid-run without killing sessions, ask for status in plain language, and do all of it <strong>by voice with Talk mode</strong> if typing feels slow.</p></div>+<video controls preload="none" playsinline poster="/media/demo/orchestrator-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/orchestrator.mp4" type="video/mp4" />+</video>+<p>Munder Difflin puts one agent between you and the floor: the GOD orchestrator — Michael — who reads every request, decomposes it, routes work to the right agents, and escalates only critical items back to you. (The full mechanics are in <a href="/blog/how-the-god-orchestrator-works/">how the GOD orchestrator works</a>.) That design has one implication people keep missing: <strong>the quality of what the floor ships is mostly the quality of your brief.</strong></p>+<p>Here’s how to brief well.</p>+<h2 id="rule-one-state-the-goal-not-the-steps" tabindex="-1">Rule one: state the goal, not the steps <a class="anchor" href="#rule-one-state-the-goal-not-the-steps" aria-hidden="true">#</a></h2>+<p>The most common failure mode is treating the orchestrator like a very slow keyboard: “open file X, change function Y, then run Z.” That works, but you’ve just done the planning yourself and hired a manager to be your typist.</p>+<p>Michael’s job is decomposition. He turns a goal into tasks on a dependency-aware kanban board, assigns them to agents (each in its own git worktree, so nobody collides), and adjudicates the results. When you pre-chew the steps, you get no parallelism, no routing, and full ownership of every mistake in your own plan.</p>+<p>State the outcome and the definition of done. Let the plan be his problem.</p>+<h2 id="the-four-parts-of-a-good-brief" tabindex="-1">The four parts of a good brief <a class="anchor" href="#the-four-parts-of-a-good-brief" aria-hidden="true">#</a></h2>+<p><strong>1. The goal.</strong> One or two sentences describing the end state. “Users can reset their password over email” beats “add a route, then a token table, then a mailer.”</p>+<p><strong>2. The constraints.</strong> What must not change, where the work lives, what conventions apply. Which repo (the floor works over your registered repos), which directories are off-limits, “follow the existing design tokens,” “don’t touch the migration history.” Constraints are cheap to write and expensive to omit — this is <a href="/blog/context-engineering-for-ai-agents/">context engineering</a> at the human layer.</p>+<p><strong>3. The budget.</strong> Munder Difflin supports per-agent token budgets with live fleet monitoring, backed by a circuit breaker that nudges, constrains, then stops runaways. Say what the work is worth: “keep this under N tokens total” or “this is an overnight job, not a sprint.” A budget in the brief becomes a budget on the floor.</p>+<p><strong>4. The deliverable.</strong> Name the artifact that proves completion: a PR against main, a green test suite, a markdown report, a rendered page. “Done” without an artifact is a vibe; agents ship vibes enthusiastically.</p>+<h2 id="bad-brief-good-brief" tabindex="-1">Bad brief, good brief <a class="anchor" href="#bad-brief-good-brief" aria-hidden="true">#</a></h2>+<p><strong>Bad:</strong> “Fix the login bug.”+No goal state, no repro, no deliverable. Michael will staff <em>something</em>, and you’ll spend the review round discovering what he guessed.</p>+<p><strong>Good:</strong> “Login fails with a 500 when the email has a <code>+</code> in it — repro is in issue #214. Goal: that case passes. Constraints: fix in the auth service only, don’t touch the session store. Budget: one worker, small. Deliverable: a PR with a regression test.”</p>+<p><strong>Bad:</strong> “Refactor the settings page, and also while you’re there improve performance and maybe update the docs.”+Three goals in a trench coat. Split them — the task board handles dependencies; your sentence shouldn’t have to.</p>+<p><strong>Good:</strong> “Goal: the settings page uses the shared form components everywhere. Constraint: no visual changes — screenshots before/after should match. Deliverable: one PR. If you find perf problems, file them as tasks, don’t fix them.”</p>+<p>That last sentence is the pro move: telling the orchestrator what to do with <em>adjacent</em> discoveries, so scope stays fixed without discoveries getting lost.</p>+<h2 id="let-it-staff" tabindex="-1">Let it staff <a class="anchor" href="#let-it-staff" aria-hidden="true">#</a></h2>+<p>Don’t specify which agent does what unless you have a real reason. Michael assigns work across the roster, and each hire can run a different engine — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, or GitHub Copilot CLI — so routing is part of the value. If you <em>do</em> care (“use the cheap local-model worker for the boilerplate”), say it as a constraint, not by micromanaging assignments.</p>+<h2 id="mid-run-steering-status-approvals" tabindex="-1">Mid-run: steering, status, approvals <a class="anchor" href="#mid-run-steering-status-approvals" aria-hidden="true">#</a></h2>+<p>A brief is not a launch-and-pray. Three controls matter while the floor runs:</p>+<p><strong>Steering.</strong> Munder Difflin has a mid-run steer and a graceful stop driven through Claude Code hook returns — you redirect an agent without killing its session. You can also type into any agent’s terminal directly, or message Michael to re-plan: “drop the docs task, the API changed.”</p>+<p><strong>Status.</strong> Ask Michael in plain language — “what’s the state of the floor?” — or read it yourself: the Command Center’s Tasks kanban, live fleet monitoring, real token and cost telemetry, and the activity log.</p>+<p><strong>Approvals.</strong> Michael resolves routine requests himself and escalates only critical items — spend, destructive ops, scope changes — into an approvals queue you act on. Answer those promptly; a stalled approval is a stalled floor. More on this pattern in <a href="/blog/human-in-the-loop-approving-ai-agents/">approving AI agents</a>.</p>+<h2 id="briefing-by-voice-talk-mode" tabindex="-1">Briefing by voice: Talk mode <a class="anchor" href="#briefing-by-voice-talk-mode" aria-hidden="true">#</a></h2>+<p>Everything above works typed into Michael’s terminal. Since v0.3.2 it also works spoken. Press <strong>Talk</strong> and Realtime Michael (OpenAI Realtime API over WebRTC, bring-your-own key) listens and <em>acts</em>: he reads the hive, creates and assigns tasks, dispatches agents, spawns and kills workers — with every destructive verb gated behind a spoken echo-back confirmation, never a bare “yes.” He speaks task completions the moment they land, and the session runs under a live cost meter with a hard spend cap and idle auto-disconnect.</p>+<p>The same brief discipline applies out loud. “Michael, goal: the changelog is updated for the release. Constraint: docs only. Deliverable: a commit on the release branch” is a complete voice brief. (Full details in the <a href="/blog/launching-munder-difflin-v0-3-2/">v0.3.2 launch post</a>.)</p>+<h2 id="the-habit" tabindex="-1">The habit <a class="anchor" href="#the-habit" aria-hidden="true">#</a></h2>+<p>Goal, constraints, budget, deliverable. Say it once, let Michael staff it, steer when reality changes, and answer your approvals. That’s the whole skill — and it’s the difference between a floor that looks busy and a floor that ships.</p>+<p><a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Download Munder Difflin</a> and brief your first floor — and if it ships something, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> is appreciated.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What should a brief to an AI orchestrator contain?</p>+ <p class="a">Four things: the goal (the outcome you want, not the steps), the constraints (what the agents must not touch, which repo, what conventions to follow), the budget (token caps and rough time expectations), and the deliverable (what artifact proves the work is done — a PR, a passing test suite, a document). Everything else — task breakdown, staffing, sequencing — is the orchestrator's job.</p>+ </div>++ <div class="qa">+ <p class="q">Why shouldn't I tell the orchestrator the exact steps?</p>+ <p class="a">Because step-by-step briefs turn a supervisor into a typist. Munder Difflin's GOD orchestrator exists to decompose work, assign it to the right agents, wire dependencies on the task board, and adjudicate results. If you pre-chew every step, you lose the parallelism and the routing — and you own every mistake in your own plan. State the goal and the definition of done; let it plan.</p>+ </div>++ <div class="qa">+ <p class="q">How do I steer the orchestrator mid-run without killing agents?</p>+ <p class="a">Munder Difflin has a mid-run steer and a graceful stop built on Claude Code hook returns, so you can redirect or halt an agent without killing its session. You can also type directly into any agent's terminal, message the orchestrator to re-plan, or use the circuit breaker's steer-constrain-stop ladder if something is looping or overspending.</p>+ </div>++ <div class="qa">+ <p class="q">How do I ask the orchestrator for status?</p>+ <p class="a">Ask it directly — 'what's the state of the floor?' — in its terminal or over Talk mode, where Michael reads the hive (tasks, board, memory, agents, activity) and answers out loud. Or read the surfaces yourself: the Command Center has a kanban Tasks tab, live fleet monitoring, token and cost telemetry, and an activity log.</p>+ </div>++ <div class="qa">+ <p class="q">What is Talk mode in Munder Difflin?</p>+ <p class="a">Talk mode (Realtime Michael, shipped in v0.3.2) is a low-latency voice channel to the GOD orchestrator over the OpenAI Realtime API. Press Talk and Michael listens, answers, and acts: he creates and assigns tasks, dispatches agents, spawns and kills workers, and speaks task completions the moment they land. Destructive verbs require a spoken echo-back confirmation, and the session runs under a live cost meter with a hard spend cap. It's bring-your-own OpenAI key.</p>+ </div>++ <div class="qa">+ <p class="q">Does the orchestrator ask for my approval before risky actions?</p>+ <p class="a">Yes. The GOD agent resolves routine requests itself and escalates only critical items — spend, destructive operations, scope changes — into a human-in-the-loop approvals queue you act on. In Talk mode, destructive actions additionally require a spoken echo-back confirmation with a distinct confirm token, never a bare yes.</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/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/talk-mode/">Talk Mode</a><a class="tag" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop</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="#rule-one-state-the-goal-not-the-steps">Rule one: state the goal, not the steps</a></li><li class="lvl-2"><a href="#the-four-parts-of-a-good-brief">The four parts of a good brief</a></li><li class="lvl-2"><a href="#bad-brief-good-brief">Bad brief, good brief</a></li><li class="lvl-2"><a href="#let-it-staff">Let it staff</a></li><li class="lvl-2"><a href="#mid-run-steering-status-approvals">Mid-run: steering, status, approvals</a></li><li class="lvl-2"><a href="#briefing-by-voice-talk-mode">Briefing by voice: Talk mode</a></li><li class="lvl-2"><a href="#the-habit">The habit</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/how-to-use-the-built-in-monaco-ide/"><span class="k">← Older</span><span class="t">How to Use the Built-in Monaco IDE</span></a>+ <a class="pn next" href="/blog/how-to-hire-from-the-agent-gallery/"><span class="k">Newer →</span><span class="t">How to Hire From the Agent Gallery</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/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/how-to-use-the-built-in-monaco-ide/index.html b/docs/blog/how-to-use-the-built-in-monaco-ide/index.htmlnew file mode 100644index 00000000..cffa1100--- /dev/null+++ b/docs/blog/how-to-use-the-built-in-monaco-ide/index.html@@ -0,0 +1,333 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>How to Use the Built-in Monaco IDE — Munder Difflin Blog</title>+<meta name="description" content="A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables." />+<link rel="canonical" href="https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/" />++<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 Use the Built-in Monaco IDE — Munder Difflin Blog" />+<meta property="og:description" content="A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables." />+<meta property="og:url" content="https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="IDE" />+<meta property="article:tag" content="Git" />+<meta property="article:tag" content="Human-in-the-Loop" />+<meta property="article:tag" content="Local-First" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="How to Use the Built-in Monaco IDE — Munder Difflin Blog" />+<meta name="twitter:description" content="A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables." />+<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 Use the Built-in Monaco IDE",+ "description": "A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/how-to-use-the-built-in-monaco-ide/" },+ "keywords": "built-in monaco ide, review ai agent code changes, monaco editor electron app, side-by-side git diff vs head, munder difflin ide walkthrough, human review workflow for ai agents",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/"+}+</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 Use the Built-in Monaco IDE", "item": "https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "How do I open the built-in IDE in Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "Click the IDE button in the title bar. It toggles a full-window Monaco editor overlay on top of the office floor — the floor, terminals, and voice UX keep running underneath, untouched. Click the button again to drop back to the floor. It shipped in v0.3.3." } },+ { "@type": "Question", "name": "How do I see what an agent changed?", "acceptedAnswer": { "@type": "Answer", "text": "Open the IDE and look at the git CHANGES rail on the left. It lists every file with uncommitted changes in the workspace; click a file and you get a read-only side-by-side diff against HEAD, so you see exactly what the agent wrote next to what was there before." } },+ { "@type": "Question", "name": "Can I edit files in the built-in IDE, not just read diffs?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The left rail also has the workspace file tree — clicking a file there opens it in a real editable Monaco tab. Tabs show a dirty-state dot when you have unsaved edits, and Cmd/Ctrl+S saves the active tab. Saves are hardened so keystrokes typed while a save is still writing are never silently dropped." } },+ { "@type": "Question", "name": "Which folder does the IDE open — how is the workspace root chosen?", "acceptedAnswer": { "@type": "Answer", "text": "The workspace root snapshots from an agent's working directory when the overlay opens: the selected agent's cwd if one is selected, otherwise the GOD agent's, otherwise the first agent's. So selecting the agent whose work you want to review before clicking IDE puts you in the right repo." } },+ { "@type": "Question", "name": "Does Monaco load from a CDN? Does the renderer touch my disk?", "acceptedAnswer": { "@type": "Answer", "text": "No and no. Monaco — the same editor engine VS Code uses — is fully self-hosted and bundled with the app, with no CDN involved, so it works offline. And the renderer holds no filesystem or git access at all: every read, write, and diff is brokered through main-process IPC via the preload bridge." } },+ { "@type": "Question", "name": "Why build an IDE into an agent harness instead of using VS Code?", "acceptedAnswer": { "@type": "Answer", "text": "Because the review loop is faster when it lives where the agents live. An agent finishes, you click IDE, read the side-by-side diff vs HEAD, fix small things in place, and go approve — no context switch to another app, no hunting for the right worktree. For heavy editing sessions your regular editor is still there; the built-in IDE is optimized for reviewing agent output." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 Use the Built-in Monaco IDE</h1>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>4 min read</span>+ <span 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 v0.3.3 ships a <strong>built-in Monaco IDE</strong> — the VS Code editor engine, fully self-hosted, no CDN. A title-bar <strong>IDE</strong> button toggles a full-window overlay above the office floor: a <strong>git CHANGES rail</strong> where clicking a file opens a <strong>side-by-side diff vs HEAD</strong>, a workspace <strong>file tree</strong>, <strong>editor tabs with dirty-state dots</strong>, and <strong>Cmd/Ctrl+S</strong> save. The workspace root snapshots from the <strong>selected → god → first agent's cwd</strong>, and <strong>all fs/git access goes through main-process IPC</strong> — the renderer never touches disk. The point: <em>agent finishes → open IDE → read the diff → tweak → approve</em>, without leaving the app.</p></div>+<p>You hired a floor of agents, one of them just announced it’s done, and now comes the part that actually matters: <strong>reading what it changed before you bless it.</strong> Until v0.3.3, that meant alt-tabbing to your editor, finding the right directory, and running <code>git diff</code> by hand. Now the review surface is built in. This is a practical walkthrough of the Monaco IDE that shipped in <a href="/blog/launching-munder-difflin-v0-3-3/">v0.3.3</a> — what each piece does and the workflow it’s designed around.</p>+<h2 id="opening-it-the-title-bar-ide-button" tabindex="-1">Opening it: the title-bar IDE button <a class="anchor" href="#opening-it-the-title-bar-ide-button" aria-hidden="true">#</a></h2>+<p>There’s an <strong>IDE</strong> button in the title bar. Click it and a full-window Monaco editor overlays the office floor — same fullscreen-overlay pattern as the rest of the app, so the floor, the terminals, and the voice UX keep running underneath, untouched. Click it again and you’re back watching avatars.</p>+<p>Monaco is the editor engine inside VS Code, and here it’s <strong>fully self-hosted</strong>: bundled workers, no CDN, themed to the harness’s light palette. That’s not a vanity detail — it means the IDE works offline and nothing about your code round-trips through a third-party host just to render syntax highlighting. Local-first, like everything else in the app.</p>+<h2 id="the-left-rail-changes-first-tree-second" tabindex="-1">The left rail: CHANGES first, tree second <a class="anchor" href="#the-left-rail-changes-first-tree-second" aria-hidden="true">#</a></h2>+<p>The left rail has two jobs, in priority order.</p>+<p><strong>The git CHANGES list</strong> is the headline. It shows every file with uncommitted changes in the workspace. Click one and you get a <strong>read-only side-by-side diff against HEAD</strong> — the agent’s version on one side, what was committed before on the other. This is the “what did my agent actually do” view, and it’s deliberately read-only: a diff is for reading, not for accidentally editing the wrong pane.</p>+<p><strong>The workspace file tree</strong> sits alongside it. Click any file there and it opens as a normal, <em>editable</em> Monaco tab. So the rail gives you both motions: <em>review</em> (CHANGES → diff) and <em>fix</em> (tree → edit).</p>+<h2 id="tabs-dirty-dots-and-cmdctrls" tabindex="-1">Tabs, dirty dots, and Cmd/Ctrl+S <a class="anchor" href="#tabs-dirty-dots-and-cmdctrls" aria-hidden="true">#</a></h2>+<p>Open files stack up as <strong>editor tabs</strong> on the right, each with a <strong>dirty-state dot</strong> when it has unsaved edits, plus save and close. <strong>Cmd/Ctrl+S</strong> saves the active tab.</p>+<p>One hardening detail worth knowing because it’s the kind of thing that silently eats work in lesser editors: saves are protected against the in-flight race. If you keep typing while a save is still writing to disk, those keystrokes are <strong>not</strong> dropped when the save completes. v0.3.3 fixed this explicitly.</p>+<h2 id="which-folder-am-i-looking-at-the-workspace-root" tabindex="-1">Which folder am I looking at? The workspace root <a class="anchor" href="#which-folder-am-i-looking-at-the-workspace-root" aria-hidden="true">#</a></h2>+<p>The IDE has to pick a repo to show, and it snapshots the workspace root from an agent’s working directory when the overlay opens, in this order:</p>+<ol>+<li>the <strong>selected agent’s</strong> cwd, if you have one selected;</li>+<li>otherwise the <strong>GOD agent’s</strong> cwd;</li>+<li>otherwise the <strong>first agent’s</strong> cwd.</li>+</ol>+<p>Practical consequence: <strong>select the agent whose work you want to review, then click IDE.</strong> That drops you straight into its directory — which matters on a floor where <a href="/blog/claude-code-git-worktrees-vs-hive/">each agent can run in its own isolated git worktree</a>, so “the repo” isn’t one place.</p>+<h2 id="the-security-posture-the-renderer-never-touches-disk" tabindex="-1">The security posture: the renderer never touches disk <a class="anchor" href="#the-security-posture-the-renderer-never-touches-disk" aria-hidden="true">#</a></h2>+<p>Everything the IDE does — listing the tree, reading files, writing saves, computing diffs — is <strong>brokered through main-process IPC</strong>. The diff view rides a <code>git:diff</code> IPC channel plus the preload bridge; the renderer process holds no filesystem or git access of its own. That’s the same architecture as the rest of the harness: the sandboxed renderer asks, the main process does, and the attack surface of “web content with disk access” simply doesn’t exist here.</p>+<h2 id="the-workflow-its-built-for-finish-diff-tweak-approve" tabindex="-1">The workflow it’s built for: finish → diff → tweak → approve <a class="anchor" href="#the-workflow-its-built-for-finish-diff-tweak-approve" aria-hidden="true">#</a></h2>+<p>Here’s the loop the whole feature is shaped around:</p>+<ol>+<li><strong>An agent finishes.</strong> You get the desktop notification, or Michael tells you.</li>+<li><strong>Select that agent, click IDE.</strong> You’re in its workspace.</li>+<li><strong>Read the CHANGES rail.</strong> Click through each touched file, read the side-by-side diff vs HEAD. This is the honest answer to “what did it do,” straight from git — not the agent’s summary of itself.</li>+<li><strong>Tweak in place.</strong> Wrong variable name, missing edge case, comment you’d phrase differently — open the file from the tree, fix it, Cmd/Ctrl+S. No editor switch.</li>+<li><strong>Approve.</strong> Now that you’ve <em>seen</em> the change, act on it — answer the approval-queue escalation, tell the agent to commit, or dispatch the follow-up.</li>+</ol>+<p>That last step is the point. <a href="/blog/human-in-the-loop-approving-ai-agents/">Human-in-the-loop approval</a> is only as good as the human’s view of the change, and “I skimmed the agent’s summary” is not a view. A diff vs HEAD is. The built-in IDE closes the gap between <em>the agent says it’s done</em> and <em>you know what done contains</em> — inside the same window where the work happened.</p>+<h2 id="try-it" tabindex="-1">Try it <a class="anchor" href="#try-it" aria-hidden="true">#</a></h2>+<p>The IDE ships in v0.3.3 for macOS, Windows, and Linux — <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">grab the latest release</a>, or start with the <a href="/blog/how-to-install-and-use-munder-difflin/">install guide</a> if you’re new. If the review loop saves you an alt-tab, a <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub star</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">How do I open the built-in IDE in Munder Difflin?</p>+ <p class="a">Click the IDE button in the title bar. It toggles a full-window Monaco editor overlay on top of the office floor — the floor, terminals, and voice UX keep running underneath, untouched. Click the button again to drop back to the floor. It shipped in v0.3.3.</p>+ </div>++ <div class="qa">+ <p class="q">How do I see what an agent changed?</p>+ <p class="a">Open the IDE and look at the git CHANGES rail on the left. It lists every file with uncommitted changes in the workspace; click a file and you get a read-only side-by-side diff against HEAD, so you see exactly what the agent wrote next to what was there before.</p>+ </div>++ <div class="qa">+ <p class="q">Can I edit files in the built-in IDE, not just read diffs?</p>+ <p class="a">Yes. The left rail also has the workspace file tree — clicking a file there opens it in a real editable Monaco tab. Tabs show a dirty-state dot when you have unsaved edits, and Cmd/Ctrl+S saves the active tab. Saves are hardened so keystrokes typed while a save is still writing are never silently dropped.</p>+ </div>++ <div class="qa">+ <p class="q">Which folder does the IDE open — how is the workspace root chosen?</p>+ <p class="a">The workspace root snapshots from an agent's working directory when the overlay opens: the selected agent's cwd if one is selected, otherwise the GOD agent's, otherwise the first agent's. So selecting the agent whose work you want to review before clicking IDE puts you in the right repo.</p>+ </div>++ <div class="qa">+ <p class="q">Does Monaco load from a CDN? Does the renderer touch my disk?</p>+ <p class="a">No and no. Monaco — the same editor engine VS Code uses — is fully self-hosted and bundled with the app, with no CDN involved, so it works offline. And the renderer holds no filesystem or git access at all: every read, write, and diff is brokered through main-process IPC via the preload bridge.</p>+ </div>++ <div class="qa">+ <p class="q">Why build an IDE into an agent harness instead of using VS Code?</p>+ <p class="a">Because the review loop is faster when it lives where the agents live. An agent finishes, you click IDE, read the side-by-side diff vs HEAD, fix small things in place, and go approve — no context switch to another app, no hunting for the right worktree. For heavy editing sessions your regular editor is still there; the built-in IDE is optimized for reviewing agent output.</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/ide/">IDE</a><a class="tag" href="/blog/tags/git/">Git</a><a class="tag" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop</a><a class="tag" href="/blog/tags/local-first/">Local-First</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="#opening-it-the-title-bar-ide-button">Opening it: the title-bar IDE button</a></li><li class="lvl-2"><a href="#the-left-rail-changes-first-tree-second">The left rail: CHANGES first, tree second</a></li><li class="lvl-2"><a href="#tabs-dirty-dots-and-cmdctrls">Tabs, dirty dots, and Cmd/Ctrl+S</a></li><li class="lvl-2"><a href="#which-folder-am-i-looking-at-the-workspace-root">Which folder am I looking at? The workspace root</a></li><li class="lvl-2"><a href="#the-security-posture-the-renderer-never-touches-disk">The security posture: the renderer never touches disk</a></li><li class="lvl-2"><a href="#the-workflow-its-built-for-finish-diff-tweak-approve">The workflow it’s built for: finish → diff → tweak → approve</a></li><li class="lvl-2"><a href="#try-it">Try it</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/launching-munder-difflin-v0-3-3/"><span class="k">← Older</span><span class="t">Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support</span></a>+ <a class="pn next" href="/blog/how-to-talk-to-your-orchestrator/"><span class="k">Newer →</span><span class="t">How to Brief Your Orchestrator (So the Floor Actually Ships)</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/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/human-in-the-loop-approving-ai-agents/index.html b/docs/blog/human-in-the-loop-approving-ai-agents/index.htmlindex 6b98268b..f881f607 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@@ -270,56 +270,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/index.html b/docs/blog/index.htmlindex ab44bc0d..0feae0f1 100644--- a/docs/blog/index.html+++ b/docs/blog/index.html@@ -84,15 +84,15 @@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">99</span></a>+ <a class="chip" aria-current="page">All<span class="ct">115</span></a>- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>@@ -107,20 +107,20 @@<div class="wrap featured"><article class="card">- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-3/" aria-hidden="true" tabindex="-1">- <span>STORY</span>+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/launching-munder-difflin-v0-3-3/">Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support</a></h3>- <p class="dek">Munder Difflin v0.3.3 adds a full Monaco IDE — file tree, editor tabs, save, and side-by-side git diffs of your agents' changes — plus GitHub Copilot CLI as a first-class agent engine, our first community-contributed provider.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot">- <span class="tag kind">Story</span>- <a class="more" href="/blog/launching-munder-difflin-v0-3-3/" aria-label="Read: Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support">Read →</a>+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article>@@ -131,6 +131,294 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-3/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>3 min</span>+ </div>+ <h3><a href="/blog/launching-munder-difflin-v0-3-3/">Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support</a></h3>+ <p class="dek">Munder Difflin v0.3.3 adds a full Monaco IDE — file tree, editor tabs, save, and side-by-side git diffs of your agents' changes — plus GitHub Copilot CLI as a first-class agent engine, our first community-contributed provider.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/launching-munder-difflin-v0-3-3/" aria-label="Read: Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-2/" aria-hidden="true" tabindex="-1"><span>STORY</span></a>diff --git a/docs/blog/launching-munder-difflin-v0-3-2/index.html b/docs/blog/launching-munder-difflin-v0-3-2/index.htmlindex f98e0f06..3c40a2df 100644--- a/docs/blog/launching-munder-difflin-v0-3-2/index.html+++ b/docs/blog/launching-munder-difflin-v0-3-2/index.html@@ -263,7 +263,7 @@<footer class="post-foot wrap"><div class="prevnext"><a class="pn prev" href="/blog/run-munder-difflin-on-a-mac-mini/"><span class="k">← Older</span><span class="t">Run Munder Difflin Locally on a Mac Mini</span></a>- <a class="pn next" href="/blog/launching-munder-difflin-v0-3-3/"><span class="k">Newer →</span><span class="t">Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support</span></a>+ <a class="pn next" href="/blog/your-first-hour-with-munder-difflin/"><span class="k">Newer →</span><span class="t">Your First Hour With Munder Difflin</span></a></div><section class="related"><h2>Related in Story</h2>diff --git a/docs/blog/launching-munder-difflin-v0-3-3/index.html b/docs/blog/launching-munder-difflin-v0-3-3/index.htmlindex fb1c9a1f..5ad26dae 100644--- a/docs/blog/launching-munder-difflin-v0-3-3/index.html+++ b/docs/blog/launching-munder-difflin-v0-3-3/index.html@@ -253,8 +253,8 @@ help it reach more people.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/launching-munder-difflin-v0-3-2/"><span class="k">← Older</span><span class="t">Launching Munder Difflin v0.3.2: Talk to Michael, a Realtime Voice Orchestrator</span></a>- <span></span>+ <a class="pn prev" href="/blog/loop-engineering-for-ai-agents/"><span class="k">← Older</span><span class="t">Loop Engineering: Designing Agent Loops That Converge</span></a>+ <a class="pn next" href="/blog/how-to-use-the-built-in-monaco-ide/"><span class="k">Newer →</span><span class="t">How to Use the Built-in Monaco IDE</span></a></div><section class="related"><h2>Related in Story</h2>diff --git a/docs/blog/local-first-vs-cloud-agent-sdks/index.html b/docs/blog/local-first-vs-cloud-agent-sdks/index.htmlindex 465e0638..428b9d82 100644--- a/docs/blog/local-first-vs-cloud-agent-sdks/index.html+++ b/docs/blog/local-first-vs-cloud-agent-sdks/index.html@@ -310,56 +310,56 @@ to run agents on your own terms — free and open source.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">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.htmlindex b816d51b..1c6a8b06 100644--- a/docs/blog/long-running-agents-the-2026-shift/index.html+++ b/docs/blog/long-running-agents-the-2026-shift/index.html@@ -293,56 +293,56 @@ source.</p><h2>Related in Concepts</h2><div class="post-grid"><article class="card">- <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/loop-engineering-for-ai-agents/index.html b/docs/blog/loop-engineering-for-ai-agents/index.htmlnew file mode 100644index 00000000..f98d7eb7--- /dev/null+++ b/docs/blog/loop-engineering-for-ai-agents/index.html@@ -0,0 +1,333 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Loop Engineering: Designing Agent Loops That Converge — Munder Difflin Blog</title>+<meta name="description" content="Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away." />+<link rel="canonical" href="https://munderdiffl.in/blog/loop-engineering-for-ai-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="Loop Engineering: Designing Agent Loops That Converge — Munder Difflin Blog" />+<meta property="og:description" content="Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away." />+<meta property="og:url" content="https://munderdiffl.in/blog/loop-engineering-for-ai-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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Concepts" />+<meta property="article:tag" content="Reliability" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Autonomy" />+<meta property="article:tag" content="Guardrails" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Loop Engineering: Designing Agent Loops That Converge — Munder Difflin Blog" />+<meta name="twitter:description" content="Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away." />+<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": "Loop Engineering: Designing Agent Loops That Converge",+ "description": "Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/loop-engineering-for-ai-agents/" },+ "keywords": "agent loop engineering, agentic loop, runaway ai agent, stop conditions for ai agents, agent circuit breaker, long-running ai agents, no-progress detection",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/loop-engineering-for-ai-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": "Loop Engineering: Designing Agent Loops That Converge", "item": "https://munderdiffl.in/blog/loop-engineering-for-ai-agents/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is an agentic loop?", "acceptedAnswer": { "@type": "Answer", "text": "It's the cycle an autonomous agent runs: gather context, take action, verify the result, repeat. Anthropic uses this framing for Claude Code and the Claude Agent SDK — an LLM autonomously using tools in a loop. The inner loop is what the model does each turn; the outer loop is everything the harness wraps around it: when to continue, when to retry, when to escalate, and when to stop." } },+ { "@type": "Question", "name": "What makes an agent loop converge instead of running away?", "acceptedAnswer": { "@type": "Answer", "text": "Three properties borrowed from ordinary loop design: a progress measure that actually moves toward done (verified state, not the model's own claim), hard bounds (iteration caps, token budgets, wall-clock limits), and real exits (task verified done, budget exhausted, or a human gate). A loop with any of the three missing is a runaway waiting for a quiet weekend." } },+ { "@type": "Question", "name": "What is a drain loop?", "acceptedAnswer": { "@type": "Answer", "text": "A pattern for keeping an agent working through a queue without a human re-prompting it. In Claude Code it's built on the Stop hook: when the agent tries to end its turn, the hook checks the inbox, and if mail is waiting it blocks the stop and continues the session with the next item as the prompt. The stop_hook_active flag exists precisely so this pattern can't recurse into an infinite forced continuation." } },+ { "@type": "Question", "name": "How do you detect a runaway agent loop?", "acceptedAnswer": { "@type": "Answer", "text": "By measuring progress from the outside, not by asking the agent. Signals include repeated near-identical tool calls, error storms (the same failure N times in a row), token spend rising while verified state doesn't change, and turns that end without any file, test, or board delta. A breaker watching those signals can intervene long before the budget does." } },+ { "@type": "Question", "name": "Why are budgets part of loop design rather than just cost control?", "acceptedAnswer": { "@type": "Answer", "text": "Because a budget is a loop bound — the guaranteed-termination clause. Even if every other signal fails and the agent loops plausibly forever, a per-agent token budget means the loop halts at a ceiling you chose in advance. Cost control is the side effect; bounded iteration is the point." } },+ { "@type": "Question", "name": "Should a stopped agent loop end at a human?", "acceptedAnswer": { "@type": "Answer", "text": "For the failure cases, yes. A converging loop has graduated responses — steer first, constrain next, stop last — and the terminal state of a stopped loop should be an approvals queue a human acts on, not a silent dead process. Escalation to a person is the exit condition of last resort, and it should be explicit in the design, not an accident." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>Loop Engineering: Designing Agent Loops That Converge</h1>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>6 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>Prompt engineering shapes one turn. Loop engineering shapes whether ten thousand turns converge.</strong> The inner agentic loop — gather context, act, verify — comes with the model. The outer loop is yours to build: <strong>stop conditions</strong> that check verified state, <strong>drain loops</strong> that feed queued work back in, <strong>retry with backoff</strong>, <strong>compaction cycles</strong> that keep context bounded, a <strong>breaker ladder</strong> (steer → constrain → stop), <strong>no-progress detection</strong>, <strong>budgets as loop bounds</strong>, and <strong>human gates as exits</strong>. That's the difference between an agent floor that runs for days and one that melts by morning.</p></div>+<p>There are two loops in every autonomous agent, and we only ever talk about one of them.</p>+<p>The inner loop is the famous one. Anthropic describes it as the agentic loop: <strong>gather context → take action → verify work → repeat</strong>. The model reads files, edits, runs the tests, reads the output, goes again. That loop ships with Claude Code, Codex, Copilot CLI — you don’t build it, you rent it.</p>+<p>The outer loop is the one you build. It answers the questions the inner loop can’t: should this agent keep going? On what? For how much? And who gets told when it shouldn’t? Get the outer loop wrong and the inner loop’s competence doesn’t matter — you either stop too early and leave work stranded, or you don’t stop and produce the classic runaway: an agent burning tokens at 3 a.m., confidently retrying the same failing command for the 40th time.</p>+<p>I think of this as <strong>loop engineering</strong>, and it deserves the same rigor we give prompts and context. (It’s the sibling of <a href="/blog/context-engineering-for-ai-agents/">context engineering</a> — that discipline shapes what’s <em>in</em> the window; this one shapes what happens <em>between</em> windows.)</p>+<h2 id="converging-loops-vs-runaway-loops" tabindex="-1">Converging loops vs runaway loops <a class="anchor" href="#converging-loops-vs-runaway-loops" aria-hidden="true">#</a></h2>+<p>Borrow the checklist from ordinary programming. A <code>while</code> loop terminates when three things are true, and an agent loop is no different:</p>+<ol>+<li><strong>A progress measure that moves.</strong> Something external must get closer to done each iteration — tests passing, board cards moving, diffs landing. Crucially it must be <em>verified</em> state, not the model’s self-report. Anthropic’s guidance on long-running harnesses makes the same point: don’t let the agent declare victory; keep an explicit feature list and only mark items done after real verification.</li>+<li><strong>Bounds.</strong> Max iterations, max tokens, max wall-clock. A loop without a bound isn’t autonomous, it’s unattended.</li>+<li><strong>Exits.</strong> Defined terminal states: done-and-verified, budget-exhausted, escalated-to-human. Every path out of the loop should be one you chose.</li>+</ol>+<p>A runaway loop is just a loop missing one of these — usually the first. The agent is <em>doing things</em>, tokens are flowing, avatars are walking around, and nothing external is changing. Motion without progress.</p>+<h2 id="the-outer-loop-toolbox" tabindex="-1">The outer-loop toolbox <a class="anchor" href="#the-outer-loop-toolbox" aria-hidden="true">#</a></h2>+<p>Here’s the toolbox as it actually exists in <a href="/">Munder Difflin</a>, where the design constraint is blunt: a floor of CLI agents has to run for days without a human babysitting it, and without melting.</p>+<p><strong>Stop conditions.</strong> The naive stop condition is “the model stopped talking.” The engineered one checks state: is the task’s definition of done verified? In Munder Difflin, workers don’t self-certify — the GOD orchestrator reads results, adjudicates, and moves the board (see <a href="/blog/how-the-god-orchestrator-works/">how the GOD orchestrator works</a>).</p>+<p><strong>Drain loops.</strong> The most useful outer-loop pattern in Claude Code is built on the Stop hook: when an agent tries to end its turn, the hook checks its mailbox — and if mail is waiting, it blocks the stop and continues the session with the next message as the prompt. The agent drains its queue instead of dying with a full inbox. Claude Code’s own hooks reference builds in the guardrail this pattern needs: a <code>stop_hook_active</code> flag, so a blocked stop can’t recurse into an infinite forced continuation. That’s loop engineering <em>inside</em> the primitive — one continuation per real stop, not a hall of mirrors.</p>+<p><strong>Retry with backoff.</strong> Transient failures (rate limits, flaky network, a wedged terminal) deserve a retry; identical immediate retries deserve suspicion. Munder Difflin’s wake-reliability layer takes the same stance at floor scale: revive wedged terminals, catch up missed schedules, re-arm the message router — recover the <em>loop</em>, don’t just replay the failure. More in <a href="/blog/recovering-from-agent-failures/">recovering from agent failures</a>.</p>+<p><strong>Compaction cycles.</strong> Long loops fill context windows, and a full window degrades every subsequent iteration. So compaction has to be part of the cycle, not an emergency. Munder Difflin runs a dedicated auto-compact maintenance schedule, decoupled from missions, and the floor even shows a <em>compacting</em> avatar state — because a maintenance pause that looks like a hang gets killed by nervous humans.</p>+<p><strong>Breaker escalation: steer → constrain → stop.</strong> Binary kill switches are a bad fit for agents, because most divergence is recoverable. Munder Difflin’s circuit breaker is a ladder: first <em>steer</em> (a corrective nudge into the session), then <em>constrain</em> (tighten what the agent may do), then <em>stop</em> — triggered by looping, error storms, or a blown budget. Graduated response preserves the work that a hard kill would throw away.</p>+<p><strong>No-progress detection.</strong> The breaker needs a tripwire, and “is it looping?” can’t be answered by asking the looper. External signals work: repeated near-identical actions, the same error N times, spend rising while verified state stays flat. There’s also a quieter failure — the <em>silent</em> stall — which Munder Difflin catches with a PTY-quiescence backstop: an agent pinned <code>working</code> but producing no output gets flipped back to idle, where the inbox-wake nudge can restart its drain loop.</p>+<p><strong>Budgets as loop bounds.</strong> Per-agent token budgets, tracked live against real telemetry, are the guaranteed-termination clause. If every other signal misses, the loop still halts at a ceiling you set while calm.</p>+<p><strong>Human gates as loop exits.</strong> The final exit isn’t a dead process; it’s a person. Spend, scope changes, and destructive operations escalate into an approvals queue rather than resolving inside the loop — the human is a designed exit condition, not an interrupt handler. That’s the heart of <a href="/blog/human-in-the-loop-approving-ai-agents/">human-in-the-loop agent design</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 model gives you the inner loop; the outer loop is the product. Verified stop conditions, drain loops with anti-recursion guards, backoff, scheduled compaction, a breaker ladder, progress tripwires, budget bounds, and human exits — stacked together, they’re why a floor of agents can run for days and converge on finished work instead of a bill.</p>+<p>Munder Difflin ships this outer loop as a free, MIT-licensed, local-first desktop app for the agent CLIs you already run. <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Download it</a>, and if the loop-nerdery resonates, a <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub star</a> helps more people find it.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>What is an agentic loop?</strong> The cycle an agent runs each turn: gather context, act, verify, repeat. The outer loop is everything the harness wraps around it — continue, retry, escalate, stop.</p>+<p><strong>What makes a loop converge?</strong> A verified progress measure, hard bounds, and designed exits. Missing any one of the three, you’ve built a runaway.</p>+<p><strong>What is a drain loop?</strong> A Stop-hook pattern: when the agent tries to end its turn with mail waiting, the hook blocks the stop and continues the session with the next item — bounded by <code>stop_hook_active</code> so it can’t recurse forever.</p>+<p><strong>How do you catch a runaway?</strong> External signals only: repeated actions, error storms, spend without state change, silent stalls. Then respond on a ladder — steer, constrain, stop — with a human approvals queue as the terminal exit.</p>+<p>Sources: <a href="https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk">Anthropic — Building agents with the Claude Agent SDK</a>;+<a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents">Anthropic — Effective harnesses for long-running agents</a>;+<a href="https://code.claude.com/docs/en/hooks">Claude Code — Hooks reference</a>.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is an agentic loop?</p>+ <p class="a">It's the cycle an autonomous agent runs: gather context, take action, verify the result, repeat. Anthropic uses this framing for Claude Code and the Claude Agent SDK — an LLM autonomously using tools in a loop. The inner loop is what the model does each turn; the outer loop is everything the harness wraps around it: when to continue, when to retry, when to escalate, and when to stop.</p>+ </div>++ <div class="qa">+ <p class="q">What makes an agent loop converge instead of running away?</p>+ <p class="a">Three properties borrowed from ordinary loop design: a progress measure that actually moves toward done (verified state, not the model's own claim), hard bounds (iteration caps, token budgets, wall-clock limits), and real exits (task verified done, budget exhausted, or a human gate). A loop with any of the three missing is a runaway waiting for a quiet weekend.</p>+ </div>++ <div class="qa">+ <p class="q">What is a drain loop?</p>+ <p class="a">A pattern for keeping an agent working through a queue without a human re-prompting it. In Claude Code it's built on the Stop hook: when the agent tries to end its turn, the hook checks the inbox, and if mail is waiting it blocks the stop and continues the session with the next item as the prompt. The stop_hook_active flag exists precisely so this pattern can't recurse into an infinite forced continuation.</p>+ </div>++ <div class="qa">+ <p class="q">How do you detect a runaway agent loop?</p>+ <p class="a">By measuring progress from the outside, not by asking the agent. Signals include repeated near-identical tool calls, error storms (the same failure N times in a row), token spend rising while verified state doesn't change, and turns that end without any file, test, or board delta. A breaker watching those signals can intervene long before the budget does.</p>+ </div>++ <div class="qa">+ <p class="q">Why are budgets part of loop design rather than just cost control?</p>+ <p class="a">Because a budget is a loop bound — the guaranteed-termination clause. Even if every other signal fails and the agent loops plausibly forever, a per-agent token budget means the loop halts at a ceiling you chose in advance. Cost control is the side effect; bounded iteration is the point.</p>+ </div>++ <div class="qa">+ <p class="q">Should a stopped agent loop end at a human?</p>+ <p class="a">For the failure cases, yes. A converging loop has graduated responses — steer first, constrain next, stop last — and the terminal state of a stopped loop should be an approvals queue a human acts on, not a silent dead process. Escalation to a person is the exit condition of last resort, and it should be explicit in the design, not an accident.</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/reliability/">Reliability</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/autonomy/">Autonomy</a><a class="tag" href="/blog/tags/guardrails/">Guardrails</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="#converging-loops-vs-runaway-loops">Converging loops vs runaway loops</a></li><li class="lvl-2"><a href="#the-outer-loop-toolbox">The outer-loop toolbox</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/orca-vs-munder-difflin/"><span class="k">← Older</span><span class="t">Orca vs Munder Difflin: Agent IDE or Agent Office?</span></a>+ <a class="pn next" href="/blog/launching-munder-difflin-v0-3-3/"><span class="k">Newer →</span><span class="t">Launching Munder Difflin v0.3.3: A Built-in Monaco IDE and GitHub Copilot CLI Support</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/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/manage-multiple-claude-code-sessions/index.html b/docs/blog/manage-multiple-claude-code-sessions/index.htmlindex fec82773..5d72ac9a 100644--- a/docs/blog/manage-multiple-claude-code-sessions/index.html+++ b/docs/blog/manage-multiple-claude-code-sessions/index.html@@ -267,56 +267,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex 647fceb4..fa3b61d3 100644--- a/docs/blog/mcp-and-skills-in-a-hive/index.html+++ b/docs/blog/mcp-and-skills-in-a-hive/index.html@@ -283,56 +283,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/mcp-security-tool-poisoning/index.html b/docs/blog/mcp-security-tool-poisoning/index.htmlindex 9afb7252..0ac98a64 100644--- a/docs/blog/mcp-security-tool-poisoning/index.html+++ b/docs/blog/mcp-security-tool-poisoning/index.html@@ -272,56 +272,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/munder-difflin-faq/index.html b/docs/blog/munder-difflin-faq/index.htmlindex f410e54c..2acbd522 100644--- a/docs/blog/munder-difflin-faq/index.html+++ b/docs/blog/munder-difflin-faq/index.html@@ -265,56 +265,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex a5db32b3..c96ea159 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@@ -248,56 +248,56 @@<h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex c89abead..8966960b 100644--- a/docs/blog/open-source-ai-tools-on-purpose/index.html+++ b/docs/blog/open-source-ai-tools-on-purpose/index.html@@ -266,56 +266,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/orca-vs-munder-difflin/index.html b/docs/blog/orca-vs-munder-difflin/index.htmlnew file mode 100644index 00000000..ffb5cd3d--- /dev/null+++ b/docs/blog/orca-vs-munder-difflin/index.html@@ -0,0 +1,386 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Orca vs Munder Difflin: Agent IDE or Agent Office? — Munder Difflin Blog</title>+<meta name="description" content="Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick." />+<link rel="canonical" href="https://munderdiffl.in/blog/orca-vs-munder-difflin/" />++<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="Orca vs Munder Difflin: Agent IDE or Agent Office? — Munder Difflin Blog" />+<meta property="og:description" content="Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick." />+<meta property="og:url" content="https://munderdiffl.in/blog/orca-vs-munder-difflin/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Comparisons" />+<meta property="article:tag" content="Orca" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Local-First" />+<meta property="article:tag" content="Orchestration" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Orca vs Munder Difflin: Agent IDE or Agent Office? — Munder Difflin Blog" />+<meta name="twitter:description" content="Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick." />+<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": "Orca vs Munder Difflin: Agent IDE or Agent Office?",+ "description": "Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/orca-vs-munder-difflin/" },+ "keywords": "orca vs munder difflin, orca agent ide, agent development environment, orca alternative, multi-agent orchestrator, run coding agents in parallel, autonomous coding agents",+ "articleSection": "Comparisons",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/orca-vs-munder-difflin/"+}+</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": "Orca vs Munder Difflin: Agent IDE or Agent Office?", "item": "https://munderdiffl.in/blog/orca-vs-munder-difflin/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is Orca (onorca.dev)?", "acceptedAnswer": { "@type": "Answer", "text": "Orca is a free, MIT-licensed Agent Development Environment (ADE) from the YC-backed team at Stably AI. It's a cross-platform desktop IDE built for running coding agent CLIs — Claude Code, Codex, OpenCode, Gemini, Copilot, and dozens more — side by side, each in its own isolated git worktree, with Ghostty-inspired terminals, a VS Code-based editor, an embedded browser with Design Mode, GitHub and Linear integration, and iOS/Android companion apps." } },+ { "@type": "Question", "name": "How is Munder Difflin different from Orca?", "acceptedAnswer": { "@type": "Answer", "text": "They sit at different altitudes. Orca is an IDE you sit in: you send prompts, compare agents, annotate diffs, and steer. Munder Difflin is an office that runs itself: a GOD orchestrator routes work between agents, agents share long-term memory and mailboxes, and work arrives via Slack, webhooks, schedules, or voice — with approval gates, budgets, and a circuit breaker so it can run for days without you watching." } },+ { "@type": "Question", "name": "Is Orca better than Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "For interactive, editor-centric work, honestly, often yes. Orca's editing, diff-annotation, per-worktree browser preview, and mobile companion are more polished for hands-on driving. Munder Difflin wins when you want autonomy: orchestration, shared memory, external triggers, scheduling, and guardrails that let a team of agents work while you're away. They solve different problems." } },+ { "@type": "Question", "name": "Can I use Orca and Munder Difflin together?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, and it's a sensible split. Both are free, MIT-licensed, local-first desktop apps that drive the same agent CLIs on your own subscriptions, so nothing conflicts. Use Orca when you're at the keyboard iterating on a feature; use Munder Difflin as the always-on layer that handles routed, scheduled, and Slack-triggered work in the background." } },+ { "@type": "Question", "name": "Do both tools use git worktrees for agent isolation?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Orca is built around worktree isolation — every agent task gets its own worktree so parallel agents never collide. Munder Difflin has the same per-agent worktree isolation as a toggle, but layers a coordination system on top: a hive of mailboxes, a shared blackboard, single-committer git, and an orchestrator that routes messages between the isolated agents." } },+ { "@type": "Question", "name": "Are Orca and Munder Difflin both free and open source?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Both are MIT-licensed, free, local-first desktop apps for macOS, Windows, and Linux, and both are bring-your-own-subscription — they wrap the agent CLIs and accounts you already have rather than reselling model access." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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/comparisons/">Comparisons</a>+ </nav>+ <h1>Orca vs Munder Difflin: Agent IDE or Agent Office?</h1>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 min read</span>+ <span class="tag kind">Comparisons</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Orca is an Agent IDE; Munder Difflin is an agent office.</strong> Orca (from YC-backed Stably AI) is the polished cockpit for <strong>driving coding agents interactively</strong> — parallel worktrees, great terminals, a VS Code editor, diff annotation, and a genuinely useful mobile companion. Munder Difflin is the layer above the cockpit: a <strong>GOD orchestrator</strong> that routes work, <strong>shared long-term memory</strong>, triggers from <strong>Slack, webhooks, schedules, and voice</strong>, and guardrails (approvals, budgets, circuit breaker) that make <strong>days-long autonomy</strong> safe. Both are free, MIT-licensed, local-first, BYO-subscription. Pick Orca to <em>sit and steer</em>; pick Munder Difflin to <em>delegate and walk away</em>. They coexist fine.</p></div>+<p>If you’re evaluating tools for running multiple coding agents, Orca and Munder Difflin will both show up in your search — and on paper they rhyme. Both are free, MIT-licensed desktop apps. Both run on macOS, Windows, and Linux. Both wrap the agent CLIs you already pay for — Claude Code, Codex, OpenCode, and more — instead of reselling model access. Both isolate agents in git worktrees so parallel work doesn’t collide.</p>+<p>But they are not the same product, and pretending otherwise would help nobody. One is an IDE. The other is an office. Here’s the honest version of that boundary.</p>+<h2 id="what-orca-actually-is" tabindex="-1">What Orca actually is <a class="anchor" href="#what-orca-actually-is" aria-hidden="true">#</a></h2>+<p><a href="https://www.onorca.dev/">Orca</a> calls itself an <strong>Agent Development Environment (ADE)</strong> — an IDE rebuilt from the ground up around agents rather than retrofitted for them. It comes from Stably AI, a Y Combinator-backed team, and it shows: the product is fast, focused, and clearly built by people who drive agents all day.</p>+<p>The core idea is <strong>parallel agents in isolated worktrees</strong>. Spin up a task and Orca creates a worktree for it; run Claude Code, Codex, OpenCode, Grok, Gemini, Copilot — it lists 25+ preconfigured agents and accepts any CLI — side by side, even firing one prompt at several agents at once and comparing what comes back. Around that core it builds a serious cockpit:</p>+<ul>+<li>A <strong>Ghostty-inspired terminal</strong> with WebGL rendering, infinite splits, and scrollback search.</li>+<li><strong>VS Code’s editor</strong> with autosave and quick-open.</li>+<li>An <strong>embedded Chromium browser per worktree</strong>, plus a Design Mode where you click any UI element to send its HTML, CSS, and a cropped screenshot straight into the agent’s context.</li>+<li><strong>Diff annotation</strong> — drop markdown comments on any diff line and send them back to the agent.</li>+<li>Native <strong>GitHub and Linear</strong> integration, SSH worktrees for remote machines, and <strong>iOS/Android companion apps</strong> to monitor and steer agents from your phone.</li>+</ul>+<p>That mobile companion and the editor-centric review flow are genuinely ahead of what Munder Difflin offers today. If your workflow is “I’m at my desk, I want to run three agents on a feature and pick the best diff,” Orca is excellent at exactly that.</p>+<p>Notice, though, what the workflow assumes: <strong>you</strong>. You send the prompts. You compare the results. You annotate the diffs. You steer. Orca’s own docs describe an interactive loop, and there’s no orchestrator, scheduler, or external trigger in it. That’s not a flaw — it’s the product. An IDE is a place you sit.</p>+<h2 id="what-munder-difflin-actually-is" tabindex="-1">What Munder Difflin actually is <a class="anchor" href="#what-munder-difflin-actually-is" aria-hidden="true">#</a></h2>+<p>Munder Difflin starts from the opposite question: what if you <em>don’t</em> sit there?</p>+<p>It’s a local-first Electron app that turns the same agent CLIs — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — into a <strong>coordinated office</strong>. Each agent is a real CLI process in its own pseudo-terminal and isolated worktree (same isolation idea as Orca — we’ve written about <a href="/blog/claude-code-git-worktrees-vs-hive/">how worktrees and the hive fit together</a>), visualized as an affectionate parody of The Office cast on a pixel-art floor. The differences stack up above that:</p>+<ul>+<li>A <strong>GOD orchestrator</strong> (“Michael”) is the one agent you talk to. It routes tasks between workers, adjudicates their messages, resolves routine questions itself, and escalates only critical items to you. (<a href="/blog/how-the-god-orchestrator-works/">How the GOD orchestrator works.</a>)</li>+<li>Agents share <strong>long-term memory</strong> — markdown-first, with a semantic recall index — so what one agent learns, the office remembers across sessions.</li>+<li>Work arrives without you: <strong>Slack messages</strong> (<a href="/blog/trigger-ai-agents-from-slack/">which can spawn ephemeral workers that reply in-thread</a>), <strong>webhooks</strong>, <strong>scheduled missions</strong> with a heartbeat that re-engages a quiet floor, GitHub issue ingestion, and <strong>voice</strong> — Talk mode connects you to Michael over the OpenAI Realtime API.</li>+<li>Autonomy is bounded by <strong>guardrails</strong>: <a href="/blog/human-in-the-loop-approving-ai-agents/">human approval gates</a> on spend, scope, and destructive operations; per-agent token budgets; a cost/runaway circuit breaker; and OpenTelemetry observability with real per-agent cost attribution.</li>+</ul>+<p>v0.3.3 did add a built-in Monaco IDE — file tree, tabs, side-by-side diffs vs HEAD — but let’s be honest about what it’s for: it’s a <strong>review surface for what your agents changed</strong>, not a place you live. Orca’s editing experience is deeper. Munder Difflin’s bet is that you’ll spend less time in an editor at all, because the office handles the routing, memory, and follow-through that would otherwise pull you back to the keyboard.</p>+<h2 id="the-boundary-drawn-plainly" tabindex="-1">The boundary, drawn plainly <a class="anchor" href="#the-boundary-drawn-plainly" aria-hidden="true">#</a></h2>+<table>+<thead>+<tr>+<th></th>+<th><strong>Orca</strong></th>+<th><strong>Munder Difflin</strong></th>+</tr>+</thead>+<tbody>+<tr>+<td>Category</td>+<td>Agent IDE / ADE</td>+<td>Autonomous agent office</td>+</tr>+<tr>+<td>You are the…</td>+<td>Driver</td>+<td>Manager</td>+</tr>+<tr>+<td>Coordination</td>+<td>You, interactively</td>+<td>GOD orchestrator routes work</td>+</tr>+<tr>+<td>Memory</td>+<td>Per-session</td>+<td>Shared long-term + semantic recall</td>+</tr>+<tr>+<td>Triggers</td>+<td>You send prompts</td>+<td>Typing, Slack, webhooks, schedules, voice</td>+</tr>+<tr>+<td>Away-from-desk</td>+<td>Mobile app (monitor + steer)</td>+<td>Runs autonomously with approval gates</td>+</tr>+<tr>+<td>Editor flow</td>+<td>VS Code editor, Design Mode, diff annotation — stronger</td>+<td>Monaco review surface — lighter</td>+</tr>+<tr>+<td>Guardrails</td>+<td>Your judgment</td>+<td>Approvals, budgets, circuit breaker, OTel</td>+</tr>+<tr>+<td>License / cost</td>+<td>MIT, free, BYO subscription</td>+<td>MIT, free, BYO subscription</td>+</tr>+</tbody>+</table>+<h2 id="when-to-pick-which" tabindex="-1">When to pick which <a class="anchor" href="#when-to-pick-which" aria-hidden="true">#</a></h2>+<p><strong>Pick Orca</strong> if your bottleneck is interactive throughput: you’re at the keyboard, you want several agents on one problem, and you want first-class tools for comparing, annotating, and shipping their diffs — plus a phone app to check in from the couch.</p>+<p><strong>Pick Munder Difflin</strong> if your bottleneck is <em>you being required at all</em>: you want work triggered from Slack or a schedule, routed by an orchestrator, informed by shared memory, and bounded by budgets and approval gates while it runs overnight.</p>+<p>And genuinely: <strong>you can run both.</strong> Same CLIs, same subscriptions, same machine, no conflict. Orca for the sessions you drive; Munder Difflin for the office that keeps working when you stop. (For the broader decision framework, see <a href="/blog/how-to-choose-a-multi-agent-tool/">how to choose a multi-agent tool</a>.)</p>+<p>If the office side sounds like your bottleneck, <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">grab the latest release</a> — and if it earns it, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is Orca (onorca.dev)?</p>+ <p class="a">Orca is a free, MIT-licensed Agent Development Environment (ADE) from the YC-backed team at Stably AI. It's a cross-platform desktop IDE built for running coding agent CLIs — Claude Code, Codex, OpenCode, Gemini, Copilot, and dozens more — side by side, each in its own isolated git worktree, with Ghostty-inspired terminals, a VS Code-based editor, an embedded browser with Design Mode, GitHub and Linear integration, and iOS/Android companion apps.</p>+ </div>++ <div class="qa">+ <p class="q">How is Munder Difflin different from Orca?</p>+ <p class="a">They sit at different altitudes. Orca is an IDE you sit in: you send prompts, compare agents, annotate diffs, and steer. Munder Difflin is an office that runs itself: a GOD orchestrator routes work between agents, agents share long-term memory and mailboxes, and work arrives via Slack, webhooks, schedules, or voice — with approval gates, budgets, and a circuit breaker so it can run for days without you watching.</p>+ </div>++ <div class="qa">+ <p class="q">Is Orca better than Munder Difflin?</p>+ <p class="a">For interactive, editor-centric work, honestly, often yes. Orca's editing, diff-annotation, per-worktree browser preview, and mobile companion are more polished for hands-on driving. Munder Difflin wins when you want autonomy: orchestration, shared memory, external triggers, scheduling, and guardrails that let a team of agents work while you're away. They solve different problems.</p>+ </div>++ <div class="qa">+ <p class="q">Can I use Orca and Munder Difflin together?</p>+ <p class="a">Yes, and it's a sensible split. Both are free, MIT-licensed, local-first desktop apps that drive the same agent CLIs on your own subscriptions, so nothing conflicts. Use Orca when you're at the keyboard iterating on a feature; use Munder Difflin as the always-on layer that handles routed, scheduled, and Slack-triggered work in the background.</p>+ </div>++ <div class="qa">+ <p class="q">Do both tools use git worktrees for agent isolation?</p>+ <p class="a">Yes. Orca is built around worktree isolation — every agent task gets its own worktree so parallel agents never collide. Munder Difflin has the same per-agent worktree isolation as a toggle, but layers a coordination system on top: a hive of mailboxes, a shared blackboard, single-committer git, and an orchestrator that routes messages between the isolated agents.</p>+ </div>++ <div class="qa">+ <p class="q">Are Orca and Munder Difflin both free and open source?</p>+ <p class="a">Yes. Both are MIT-licensed, free, local-first desktop apps for macOS, Windows, and Linux, and both are bring-your-own-subscription — they wrap the agent CLIs and accounts you already have rather than reselling model access.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/comparisons/">Comparisons</a><a class="tag" href="/blog/tags/orca/">Orca</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/orchestration/">Orchestration</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-orca-actually-is">What Orca actually is</a></li><li class="lvl-2"><a href="#what-munder-difflin-actually-is">What Munder Difflin actually is</a></li><li class="lvl-2"><a href="#the-boundary-drawn-plainly">The boundary, drawn plainly</a></li><li class="lvl-2"><a href="#when-to-pick-which">When to pick which</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/review-agent-work-where-it-happens/"><span class="k">← Older</span><span class="t">Review Agent Work Where It Happens</span></a>+ <a class="pn next" href="/blog/loop-engineering-for-ai-agents/"><span class="k">Newer →</span><span class="t">Loop Engineering: Designing Agent Loops That Converge</span></a>+ </div>+ <section class="related">+ <h2>Related in Comparisons</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/prompt-caching-for-ai-agents/index.html b/docs/blog/prompt-caching-for-ai-agents/index.htmlindex 9be8ae77..099dff78 100644--- a/docs/blog/prompt-caching-for-ai-agents/index.html+++ b/docs/blog/prompt-caching-for-ai-agents/index.html@@ -302,56 +302,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/review-agent-work-where-it-happens/index.html b/docs/blog/review-agent-work-where-it-happens/index.htmlnew file mode 100644index 00000000..1f77ae2e--- /dev/null+++ b/docs/blog/review-agent-work-where-it-happens/index.html@@ -0,0 +1,324 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Review Agent Work Where It Happens — Munder Difflin Blog</title>+<meta name="description" content="AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor." />+<link rel="canonical" href="https://munderdiffl.in/blog/review-agent-work-where-it-happens/" />++<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="Review Agent Work Where It Happens — Munder Difflin Blog" />+<meta property="og:description" content="AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor." />+<meta property="og:url" content="https://munderdiffl.in/blog/review-agent-work-where-it-happens/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Concepts" />+<meta property="article:tag" content="Code Review" />+<meta property="article:tag" content="Monaco IDE" />+<meta property="article:tag" content="Human-in-the-Loop" />+<meta property="article:tag" content="Git" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Review Agent Work Where It Happens — Munder Difflin Blog" />+<meta name="twitter:description" content="AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<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": "Review Agent Work Where It Happens",+ "description": "AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/review-agent-work-where-it-happens/" },+ "keywords": "review ai agent code changes, ai agent code review bottleneck, review agent diffs in place, built-in monaco ide, supervising ai coding agents, human in the loop code review, multi-agent git workflow",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/review-agent-work-where-it-happens/"+}+</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": "Review Agent Work Where It Happens", "item": "https://munderdiffl.in/blog/review-agent-work-where-it-happens/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Why is code review the bottleneck in multi-agent coding?", "acceptedAnswer": { "@type": "Answer", "text": "Because generation scaled and review didn't. A floor of CLI agents can produce diffs across several worktrees in parallel, but every change still has to pass through one human's judgment before it ships. The constraint on a supervised agent fleet is no longer how fast the agents write code — it's how fast you can read, verify, and accept what they wrote." } },+ { "@type": "Question", "name": "What is review-in-place?", "acceptedAnswer": { "@type": "Answer", "text": "Reviewing agent output inside the same tool where you supervise the agents, instead of alt-tabbing to an external editor. In Munder Difflin, a title-bar IDE button opens a built-in Monaco editor over the office floor: a git CHANGES rail lists what the agents touched, clicking a file shows a side-by-side diff against HEAD, and the file tree lets you open and edit anything with Cmd/Ctrl+S save. You never leave the app where the agents, terminals, and approvals live." } },+ { "@type": "Question", "name": "Is the built-in IDE a full VS Code replacement?", "acceptedAnswer": { "@type": "Answer", "text": "No, and it isn't trying to be. It's Monaco — the same editor engine VS Code uses, fully self-hosted with no CDN — scoped to the supervision loop: see what changed via the CHANGES rail, read the side-by-side diff vs HEAD, and make small corrections with editor tabs and Cmd/Ctrl+S. For deep multi-hour editing sessions your usual editor is still the right tool; for reviewing and touching up agent work, in-place is faster." } },+ { "@type": "Question", "name": "How does the single-committer git pattern make review safer?", "acceptedAnswer": { "@type": "Answer", "text": "In Munder Difflin, no agent ever runs git against the shared hive repo — agents write plain files to their outbox and one harness-owned committer does all the git operations. That prevents index.lock corruption from concurrent commits and gives you a serialized, auditable history. Combined with per-agent worktrees for code changes, it means the diff you review is exactly what one agent did, not an interleaving of several." } },+ { "@type": "Question", "name": "Where do human approval gates fit into reviewing agent work?", "acceptedAnswer": { "@type": "Answer", "text": "The GOD orchestrator resolves routine requests itself and escalates only critical items — spend, destructive operations, scope changes — into an approvals queue you act on. That's decision-level review. The IDE's diff view is code-level review. Together they cover both halves: you approve what the fleet is allowed to do, and you verify what it actually did, without leaving the app." } },+ { "@type": "Question", "name": "Does the IDE give the renderer direct filesystem access?", "acceptedAnswer": { "@type": "Answer", "text": "No. All filesystem and git access is brokered through the Electron main process over IPC — the renderer holds no fs or git access of its own. The diff comes from a main-process git bridge, saves go through the same brokered path, and a v0.3.3 fix ensures keystrokes typed during an in-flight save are never silently lost." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>Review Agent Work Where It Happens</h1>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>4 min read</span>+ <span 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>Agents write diffs faster than you can review them</strong> — and every alt-tab to an external editor breaks the supervision loop you're supposed to be running. The fix is <strong>review-in-place</strong>: Munder Difflin v0.3.3 ships a <strong>built-in Monaco IDE</strong> (the VS Code editor engine, self-hosted) over the office floor — a <strong>git CHANGES rail</strong>, <strong>side-by-side diffs vs HEAD</strong>, a file tree, and <strong>Cmd/Ctrl+S</strong> edits — so you verify agent work where the agents actually are. Pair it with the <strong>single-committer git pattern</strong> (clean, serialized, reviewable history) and <strong>human approval gates</strong> (decision-level review), and the review bottleneck stops being the reason your fleet idles.</p></div>+<p>Here’s the uncomfortable math of running a floor of coding agents: generation scaled, review didn’t. One <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> dispatching work to a handful of CLI agents in isolated worktrees can produce more diffs in an hour than most engineers review in a day. The agents aren’t the bottleneck anymore. <strong>You are.</strong></p>+<p>That’s not an insult — it’s the design constraint. A supervised fleet is only as fast as its slowest verification step, and for code, verification means a human actually reading the change. So the question worth engineering is: how do you make the reading step cheap?</p>+<h2 id="alt-tabbing-is-where-supervision-goes-to-die" tabindex="-1">Alt-tabbing is where supervision goes to die <a class="anchor" href="#alt-tabbing-is-where-supervision-goes-to-die" aria-hidden="true">#</a></h2>+<p>The default answer is “open the repo in your editor.” It works, and it’s also quietly terrible for this job.</p>+<p>When you supervise agents, you’re running a loop: watch the floor, read an escalation, check what an agent changed, answer, move on. Every hop out to an external editor breaks that loop. You alt-tab, find the right window, find the right worktree (each agent has its own), pull up a diff, and by the time you’ve read it, the context that prompted the check — which agent, which task, what it claimed — has evaporated. Then you tab back and reconstruct it.</p>+<p>Multiply that by every agent, every task, all day. The cost isn’t the seconds per switch; it’s that switching makes review feel expensive, so you do less of it, so agent work merges less verified than it should. The bottleneck doesn’t just slow you down — it degrades the quality of the supervision itself.</p>+<h2 id="review-in-place-the-ide-comes-to-the-floor" tabindex="-1">Review-in-place: the IDE comes to the floor <a class="anchor" href="#review-in-place-the-ide-comes-to-the-floor" aria-hidden="true">#</a></h2>+<p>This is the problem the v0.3.3 built-in IDE exists to solve. A title-bar <strong>IDE</strong> button opens a full-window <strong>Monaco</strong> editor — the same editor engine VS Code runs on, fully self-hosted with no CDN — as an overlay on the office floor. The floor, the terminals, and everything else stay untouched underneath; you toggle in, review, toggle out.</p>+<p>The layout is built around the review loop, not general-purpose editing:</p>+<ul>+<li><strong>A git CHANGES rail</strong> on the left lists exactly what changed in the workspace. This is the “what did my agents just do” view, one click from the floor.</li>+<li><strong>Click a changed file</strong> and you get a read-only <strong>side-by-side diff vs HEAD</strong> — the honest before/after, not a summary the agent wrote about itself.</li>+<li><strong>A workspace file tree</strong> below it opens any file for real editing, with <strong>editor tabs</strong>, dirty-state dots, and <strong>Cmd/Ctrl+S</strong> save. Spot a wrong variable name in review? Fix it there. No round-trip through another app, no “hey agent, please rename x to y” for a two-character change.</li>+</ul>+<p>The workspace root snapshots from the selected agent’s cwd (falling back to the GOD agent’s, then the first agent’s), so the IDE opens onto the code you were just looking at, not a generic project picker.</p>+<p>One architectural note that matters more than it sounds: <strong>the renderer holds no filesystem or git access.</strong> Every read, diff, and save is brokered through the Electron main process over IPC. The pretty editor window is just a view; the privileged operations happen in one audited place. And a v0.3.3 fix hardened the save path so keystrokes typed while a save is still writing are never silently dropped — a small thing, exactly the kind of small thing that erodes trust in an in-app editor if it’s wrong.</p>+<h2 id="the-diff-is-only-trustworthy-because-of-how-it-was-made" tabindex="-1">The diff is only trustworthy because of how it was made <a class="anchor" href="#the-diff-is-only-trustworthy-because-of-how-it-was-made" aria-hidden="true">#</a></h2>+<p>A side-by-side diff vs HEAD is only useful if HEAD means something. In a naive multi-agent setup — several agents committing to one repo — it doesn’t: histories interleave, <code>index.lock</code> collisions corrupt state, and “what did agent B change” has no clean answer.</p>+<p>Munder Difflin avoids this with two structural choices. For the shared hive, <strong>no agent ever touches git</strong>: agents write plain files to their <code>outbox/</code>, the router delivers mail, and a single harness-owned committer performs every git operation — the <a href="/blog/single-committer-git-pattern/">single-committer git pattern</a>, which trades a theoretical bottleneck for a serialized, corruption-free, auditable history. For code, <strong>each agent gets its own isolated worktree</strong> (see <a href="/blog/claude-code-git-worktrees-vs-hive/">worktrees vs the hive</a>), so the diff you review is one agent’s coherent work, not a merge puzzle.</p>+<p>Review-in-place sits on top of that foundation. The CHANGES rail is legible <em>because</em> the git story underneath is disciplined.</p>+<h2 id="the-other-half-gates-for-decisions-diffs-for-code" tabindex="-1">The other half: gates for decisions, diffs for code <a class="anchor" href="#the-other-half-gates-for-decisions-diffs-for-code" aria-hidden="true">#</a></h2>+<p>Reading diffs is code-level review. But half of supervising agents is <strong>decision-level</strong> review: should this agent spend that much, delete that thing, expand that scope? The GOD orchestrator handles the routine traffic itself and escalates only critical items — spend, destructive ops, scope changes — into an approvals queue you act on. That’s the <a href="/blog/human-in-the-loop-approving-ai-agents/">human-in-the-loop gate</a>, and it’s deliberately the same shape as the IDE: the decision comes to you, in the app, with context attached.</p>+<p>Put together, the review story has two lanes and zero alt-tabs. Approvals catch the <em>should we</em> questions before damage happens; the IDE’s diff rail catches the <em>what actually happened</em> questions before code merges. Both live where the agents live. The supervision loop stays unbroken, review stays cheap, and cheap review is review that actually happens.</p>+<p>Agents got fast. The winning move isn’t reviewing less — it’s moving review to where the work is. <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Grab the latest release</a> and try the IDE button, and if the floor earns it, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Why is code review the bottleneck in multi-agent coding?</p>+ <p class="a">Because generation scaled and review didn't. A floor of CLI agents can produce diffs across several worktrees in parallel, but every change still has to pass through one human's judgment before it ships. The constraint on a supervised agent fleet is no longer how fast the agents write code — it's how fast you can read, verify, and accept what they wrote.</p>+ </div>++ <div class="qa">+ <p class="q">What is review-in-place?</p>+ <p class="a">Reviewing agent output inside the same tool where you supervise the agents, instead of alt-tabbing to an external editor. In Munder Difflin, a title-bar IDE button opens a built-in Monaco editor over the office floor: a git CHANGES rail lists what the agents touched, clicking a file shows a side-by-side diff against HEAD, and the file tree lets you open and edit anything with Cmd/Ctrl+S save. You never leave the app where the agents, terminals, and approvals live.</p>+ </div>++ <div class="qa">+ <p class="q">Is the built-in IDE a full VS Code replacement?</p>+ <p class="a">No, and it isn't trying to be. It's Monaco — the same editor engine VS Code uses, fully self-hosted with no CDN — scoped to the supervision loop: see what changed via the CHANGES rail, read the side-by-side diff vs HEAD, and make small corrections with editor tabs and Cmd/Ctrl+S. For deep multi-hour editing sessions your usual editor is still the right tool; for reviewing and touching up agent work, in-place is faster.</p>+ </div>++ <div class="qa">+ <p class="q">How does the single-committer git pattern make review safer?</p>+ <p class="a">In Munder Difflin, no agent ever runs git against the shared hive repo — agents write plain files to their outbox and one harness-owned committer does all the git operations. That prevents index.lock corruption from concurrent commits and gives you a serialized, auditable history. Combined with per-agent worktrees for code changes, it means the diff you review is exactly what one agent did, not an interleaving of several.</p>+ </div>++ <div class="qa">+ <p class="q">Where do human approval gates fit into reviewing agent work?</p>+ <p class="a">The GOD orchestrator resolves routine requests itself and escalates only critical items — spend, destructive operations, scope changes — into an approvals queue you act on. That's decision-level review. The IDE's diff view is code-level review. Together they cover both halves: you approve what the fleet is allowed to do, and you verify what it actually did, without leaving the app.</p>+ </div>++ <div class="qa">+ <p class="q">Does the IDE give the renderer direct filesystem access?</p>+ <p class="a">No. All filesystem and git access is brokered through the Electron main process over IPC — the renderer holds no fs or git access of its own. The diff comes from a main-process git bridge, saves go through the same brokered path, and a v0.3.3 fix ensures keystrokes typed during an in-flight save are never silently lost.</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/code-review/">Code Review</a><a class="tag" href="/blog/tags/monaco-ide/">Monaco IDE</a><a class="tag" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop</a><a class="tag" href="/blog/tags/git/">Git</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="#alt-tabbing-is-where-supervision-goes-to-die">Alt-tabbing is where supervision goes to die</a></li><li class="lvl-2"><a href="#review-in-place-the-ide-comes-to-the-floor">Review-in-place: the IDE comes to the floor</a></li><li class="lvl-2"><a href="#the-diff-is-only-trustworthy-because-of-how-it-was-made">The diff is only trustworthy because of how it was made</a></li><li class="lvl-2"><a href="#the-other-half-gates-for-decisions-diffs-for-code">The other half: gates for decisions, diffs for code</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/run-a-mixed-engine-office/"><span class="k">← Older</span><span class="t">Run a Mixed-Engine Office: the Right CLI for Every Desk</span></a>+ <a class="pn next" href="/blog/orca-vs-munder-difflin/"><span class="k">Newer →</span><span class="t">Orca vs Munder Difflin: Agent IDE or Agent Office?</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/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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-a-mixed-engine-office/index.html b/docs/blog/run-a-mixed-engine-office/index.htmlnew file mode 100644index 00000000..e9f5dc3b--- /dev/null+++ b/docs/blog/run-a-mixed-engine-office/index.html@@ -0,0 +1,328 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Run a Mixed-Engine Office: the Right CLI for Every Desk — Munder Difflin Blog</title>+<meta name="description" content="A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models." />+<link rel="canonical" href="https://munderdiffl.in/blog/run-a-mixed-engine-office/" />++<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 a Mixed-Engine Office: the Right CLI for Every Desk — Munder Difflin Blog" />+<meta property="og:description" content="A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models." />+<meta property="og:url" content="https://munderdiffl.in/blog/run-a-mixed-engine-office/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Engines" />+<meta property="article:tag" content="Local-First" />+<meta property="article:tag" content="Cost" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Run a Mixed-Engine Office: the Right CLI for Every Desk — Munder Difflin Blog" />+<meta name="twitter:description" content="A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models." />+<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 a Mixed-Engine Office: the Right CLI for Every Desk",+ "description": "A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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-a-mixed-engine-office/" },+ "keywords": "mixed-engine ai agent office, mix ai coding agents, claude code orchestrator, byok agent engines, local llm coding agents, per-agent engine picker, multi-engine agent harness",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/run-a-mixed-engine-office/"+}+</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 a Mixed-Engine Office: the Right CLI for Every Desk", "item": "https://munderdiffl.in/blog/run-a-mixed-engine-office/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Which agent engines can Munder Difflin run on one floor?", "acceptedAnswer": { "@type": "Answer", "text": "Seven CLI engines plus a local provider: Claude Code, Antigravity (Gemini), OpenAI Codex, OpenCode, Crush, pi.dev, and GitHub Copilot CLI, which joined in v0.3.3 as the first community-contributed engine. You pick the engine per hire from a visual picker in Add Agent, and they all participate in the same hive on the same office floor." } },+ { "@type": "Question", "name": "Can any engine be the GOD orchestrator?", "acceptedAnswer": { "@type": "Answer", "text": "Michael's engine is swappable from onboarding or a change-engine flow, and OpenCode, Crush, and pi.dev are god-eligible alongside Claude Code, Antigravity, and Codex. Claude Code is the strongest default because it has the native hook bridge and the deepest hive integration. Copilot CLI is a worker-only engine: its print mode exits per turn, so it can't run the floor." } },+ { "@type": "Question", "name": "Where do API keys and local model endpoints go?", "acceptedAnswer": { "@type": "Answer", "text": "Settings -> AI Engines. Per-provider keys (Anthropic, OpenAI, Google, OpenRouter, Groq) are stored write-only in the encrypted secret broker — they're never read back into the renderer and are materialized main-only at spawn. The same panel holds per-engine local base-URLs for Ollama, LM Studio, or vLLM, plus default-model fields that OpenCode, Crush, and pi.dev pick up when they spawn." } },+ { "@type": "Question", "name": "How do I run some desks on local or open-source models?", "acceptedAnswer": { "@type": "Answer", "text": "Hire a worker on a local-capable engine — OpenCode, Crush, or pi.dev — and the Add Agent modal surfaces curated OSS-model quick-picks: a Local bucket of Mac-runnable Ollama tags (gpt-oss, Qwen3, DeepSeek-R1, Mistral Small, Llama 3.3 70B) and a BYOK bucket via Groq or OpenRouter. Clicking one fills the engine-correct model slug and rebuilds the spawn command for you." } },+ { "@type": "Question", "name": "Why is GitHub Copilot CLI limited to dispatched tasks?", "acceptedAnswer": { "@type": "Answer", "text": "Copilot CLI runs in its documented non-interactive print mode (copilot -p), which exits after each turn and exposes no hook bridge. That means Copilot workers can't drain hive inbox mail — routed messages bounce to the GOD orchestrator instead of silently dropping. They're excellent for self-contained dispatched work, and they authenticate with your existing GitHub Copilot login, no new keys." } },+ { "@type": "Question", "name": "What happens if a chosen engine's CLI isn't installed?", "acceptedAnswer": { "@type": "Answer", "text": "The harness self-heals: it runs that engine's installer in the terminal, then automatically restarts and continues into the freshly installed binary in place. There's no dead-end and no manual step, and the flow is idempotent so the installer never fires twice." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 a Mixed-Engine Office: the Right CLI for Every Desk</h1>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>You don't have to pick one agent CLI. Munder Difflin runs <strong>seven engines on one floor</strong> — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — chosen <strong>per hire</strong> from a visual picker. The winning layout: <strong>Claude Code as the GOD orchestrator</strong> and hive-aware senior workers, <strong>Codex for coding bursts</strong>, <strong>Copilot for dispatched, self-contained tasks</strong>, and <strong>OpenCode / Crush / pi.dev on BYOK keys or local models</strong> for the routine majority. Keys and local endpoints live in <strong>Settings → AI Engines</strong>; OSS-model quick-picks fill the right slug for you.</p></div>+<p>Most multi-agent setups are a clone army: five copies of the same CLI on the same model, paying the same rate for wildly different jobs. That’s like staffing an office entirely with regional managers. A real office has a manager, a couple of closers, and a lot of people doing solid routine work at a sensible salary.</p>+<p>Munder Difflin is built for that second shape. Every hire — and Michael, the <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> himself — runs on a pluggable engine, picked from a visual provider picker at hire time. Here’s how to lay out the floor.</p>+<h2 id="the-engine-roster-honestly" tabindex="-1">The engine roster, honestly <a class="anchor" href="#the-engine-roster-honestly" aria-hidden="true">#</a></h2>+<p>Seven engines can sit on one floor today, and they’re not interchangeable — that’s the point:</p>+<ul>+<li><strong>Claude Code</strong> — the deepest hive citizen. Native hooks drive lifecycle events, inbox draining, HITL gates, and mid-run steering. The natural orchestrator.</li>+<li><strong>Antigravity (Gemini)</strong> — full hive participation via the native <code>agy-hook</code> bridge.</li>+<li><strong>OpenAI Codex</strong> — receives the hive protocol as its initial prompt and participates through inbox/outbox routing. A strong pure-coding worker.</li>+<li><strong>OpenCode, Crush, pi.dev</strong> — the BYOK trio (shipped in v0.3.1), wired in via native-plugin, proxy, and hooks bridges respectively. Each works as a worker <em>and</em> as Michael, and each can point at your own keys or a local model.</li>+<li><strong>GitHub Copilot CLI</strong> — new in <a href="/blog/launching-munder-difflin-v0-3-3/">v0.3.3</a>, the first community-contributed engine (PR #101). Runs in documented print mode (<code>copilot -p</code>) with a model picker and <code>--resume</code>, authenticated by your existing Copilot login.</li>+</ul>+<p>One honest caveat up front: Copilot’s print mode exits per turn and has no hook bridge, so its workers can’t drain hive inbox mail — routed mail bounces to the orchestrator instead of disappearing. That’s by design, and it tells you exactly where Copilot desks belong.</p>+<h2 id="the-layout-that-works" tabindex="-1">The layout that works <a class="anchor" href="#the-layout-that-works" aria-hidden="true">#</a></h2>+<p><strong>Michael’s office: Claude Code.</strong> The orchestrator reads every request, adjudicates traffic, scribes the blackboard, and escalates only critical items to you. That’s sustained, stateful, judgment-heavy work — give it the engine with native hooks and the tightest harness integration. (Michael’s engine is swappable from onboarding or the change-engine flow if you want to experiment; OpenCode, Crush, and pi.dev are all god-eligible, backstopped by a provider-agnostic idle fallback.)</p>+<p><strong>Senior desks: Claude Code or Antigravity, hive-aware.</strong> Work that involves conversation — replying to routed messages, coordinating with other agents, long multi-step missions — needs engines that drain a mailbox. These are your closers.</p>+<p><strong>Coding bursts: Codex.</strong> Scoped, well-defined implementation work — “build this component, tests included” — plays to Codex’s strengths. It gets the protocol injected as its initial prompt and reports back through outbox routing.</p>+<p><strong>Dispatched tasks: Copilot CLI.</strong> Self-contained jobs that arrive, execute, and finish — perfect for print mode. Hire a Copilot worker, pick its model (Claude Sonnet 4.5 by default, GPT-5.4, or auto), and dispatch. No new keys; your existing GitHub Copilot seat covers it.</p>+<p><strong>The routine majority: OpenCode, Crush, or pi.dev on cheap or local models.</strong> Formatting passes, doc updates, changelog grooming, triage — most fleet work doesn’t need frontier reasoning, and this is where the money is. This is <a href="/blog/do-more-with-less-model-routing/">capability routing</a> made physical: the desk itself is the routing decision.</p>+<h2 id="wiring-it-settings-ai-engines" tabindex="-1">Wiring it: Settings → AI Engines <a class="anchor" href="#wiring-it-settings-ai-engines" aria-hidden="true">#</a></h2>+<p>All the credentials for the BYOK trio live in one panel. <strong>Settings → AI Engines</strong> collects per-provider API keys — Anthropic, OpenAI, Google, OpenRouter, Groq — stored <strong>write-only</strong> in the encrypted secret broker. They’re never read back into the renderer; the main process materializes them into the environment only at spawn. The same panel takes per-engine <strong>local base-URLs</strong> (Ollama, LM Studio, vLLM) and default-model fields, which OpenCode, Crush, and pi.dev pick up automatically.</p>+<p>Then hire. In Add Agent, choosing a local-capable engine surfaces <strong>OSS-model quick-picks</strong>: a <em>Local</em> bucket of Mac-runnable Ollama tags (gpt-oss 20B/120B, Qwen3, DeepSeek-R1, Mistral Small, Llama 3.3 70B) and a <em>third-party OSS provider</em> bucket via Groq or OpenRouter. Click one and it fills the engine-correct slug — <code>local/<tag></code> for OpenCode, <code>ollama/<tag></code> for Crush and pi — and rebuilds the spawn command. If the engine’s CLI binary is missing, the harness runs its installer in the terminal and auto restart-and-continues into the fresh binary. No dead-ends.</p>+<p>The full local-model walkthrough is in <a href="/blog/run-munder-difflin-on-open-models/">run Munder Difflin on open models</a>.</p>+<h2 id="keeping-the-mixed-floor-affordable-and-sane" tabindex="-1">Keeping the mixed floor affordable and sane <a class="anchor" href="#keeping-the-mixed-floor-affordable-and-sane" aria-hidden="true">#</a></h2>+<p>A mixed floor is a cost instrument, but only if you can see and cap what each desk spends. Munder Difflin gives every agent a <strong>token budget</strong> with live fleet monitoring, real token and cost telemetry per agent per session, and a <strong>circuit breaker</strong> that steers, constrains, then stops any agent that loops or blows its budget. The expensive Claude Code desks carry tight scopes; the local desks can grind all night for electricity. The routing logic — which work deserves which price — is the whole subject of <a href="/blog/the-multi-agent-cost-playbook/">the multi-agent cost playbook</a>.</p>+<p>Isolation keeps them from colliding: each hire gets its own pseudo-terminal and, with the git-isolation toggle, its own worktree — seven engines, zero branch fights.</p>+<h2 id="start-with-three-desks" tabindex="-1">Start with three desks <a class="anchor" href="#start-with-three-desks" aria-hidden="true">#</a></h2>+<p>Don’t design the org chart up front. Hire Claude Code as Michael, add one Codex or Copilot desk for a real coding task, and one OpenCode desk on a Groq or Ollama model for something routine. Watch what each engine is actually good at on <em>your</em> work, then grow the floor around the evidence.</p>+<p>Munder Difflin is free, MIT-licensed, and local-first. <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Grab the latest release</a> and try a mixed floor — and if it earns a spot in your toolkit, a <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub star</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Which agent engines can Munder Difflin run on one floor?</p>+ <p class="a">Seven CLI engines plus a local provider: Claude Code, Antigravity (Gemini), OpenAI Codex, OpenCode, Crush, pi.dev, and GitHub Copilot CLI, which joined in v0.3.3 as the first community-contributed engine. You pick the engine per hire from a visual picker in Add Agent, and they all participate in the same hive on the same office floor.</p>+ </div>++ <div class="qa">+ <p class="q">Can any engine be the GOD orchestrator?</p>+ <p class="a">Michael's engine is swappable from onboarding or a change-engine flow, and OpenCode, Crush, and pi.dev are god-eligible alongside Claude Code, Antigravity, and Codex. Claude Code is the strongest default because it has the native hook bridge and the deepest hive integration. Copilot CLI is a worker-only engine: its print mode exits per turn, so it can't run the floor.</p>+ </div>++ <div class="qa">+ <p class="q">Where do API keys and local model endpoints go?</p>+ <p class="a">Settings -> AI Engines. Per-provider keys (Anthropic, OpenAI, Google, OpenRouter, Groq) are stored write-only in the encrypted secret broker — they're never read back into the renderer and are materialized main-only at spawn. The same panel holds per-engine local base-URLs for Ollama, LM Studio, or vLLM, plus default-model fields that OpenCode, Crush, and pi.dev pick up when they spawn.</p>+ </div>++ <div class="qa">+ <p class="q">How do I run some desks on local or open-source models?</p>+ <p class="a">Hire a worker on a local-capable engine — OpenCode, Crush, or pi.dev — and the Add Agent modal surfaces curated OSS-model quick-picks: a Local bucket of Mac-runnable Ollama tags (gpt-oss, Qwen3, DeepSeek-R1, Mistral Small, Llama 3.3 70B) and a BYOK bucket via Groq or OpenRouter. Clicking one fills the engine-correct model slug and rebuilds the spawn command for you.</p>+ </div>++ <div class="qa">+ <p class="q">Why is GitHub Copilot CLI limited to dispatched tasks?</p>+ <p class="a">Copilot CLI runs in its documented non-interactive print mode (copilot -p), which exits after each turn and exposes no hook bridge. That means Copilot workers can't drain hive inbox mail — routed messages bounce to the GOD orchestrator instead of silently dropping. They're excellent for self-contained dispatched work, and they authenticate with your existing GitHub Copilot login, no new keys.</p>+ </div>++ <div class="qa">+ <p class="q">What happens if a chosen engine's CLI isn't installed?</p>+ <p class="a">The harness self-heals: it runs that engine's installer in the terminal, then automatically restarts and continues into the freshly installed binary in place. There's no dead-end and no manual step, and the flow is idempotent so the installer never fires twice.</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/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/engines/">Engines</a><a class="tag" href="/blog/tags/local-first/">Local-First</a><a class="tag" href="/blog/tags/cost/">Cost</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-engine-roster-honestly">The engine roster, honestly</a></li><li class="lvl-2"><a href="#the-layout-that-works">The layout that works</a></li><li class="lvl-2"><a href="#wiring-it-settings-ai-engines">Wiring it: Settings → AI Engines</a></li><li class="lvl-2"><a href="#keeping-the-mixed-floor-affordable-and-sane">Keeping the mixed floor affordable and sane</a></li><li class="lvl-2"><a href="#start-with-three-desks">Start with three desks</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/tmux-and-scripts-vs-an-agent-harness/"><span class="k">← Older</span><span class="t">Running Agents in tmux vs an Agent Harness</span></a>+ <a class="pn next" href="/blog/review-agent-work-where-it-happens/"><span class="k">Newer →</span><span class="t">Review Agent Work Where It Happens</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/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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-ai-agent-hive-from-slack-setup/index.html b/docs/blog/run-ai-agent-hive-from-slack-setup/index.htmlindex 013a3e89..67351834 100644--- a/docs/blog/run-ai-agent-hive-from-slack-setup/index.html+++ b/docs/blog/run-ai-agent-hive-from-slack-setup/index.html@@ -328,56 +328,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/run-munder-difflin-on-a-mac-mini/index.html b/docs/blog/run-munder-difflin-on-a-mac-mini/index.htmlindex 7e78d178..cb547225 100644--- a/docs/blog/run-munder-difflin-on-a-mac-mini/index.html+++ b/docs/blog/run-munder-difflin-on-a-mac-mini/index.html@@ -428,56 +428,56 @@ Difflin</a>.</li><h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">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">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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'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>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</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>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/run-munder-difflin-on-open-models/index.html b/docs/blog/run-munder-difflin-on-open-models/index.htmlindex 4613fb7f..8061d27b 100644--- a/docs/blog/run-munder-difflin-on-open-models/index.html+++ b/docs/blog/run-munder-difflin-on-open-models/index.html@@ -413,56 +413,56 @@ ollama serve <span class="token comment"># exposes the OpenAI-<h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">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">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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'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>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</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>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex 5207a6fd..a53f75cf 100644--- a/docs/blog/security-for-ai-coding-agents/index.html+++ b/docs/blog/security-for-ai-coding-agents/index.html@@ -267,56 +267,56 @@ and open source.</p><h2>Related in Guides</h2><div class="post-grid"><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/shareable-agent-roles/index.html b/docs/blog/shareable-agent-roles/index.htmlindex 0c6270a4..11067a58 100644--- a/docs/blog/shareable-agent-roles/index.html+++ b/docs/blog/shareable-agent-roles/index.html@@ -268,56 +268,56 @@<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">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-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>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 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>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</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>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a></div></div></article><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/voice-as-a-control-plane-for-agent-fleets/" 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-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 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/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex 71f909be..b287d667 100644--- a/docs/blog/small-team-ai-agents-playbook/index.html+++ b/docs/blog/small-team-ai-agents-playbook/index.html@@ -272,56 +272,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/tags/ade/index.html b/docs/blog/tags/ade/index.htmlnew file mode 100644index 00000000..1f7dc1f1--- /dev/null+++ b/docs/blog/tags/ade/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>ADE — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged ADE." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/ade/" />++<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="ADE — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged ADE." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/ade/" />+<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="ADE — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged ADE." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#ADE</h1>+ <p class="lead">1 post tagged <strong>ADE</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/agent-design/index.html b/docs/blog/tags/agent-design/index.htmlindex c1090aba..89e7d103 100644--- a/docs/blog/tags/agent-design/index.html+++ b/docs/blog/tags/agent-design/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Agent Design</h1>- <p class="lead">1 post tagged <strong>Agent Design</strong>.</p>+ <p class="lead">2 posts tagged <strong>Agent Design</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a>diff --git a/docs/blog/tags/architecture/index.html b/docs/blog/tags/architecture/index.htmlindex 85ba5b77..90b95225 100644--- a/docs/blog/tags/architecture/index.html+++ b/docs/blog/tags/architecture/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Architecture</h1>- <p class="lead">3 posts tagged <strong>Architecture</strong>.</p>+ <p class="lead">4 posts tagged <strong>Architecture</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">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/tags/autogen/index.html b/docs/blog/tags/autogen/index.htmlnew file mode 100644index 00000000..2395a795--- /dev/null+++ b/docs/blog/tags/autogen/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>AutoGen — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged AutoGen." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/autogen/" />++<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="AutoGen — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged AutoGen." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/autogen/" />+<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="AutoGen — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged AutoGen." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#AutoGen</h1>+ <p class="lead">1 post tagged <strong>AutoGen</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/autonomy/index.html b/docs/blog/tags/autonomy/index.htmlnew file mode 100644index 00000000..fe854480--- /dev/null+++ b/docs/blog/tags/autonomy/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Autonomy — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Autonomy." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/autonomy/" />++<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="Autonomy — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Autonomy." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/autonomy/" />+<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="Autonomy — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Autonomy." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Autonomy</h1>+ <p class="lead">1 post tagged <strong>Autonomy</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/claude-code/index.html b/docs/blog/tags/claude-code/index.htmlindex 2490c806..b2b60016 100644--- a/docs/blog/tags/claude-code/index.html+++ b/docs/blog/tags/claude-code/index.html@@ -57,11 +57,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Claude Code</h1>- <p class="lead">42 posts tagged <strong>Claude Code</strong>.</p>+ <p class="lead">44 posts tagged <strong>Claude Code</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-0/" 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.htmlindex 78bf945d..65065018 100644--- a/docs/blog/tags/cli-agents/index.html+++ b/docs/blog/tags/cli-agents/index.html@@ -57,11 +57,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#CLI Agents</h1>- <p class="lead">2 posts tagged <strong>CLI Agents</strong>.</p>+ <p class="lead">4 posts tagged <strong>CLI Agents</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/code-review/index.html b/docs/blog/tags/code-review/index.htmlindex c9270f98..cf20b9b5 100644--- a/docs/blog/tags/code-review/index.html+++ b/docs/blog/tags/code-review/index.html@@ -57,11 +57,29 @@<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>+ <p class="lead">2 posts tagged <strong>Code Review</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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>diff --git a/docs/blog/tags/command-center/index.html b/docs/blog/tags/command-center/index.htmlnew file mode 100644index 00000000..8abf553c--- /dev/null+++ b/docs/blog/tags/command-center/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Command Center — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Command Center." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/command-center/" />++<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="Command Center — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Command Center." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/command-center/" />+<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="Command Center — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Command Center." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Command Center</h1>+ <p class="lead">1 post tagged <strong>Command Center</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/comparisons/index.html b/docs/blog/tags/comparisons/index.htmlindex a92d1036..360a1ffb 100644--- a/docs/blog/tags/comparisons/index.html+++ b/docs/blog/tags/comparisons/index.html@@ -57,11 +57,83 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Comparisons</h1>- <p class="lead">12 posts tagged <strong>Comparisons</strong>.</p>+ <p class="lead">16 posts tagged <strong>Comparisons</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a>diff --git a/docs/blog/tags/concepts/index.html b/docs/blog/tags/concepts/index.htmlindex 54ed2cdd..db142d85 100644--- a/docs/blog/tags/concepts/index.html+++ b/docs/blog/tags/concepts/index.html@@ -57,11 +57,101 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Concepts</h1>- <p class="lead">13 posts tagged <strong>Concepts</strong>.</p>+ <p class="lead">18 posts tagged <strong>Concepts</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a>diff --git a/docs/blog/tags/copilot-cli/index.html b/docs/blog/tags/copilot-cli/index.htmlnew file mode 100644index 00000000..20cbc2b5--- /dev/null+++ b/docs/blog/tags/copilot-cli/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Copilot CLI — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Copilot CLI." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/copilot-cli/" />++<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="Copilot CLI — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Copilot CLI." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/copilot-cli/" />+<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="Copilot CLI — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Copilot CLI." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Copilot CLI</h1>+ <p class="lead">1 post tagged <strong>Copilot CLI</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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.htmlindex ce21c11f..42765aa8 100644--- a/docs/blog/tags/cost/index.html+++ b/docs/blog/tags/cost/index.html@@ -57,11 +57,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Cost</h1>- <p class="lead">5 posts tagged <strong>Cost</strong>.</p>+ <p class="lead">7 posts tagged <strong>Cost</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">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>diff --git a/docs/blog/tags/crewai/index.html b/docs/blog/tags/crewai/index.htmlnew file mode 100644index 00000000..8a00b3fb--- /dev/null+++ b/docs/blog/tags/crewai/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>CrewAI — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged CrewAI." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/crewai/" />++<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="CrewAI — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged CrewAI." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/crewai/" />+<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="CrewAI — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged CrewAI." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#CrewAI</h1>+ <p class="lead">1 post tagged <strong>CrewAI</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/engines/index.html b/docs/blog/tags/engines/index.htmlnew file mode 100644index 00000000..d0ef408e--- /dev/null+++ b/docs/blog/tags/engines/index.html@@ -0,0 +1,158 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Engines — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Engines." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/engines/" />++<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="Engines — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Engines." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/engines/" />+<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="Engines — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Engines." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Engines</h1>+ <p class="lead">3 posts tagged <strong>Engines</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/getting-started/index.html b/docs/blog/tags/getting-started/index.htmlindex 11d19cb3..1a890295 100644--- a/docs/blog/tags/getting-started/index.html+++ b/docs/blog/tags/getting-started/index.html@@ -57,11 +57,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Getting Started</h1>- <p class="lead">7 posts tagged <strong>Getting Started</strong>.</p>+ <p class="lead">9 posts tagged <strong>Getting Started</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </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"><span>GUIDES</span></a>diff --git a/docs/blog/tags/git-worktrees/index.html b/docs/blog/tags/git-worktrees/index.htmlnew file mode 100644index 00000000..c3964ed3--- /dev/null+++ b/docs/blog/tags/git-worktrees/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Git Worktrees — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Git Worktrees." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/git-worktrees/" />++<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="Git Worktrees — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Git Worktrees." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/git-worktrees/" />+<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="Git Worktrees — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Git Worktrees." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Git Worktrees</h1>+ <p class="lead">1 post tagged <strong>Git Worktrees</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/git/index.html b/docs/blog/tags/git/index.htmlindex ddd14a84..d456d5b2 100644--- a/docs/blog/tags/git/index.html+++ b/docs/blog/tags/git/index.html@@ -57,11 +57,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Git</h1>- <p class="lead">2 posts tagged <strong>Git</strong>.</p>+ <p class="lead">4 posts tagged <strong>Git</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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>diff --git a/docs/blog/tags/github-copilot/index.html b/docs/blog/tags/github-copilot/index.htmlnew file mode 100644index 00000000..5997a7a2--- /dev/null+++ b/docs/blog/tags/github-copilot/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>GitHub Copilot — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged GitHub Copilot." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/github-copilot/" />++<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 Copilot — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged GitHub Copilot." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/github-copilot/" />+<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 Copilot — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged GitHub Copilot." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 Copilot</h1>+ <p class="lead">1 post tagged <strong>GitHub Copilot</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/guardrails/index.html b/docs/blog/tags/guardrails/index.htmlindex 1dbc2fff..199009d6 100644--- a/docs/blog/tags/guardrails/index.html+++ b/docs/blog/tags/guardrails/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Guardrails</h1>- <p class="lead">4 posts tagged <strong>Guardrails</strong>.</p>+ <p class="lead">5 posts tagged <strong>Guardrails</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/mcp-security-tool-poisoning/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/guides/index.html b/docs/blog/tags/guides/index.htmlindex c8114dcc..5298a54e 100644--- a/docs/blog/tags/guides/index.html+++ b/docs/blog/tags/guides/index.html@@ -57,11 +57,137 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Guides</h1>- <p class="lead">16 posts tagged <strong>Guides</strong>.</p>+ <p class="lead">23 posts tagged <strong>Guides</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/harness-engineering/index.html b/docs/blog/tags/harness-engineering/index.htmlnew file mode 100644index 00000000..99d8e9b8--- /dev/null+++ b/docs/blog/tags/harness-engineering/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Harness Engineering — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Harness Engineering." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/harness-engineering/" />++<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="Harness Engineering — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Harness Engineering." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/harness-engineering/" />+<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="Harness Engineering — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Harness Engineering." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Harness Engineering</h1>+ <p class="lead">1 post tagged <strong>Harness Engineering</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/human-in-the-loop/index.html b/docs/blog/tags/human-in-the-loop/index.htmlindex f5417bd3..b95973f9 100644--- a/docs/blog/tags/human-in-the-loop/index.html+++ b/docs/blog/tags/human-in-the-loop/index.html@@ -57,11 +57,83 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Human-in-the-Loop</h1>- <p class="lead">3 posts tagged <strong>Human-in-the-Loop</strong>.</p>+ <p class="lead">7 posts tagged <strong>Human-in-the-Loop</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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/ide/index.html b/docs/blog/tags/ide/index.htmlindex bea8cfc1..3abd851c 100644--- a/docs/blog/tags/ide/index.html+++ b/docs/blog/tags/ide/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#IDE</h1>- <p class="lead">1 post tagged <strong>IDE</strong>.</p>+ <p class="lead">2 posts tagged <strong>IDE</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-3/" aria-hidden="true" tabindex="-1"><span>STORY</span></a>diff --git a/docs/blog/tags/kanban/index.html b/docs/blog/tags/kanban/index.htmlnew file mode 100644index 00000000..37a0a901--- /dev/null+++ b/docs/blog/tags/kanban/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Kanban — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Kanban." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/kanban/" />++<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="Kanban — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Kanban." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/kanban/" />+<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="Kanban — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Kanban." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Kanban</h1>+ <p class="lead">1 post tagged <strong>Kanban</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/langgraph/index.html b/docs/blog/tags/langgraph/index.htmlnew file mode 100644index 00000000..4d4f51c3--- /dev/null+++ b/docs/blog/tags/langgraph/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>LangGraph — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged LangGraph." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/langgraph/" />++<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="LangGraph — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged LangGraph." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/langgraph/" />+<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="LangGraph — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged LangGraph." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#LangGraph</h1>+ <p class="lead">1 post tagged <strong>LangGraph</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/local-first/index.html b/docs/blog/tags/local-first/index.htmlindex 76032f0b..69e0763b 100644--- a/docs/blog/tags/local-first/index.html+++ b/docs/blog/tags/local-first/index.html@@ -57,11 +57,83 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Local-First</h1>- <p class="lead">9 posts tagged <strong>Local-First</strong>.</p>+ <p class="lead">13 posts tagged <strong>Local-First</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/monaco-ide/index.html b/docs/blog/tags/monaco-ide/index.htmlnew file mode 100644index 00000000..299227eb--- /dev/null+++ b/docs/blog/tags/monaco-ide/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Monaco IDE — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Monaco IDE." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/monaco-ide/" />++<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="Monaco IDE — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Monaco IDE." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/monaco-ide/" />+<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="Monaco IDE — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Monaco IDE." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Monaco IDE</h1>+ <p class="lead">1 post tagged <strong>Monaco IDE</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/multi-agent/index.html b/docs/blog/tags/multi-agent/index.htmlindex 7f1157c0..7e26986c 100644--- a/docs/blog/tags/multi-agent/index.html+++ b/docs/blog/tags/multi-agent/index.html@@ -57,11 +57,101 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Multi-Agent</h1>- <p class="lead">66 posts tagged <strong>Multi-Agent</strong>.</p>+ <p class="lead">79 posts tagged <strong>Multi-Agent</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-3/" aria-hidden="true" tabindex="-1"><span>STORY</span></a>@@ -79,6 +169,150 @@</div></div></article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-2/" aria-hidden="true" tabindex="-1"><span>STORY</span>diff --git a/docs/blog/tags/observability/index.html b/docs/blog/tags/observability/index.htmlindex aa77d8bd..1aa63540 100644--- a/docs/blog/tags/observability/index.html+++ b/docs/blog/tags/observability/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Observability</h1>- <p class="lead">4 posts tagged <strong>Observability</strong>.</p>+ <p class="lead">5 posts tagged <strong>Observability</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/onboarding/index.html b/docs/blog/tags/onboarding/index.htmlnew file mode 100644index 00000000..a36a088c--- /dev/null+++ b/docs/blog/tags/onboarding/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Onboarding — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Onboarding." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/onboarding/" />++<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="Onboarding — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Onboarding." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/onboarding/" />+<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="Onboarding — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Onboarding." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Onboarding</h1>+ <p class="lead">1 post tagged <strong>Onboarding</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/orca/index.html b/docs/blog/tags/orca/index.htmlnew file mode 100644index 00000000..3945dac1--- /dev/null+++ b/docs/blog/tags/orca/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Orca — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Orca." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/orca/" />++<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="Orca — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Orca." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/orca/" />+<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="Orca — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Orca." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Orca</h1>+ <p class="lead">1 post tagged <strong>Orca</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/orchestration/index.html b/docs/blog/tags/orchestration/index.htmlindex c8aea6cd..2e7eb05f 100644--- a/docs/blog/tags/orchestration/index.html+++ b/docs/blog/tags/orchestration/index.html@@ -57,11 +57,65 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Orchestration</h1>- <p class="lead">16 posts tagged <strong>Orchestration</strong>.</p>+ <p class="lead">19 posts tagged <strong>Orchestration</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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>diff --git a/docs/blog/tags/reliability/index.html b/docs/blog/tags/reliability/index.htmlindex 816bf49a..c1cd79e2 100644--- a/docs/blog/tags/reliability/index.html+++ b/docs/blog/tags/reliability/index.html@@ -57,11 +57,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Reliability</h1>- <p class="lead">2 posts tagged <strong>Reliability</strong>.</p>+ <p class="lead">4 posts tagged <strong>Reliability</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/security/index.html b/docs/blog/tags/security/index.htmlindex 8257f7a9..19b4c22e 100644--- a/docs/blog/tags/security/index.html+++ b/docs/blog/tags/security/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Security</h1>- <p class="lead">6 posts tagged <strong>Security</strong>.</p>+ <p class="lead">7 posts tagged <strong>Security</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1"><span>INTERNALS</span></a>diff --git a/docs/blog/tags/talk-mode/index.html b/docs/blog/tags/talk-mode/index.htmlnew file mode 100644index 00000000..cacbe30b--- /dev/null+++ b/docs/blog/tags/talk-mode/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Talk Mode — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Talk Mode." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/talk-mode/" />++<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="Talk Mode — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Talk Mode." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/talk-mode/" />+<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="Talk Mode — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Talk Mode." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Talk Mode</h1>+ <p class="lead">1 post tagged <strong>Talk Mode</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/tmux/index.html b/docs/blog/tags/tmux/index.htmlnew file mode 100644index 00000000..44420480--- /dev/null+++ b/docs/blog/tags/tmux/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>tmux — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged tmux." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/tmux/" />++<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="tmux — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged tmux." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/tmux/" />+<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="tmux — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged tmux." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#tmux</h1>+ <p class="lead">1 post tagged <strong>tmux</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/tooling-landscape/index.html b/docs/blog/tags/tooling-landscape/index.htmlnew file mode 100644index 00000000..3ffee81f--- /dev/null+++ b/docs/blog/tags/tooling-landscape/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Tooling Landscape — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Tooling Landscape." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/tooling-landscape/" />++<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="Tooling Landscape — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Tooling Landscape." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/tooling-landscape/" />+<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="Tooling Landscape — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Tooling Landscape." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Tooling Landscape</h1>+ <p class="lead">1 post tagged <strong>Tooling Landscape</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/video/index.html b/docs/blog/tags/video/index.htmlnew file mode 100644index 00000000..48226611--- /dev/null+++ b/docs/blog/tags/video/index.html@@ -0,0 +1,122 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Video — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Video." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/video/" />++<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="Video — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Video." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/video/" />+<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="Video — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Video." />+<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="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>#Video</h1>+ <p class="lead">1 post tagged <strong>Video</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/how-to-install-and-use-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>+ <span class="dot" aria-hidden="true"></span>+ <span>9 min</span>+ </div>+ <h3><a href="/blog/how-to-install-and-use-munder-difflin/">How to Install and Use Munder Difflin</a></h3>+ <p class="dek">Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</p>+ <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>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/voice/index.html b/docs/blog/tags/voice/index.htmlindex 4b9497cb..48f4e474 100644--- a/docs/blog/tags/voice/index.html+++ b/docs/blog/tags/voice/index.html@@ -57,11 +57,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Voice</h1>- <p class="lead">1 post tagged <strong>Voice</strong>.</p>+ <p class="lead">2 posts tagged <strong>Voice</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-story" href="/blog/launching-munder-difflin-v0-3-2/" aria-hidden="true" tabindex="-1"><span>STORY</span></a>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.htmlindex 38a67706..444a3896 100644--- 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@@ -302,56 +302,56 @@ source.</p><h2>Related in Concepts</h2><div class="post-grid"><article class="card">- <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a></div></div></article><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/voice-as-a-control-plane-for-agent-fleets/" 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-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 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/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/the-lethal-trifecta-for-coding-agents/index.html b/docs/blog/the-lethal-trifecta-for-coding-agents/index.htmlindex 1195e54c..d1e05359 100644--- a/docs/blog/the-lethal-trifecta-for-coding-agents/index.html+++ b/docs/blog/the-lethal-trifecta-for-coding-agents/index.html@@ -290,56 +290,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex cbff0d08..cf6bee8f 100644--- a/docs/blog/the-multi-agent-cost-playbook/index.html+++ b/docs/blog/the-multi-agent-cost-playbook/index.html@@ -271,56 +271,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/tmux-and-scripts-vs-an-agent-harness/index.html b/docs/blog/tmux-and-scripts-vs-an-agent-harness/index.htmlnew file mode 100644index 00000000..bc6c0d7c--- /dev/null+++ b/docs/blog/tmux-and-scripts-vs-an-agent-harness/index.html@@ -0,0 +1,325 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Running Agents in tmux vs an Agent Harness — Munder Difflin Blog</title>+<meta name="description" content="tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates." />+<link rel="canonical" href="https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/" />++<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="Running Agents in tmux vs an Agent Harness — Munder Difflin Blog" />+<meta property="og:description" content="tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates." />+<meta property="og:url" content="https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Comparisons" />+<meta property="article:tag" content="tmux" />+<meta property="article:tag" content="Claude Code" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Git Worktrees" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Running Agents in tmux vs an Agent Harness — Munder Difflin Blog" />+<meta name="twitter:description" content="tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates." />+<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": "Running Agents in tmux vs an Agent Harness",+ "description": "tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/tmux-and-scripts-vs-an-agent-harness/" },+ "keywords": "tmux vs agent harness, run claude code in tmux, multiple claude code sessions tmux, git worktrees parallel agents, diy multi-agent setup, agent harness vs shell scripts",+ "articleSection": "Comparisons",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/"+}+</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": "Running Agents in tmux vs an Agent Harness", "item": "https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Can I run multiple Claude Code sessions with just tmux and git worktrees?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, and it works well at small scale. Give each session its own tmux pane or window and its own git worktree so branches never collide, then detach and reattach as you like. This is a widely used pattern — Claude Code's own creators endorse worktrees for parallel sessions. The pain starts when you go past two or three agents: no routing between sessions, no shared memory, no budgets, and you become the coordination layer." } },+ { "@type": "Question", "name": "What does an agent harness add over tmux plus shell scripts?", "acceptedAnswer": { "@type": "Answer", "text": "The parts you'd otherwise build by hand: a router that moves messages between agents, an orchestrator that assigns and adjudicates work, shared long-term memory across sessions, per-agent token budgets with a circuit breaker, approval gates for destructive operations, triggers from Slack, webhooks, and schedules, and a live view of every agent instead of scrollback archaeology. Munder Difflin does all of this while still running the same CLI processes you'd run in tmux." } },+ { "@type": "Question", "name": "Does using a harness mean giving up the terminal?", "acceptedAnswer": { "@type": "Answer", "text": "No. In Munder Difflin every agent is still a real CLI process — claude, codex, copilot, and others — running in a genuine pseudo-terminal via node-pty. You can open any agent's live terminal and type into it directly, exactly like a tmux pane. The harness sits around the terminals, not instead of them." } },+ { "@type": "Question", "name": "Is the DIY tmux approach ever the right choice?", "acceptedAnswer": { "@type": "Answer", "text": "Often, yes. If you run one or two parallel sessions, review everything yourself, and don't need triggers or unattended operation, tmux plus worktrees is simple, transparent, and has zero new dependencies. The harness earns its keep when agents need to hand work to each other, run while you're away, remember across sessions, or stay inside a budget." } },+ { "@type": "Question", "name": "Do tmux-based agents share memory between sessions?", "acceptedAnswer": { "@type": "Answer", "text": "No. Each CLI session starts with a fresh context, and anything one agent learned dies with its scrollback unless you manually paste it into another session or a file. A harness like Munder Difflin gives every agent markdown-first long-term memory plus a shared semantic index, so what one agent learns is recallable by all of them across restarts." } },+ { "@type": "Question", "name": "Is Munder Difflin free if I already pay for Claude Code?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. It's MIT-licensed and free, and it drives the CLI subscriptions you already have — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — so there's no extra platform fee on top of your existing model spend." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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/comparisons/">Comparisons</a>+ </nav>+ <h1>Running Agents in tmux vs an Agent Harness</h1>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>4 min read</span>+ <span class="tag kind">Comparisons</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>tmux + git worktrees + shell scripts is a real, respectable way to run several Claude Code sessions in parallel</strong> — it's the setup half the community uses, and at two or three agents it's genuinely fine. What breaks at scale is everything <em>between</em> the panes: <strong>no routing, no shared memory, no budgets, no crash recovery, coordination via copy-paste, and scrollback archaeology to find out what happened overnight</strong>. An agent harness automates exactly that layer while still running the same CLI processes. <strong>Munder Difflin is, roughly, the tmux setup you would have built yourself after six months</strong> — free, open source, and local-first.</p></div>+<p>Let’s start by giving the DIY path its due, because it deserves it.</p>+<p>The standard recipe — tmux for sessions, <a href="https://git-scm.com/docs/git-worktree">git worktrees</a> for isolation, a shell script to spin everything up, maybe cron for the nightly run — is not a hack. Worktrees give each agent its own working directory and branch while sharing one repository, so parallel sessions never fight over a checkout. tmux gives you named, detachable sessions that survive a closed laptop lid on a remote box. Boris Cherny, one of Claude Code’s creators, has called parallel worktree sessions the <a href="https://www.mindstudio.ai/blog/claude-code-git-worktrees-parallel-branches">“single biggest productivity unlock”</a>, and Claude Code has since added native worktree support. Tools like <a href="https://github.com/smtg-ai/claude-squad">Claude Squad</a> exist precisely because this pattern is popular enough to be worth wrapping in a TUI.</p>+<p>If you’re running two agents on two branches and reviewing everything yourself, stop reading — you don’t have a problem. The problem shows up when you try to make the panes into a <em>team</em>.</p>+<h2 id="what-breaks-at-scale" tabindex="-1">What breaks at scale <a class="anchor" href="#what-breaks-at-scale" aria-hidden="true">#</a></h2>+<p><strong>No routing.</strong> tmux panes are strangers to each other. When agent A finishes the API change agent B is waiting on, nothing tells B. <em>You</em> notice, <em>you</em> copy the relevant output, <em>you</em> paste it into the other pane. You are the message bus, and the message bus goes to sleep at night. Community writeups on parallel sessions consistently land on the same ceiling — <a href="https://www.codewithseb.com/blog/parallel-claude-code-sessions-git-worktrees-guide">two to three sessions is sustainable, five is cognitively expensive</a> — and the ceiling is you.</p>+<p><strong>No shared memory.</strong> Each session starts cold. The bug agent A root-caused on Tuesday is unknown to agent B on Wednesday; the knowledge lives in a scrollback buffer that will eventually be truncated. There’s no place where “things this project has learned” accumulates. (This is exactly the gap a <a href="/blog/semantic-memory-for-ai-agents/">semantic memory layer</a> exists to fill.)</p>+<p><strong>No budgets, no brakes.</strong> A looping agent in pane 4 will happily burn tokens until you happen to switch to pane 4. There’s no per-agent budget, no circuit breaker, no gate before a destructive command — the safety rail is <em>hope</em> plus however often you cycle through panes.</p>+<p><strong>Scrollback archaeology.</strong> “What did the fleet do overnight?” becomes an hour of <code>Ctrl+B [</code> and paging through six buffers, reconstructing a timeline by hand. There’s no event log, no board, no cost attribution — just bytes.</p>+<p><strong>Crash recovery is manual.</strong> A wedged session, a dead pane after a reboot, a cron job that fired while the machine slept — each is a small manual rebuild: recreate the worktree, relaunch the CLI, re-explain the task. Nothing <a href="/blog/recovering-from-agent-failures/">resumes or self-heals</a>.</p>+<p><strong>Cron is a trigger with no feedback loop.</strong> Cron can start a session on a schedule, but it can’t watch the result, retry a failure, or route the output anywhere. And there’s no path at all from “a teammate posted in Slack” or “a webhook fired” to “an agent picked it up.”</p>+<p>None of these are tmux’s fault. tmux is a terminal multiplexer, and it’s excellent at multiplexing terminals. Everything above is a <em>coordination</em> problem, and coordination is a different program — one you end up writing yourself, script by script, incident by incident.</p>+<h2 id="what-a-harness-automates" tabindex="-1">What a harness automates <a class="anchor" href="#what-a-harness-automates" aria-hidden="true">#</a></h2>+<p>This is the layer <a href="/">Munder Difflin</a> is. Our landing page has a <a href="/#compare">full comparison table</a>, but it maps almost one-to-one onto the breakage list:</p>+<ul>+<li><strong>Routing and orchestration.</strong> Agents get mailboxes; a router moves messages between them; a <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> assigns work, adjudicates, and escalates only what genuinely needs a human. Coordination by copy-paste becomes envelopes flying between desks — literally, on the office floor.</li>+<li><strong>Worktrees, provisioned for you.</strong> The same git-worktree isolation you’d script by hand is a toggle: each agent gets a dedicated worktree on spawn, torn down on kill. (Deeper dive: <a href="/blog/claude-code-git-worktrees-vs-hive/">worktrees vs the hive</a>.)</li>+<li><strong>Shared long-term memory.</strong> Markdown-first memory per agent, mined into a shared semantic index, recalled in milliseconds across sessions and restarts.</li>+<li><strong>Budgets and brakes.</strong> Per-agent token budgets, real token/cost telemetry, and a circuit breaker with a steer → constrain → stop ladder for loops and runaway spend — plus human approval gates on spend, scope, and destructive ops.</li>+<li><strong>Observability instead of archaeology.</strong> A live floor, a Command Center with a kanban board, an activity log, and OpenTelemetry spans per agent. The overnight question takes a glance, not an excavation.</li>+<li><strong>Triggers with a feedback loop.</strong> <a href="/blog/scheduling-autonomous-agent-missions/">Scheduled missions</a> with a heartbeat, Slack ingress that replies in-thread, webhooks, voice — and wake-reliability hardening that catches up missed schedules and revives wedged terminals when the machine wakes.</li>+</ul>+<p>Crucially, the terminals are still terminals. Every agent is the real CLI — Claude Code, Codex, Copilot CLI, and four others — running in a real pseudo-terminal you can pop open and type into, exactly like the pane you left behind.</p>+<h2 id="the-honest-framing" tabindex="-1">The honest framing <a class="anchor" href="#the-honest-framing" aria-hidden="true">#</a></h2>+<p>The DIY path isn’t wrong; it’s version one. Every feature above started life as somebody’s shell script, and if you kept iterating on your tmux setup — add a router script, a memory file, a budget checker, a Slack bridge, a recovery script — you’d converge on a harness. Munder Difflin is that convergence, already built, MIT-licensed, and local-first, so the six months of scripting goes into your actual work instead.</p>+<p>If you’re at two panes, enjoy them. If you’re at five and tired of being the message bus, <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">download the latest release</a> — and if it saves you a script or two, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> is appreciated.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Can I run multiple Claude Code sessions with just tmux and git worktrees?</p>+ <p class="a">Yes, and it works well at small scale. Give each session its own tmux pane or window and its own git worktree so branches never collide, then detach and reattach as you like. This is a widely used pattern — Claude Code's own creators endorse worktrees for parallel sessions. The pain starts when you go past two or three agents: no routing between sessions, no shared memory, no budgets, and you become the coordination layer.</p>+ </div>++ <div class="qa">+ <p class="q">What does an agent harness add over tmux plus shell scripts?</p>+ <p class="a">The parts you'd otherwise build by hand: a router that moves messages between agents, an orchestrator that assigns and adjudicates work, shared long-term memory across sessions, per-agent token budgets with a circuit breaker, approval gates for destructive operations, triggers from Slack, webhooks, and schedules, and a live view of every agent instead of scrollback archaeology. Munder Difflin does all of this while still running the same CLI processes you'd run in tmux.</p>+ </div>++ <div class="qa">+ <p class="q">Does using a harness mean giving up the terminal?</p>+ <p class="a">No. In Munder Difflin every agent is still a real CLI process — claude, codex, copilot, and others — running in a genuine pseudo-terminal via node-pty. You can open any agent's live terminal and type into it directly, exactly like a tmux pane. The harness sits around the terminals, not instead of them.</p>+ </div>++ <div class="qa">+ <p class="q">Is the DIY tmux approach ever the right choice?</p>+ <p class="a">Often, yes. If you run one or two parallel sessions, review everything yourself, and don't need triggers or unattended operation, tmux plus worktrees is simple, transparent, and has zero new dependencies. The harness earns its keep when agents need to hand work to each other, run while you're away, remember across sessions, or stay inside a budget.</p>+ </div>++ <div class="qa">+ <p class="q">Do tmux-based agents share memory between sessions?</p>+ <p class="a">No. Each CLI session starts with a fresh context, and anything one agent learned dies with its scrollback unless you manually paste it into another session or a file. A harness like Munder Difflin gives every agent markdown-first long-term memory plus a shared semantic index, so what one agent learns is recallable by all of them across restarts.</p>+ </div>++ <div class="qa">+ <p class="q">Is Munder Difflin free if I already pay for Claude Code?</p>+ <p class="a">Yes. It's MIT-licensed and free, and it drives the CLI subscriptions you already have — Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, and GitHub Copilot CLI — so there's no extra platform fee on top of your existing model spend.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/comparisons/">Comparisons</a><a class="tag" href="/blog/tags/tmux/">tmux</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/git-worktrees/">Git Worktrees</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-breaks-at-scale">What breaks at scale</a></li><li class="lvl-2"><a href="#what-a-harness-automates">What a harness automates</a></li><li class="lvl-2"><a href="#the-honest-framing">The honest framing</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/voice-as-a-control-plane-for-agent-fleets/"><span class="k">← Older</span><span class="t">Voice Is a Control Plane, Not a Gimmick</span></a>+ <a class="pn next" href="/blog/run-a-mixed-engine-office/"><span class="k">Newer →</span><span class="t">Run a Mixed-Engine Office: the Right CLI for Every Desk</span></a>+ </div>+ <section class="related">+ <h2>Related in Comparisons</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/topics/comparisons/index.html b/docs/blog/topics/comparisons/index.htmlindex 1a0246e5..f2c166a7 100644--- a/docs/blog/topics/comparisons/index.html+++ b/docs/blog/topics/comparisons/index.html@@ -62,18 +62,18 @@</nav><p class="eyebrow">Topic</p><h1>comparisons</h1>- <p class="lead">12 posts in this cluster.</p>+ <p class="lead">16 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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</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/comparisons/" aria-current="page">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>@@ -89,6 +89,78 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-comparisons" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-hidden="true" tabindex="-1">+ <span>COMPARISONS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/tmux-and-scripts-vs-an-agent-harness/">Running Agents in tmux vs an Agent Harness</a></h3>+ <p class="dek">tmux panes, git worktrees, shell scripts, and cron will absolutely run several Claude Code sessions at once. Here's what that DIY setup does well, where it breaks at scale, and what a purpose-built agent harness automates.</p>+ <div class="foot">+ <span class="tag kind">Comparisons</span>+ <a class="more" href="/blog/tmux-and-scripts-vs-an-agent-harness/" aria-label="Read: Running Agents in tmux vs an Agent Harness">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a>diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.htmlindex 142c4783..0ba1c466 100644--- a/docs/blog/topics/concepts/index.html+++ b/docs/blog/topics/concepts/index.html@@ -62,18 +62,18 @@</nav><p class="eyebrow">Topic</p><h1>concepts</h1>- <p class="lead">16 posts in this cluster.</p>+ <p class="lead">21 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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>@@ -89,6 +89,96 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-harness-engineering/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-harness-engineering/">What Is Harness Engineering?</a></h3>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-harness-engineering/" aria-label="Read: What Is Harness Engineering?">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a>diff --git a/docs/blog/topics/guides/index.html b/docs/blog/topics/guides/index.htmlindex fed166fa..c6eab3cd 100644--- a/docs/blog/topics/guides/index.html+++ b/docs/blog/topics/guides/index.html@@ -62,18 +62,18 @@</nav><p class="eyebrow">Topic</p><h1>guides</h1>- <p class="lead">27 posts in this cluster.</p>+ <p class="lead">34 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">27</span></a>+ <a class="chip" href="/blog/topics/guides/" aria-current="page">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>@@ -89,6 +89,132 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-talk-to-your-orchestrator/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-talk-to-your-orchestrator/">How to Brief Your Orchestrator (So the Floor Actually Ships)</a></h3>+ <p class="dek">A practical guide to briefing Munder Difflin's GOD orchestrator: state the goal not the steps, set constraints and budgets, name the deliverable, and let Michael staff the floor. With bad-vs-good brief examples, mid-run steering, and Talk mode.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-talk-to-your-orchestrator/" aria-label="Read: How to Brief Your Orchestrator (So the Floor Actually Ships)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-use-the-built-in-monaco-ide/">How to Use the Built-in Monaco IDE</a></h3>+ <p class="dek">A practical walkthrough of Munder Difflin v0.3.3's built-in Monaco IDE: the title-bar IDE button, the git CHANGES rail with side-by-side diffs vs HEAD, the file tree, tabs, Cmd/Ctrl+S save — and the agent review workflow it enables.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-use-the-built-in-monaco-ide/" aria-label="Read: How to Use the Built-in Monaco IDE">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/run-a-mixed-engine-office/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/run-a-mixed-engine-office/">Run a Mixed-Engine Office: the Right CLI for Every Desk</a></h3>+ <p class="dek">A practical guide to mixing agent engines on one Munder Difflin floor: Claude Code as orchestrator, Codex for coding bursts, Copilot for dispatched tasks, and OpenCode/Crush/pi.dev for BYOK keys and local models.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/run-a-mixed-engine-office/" aria-label="Read: Run a Mixed-Engine Office: the Right CLI for Every Desk">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/your-first-hour-with-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/your-first-hour-with-munder-difflin/">Your First Hour With Munder Difflin</a></h3>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/your-first-hour-with-munder-difflin/" aria-label="Read: Your First Hour With Munder Difflin">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/topics/index.html b/docs/blog/topics/index.htmlindex 9271c0d1..08107579 100644--- a/docs/blog/topics/index.html+++ b/docs/blog/topics/index.html@@ -69,7 +69,7 @@<span class="thumb t-guides" aria-hidden="true">GUIDES</span><div class="body"><h3 style="color:var(--ink)">guides</h3>- <p class="dek">27 posts.</p>+ <p class="dek">34 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -78,7 +78,7 @@<span class="thumb t-concepts" aria-hidden="true">CONCEPTS</span><div class="body"><h3 style="color:var(--ink)">concepts</h3>- <p class="dek">16 posts.</p>+ <p class="dek">21 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -96,7 +96,7 @@<span class="thumb t-comparisons" aria-hidden="true">COMPARISONS</span><div class="body"><h3 style="color:var(--ink)">comparisons</h3>- <p class="dek">12 posts.</p>+ <p class="dek">16 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -143,33 +143,39 @@<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">66</span></a>+ <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">79</span></a>++ <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">44</span></a>- <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">42</span></a>+ <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">23</span></a><a class="chip" href="/blog/tags/internals/">Internals<span class="ct">23</span></a>- <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">16</span></a>+ <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">19</span></a>- <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">16</span></a>+ <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">18</span></a>- <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">13</span></a>+ <a class="chip" href="/blog/tags/comparisons/">Comparisons<span class="ct">16</span></a>- <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">13</span></a>+ <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">13</span></a>- <a class="chip" href="/blog/tags/comparisons/">Comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">13</span></a><a class="chip" href="/blog/tags/automation/">Automation<span class="ct">11</span></a><a class="chip" href="/blog/tags/story/">Story<span class="ct">10</span></a>- <a class="chip" href="/blog/tags/tools/">Tools<span class="ct">9</span></a>+ <a class="chip" href="/blog/tags/getting-started/">Getting Started<span class="ct">9</span></a>- <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">9</span></a>+ <a class="chip" href="/blog/tags/tools/">Tools<span class="ct">9</span></a><a class="chip" href="/blog/tags/memory/">Memory<span class="ct">8</span></a>- <a class="chip" href="/blog/tags/getting-started/">Getting Started<span class="ct">7</span></a>+ <a class="chip" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop<span class="ct">7</span></a>++ <a class="chip" href="/blog/tags/security/">Security<span class="ct">7</span></a>++ <a class="chip" href="/blog/tags/cost/">Cost<span class="ct">7</span></a><a class="chip" href="/blog/tags/release/">Release<span class="ct">7</span></a>@@ -177,29 +183,29 @@<a class="chip" href="/blog/tags/use-cases/">Use Cases<span class="ct">6</span></a>- <a class="chip" href="/blog/tags/security/">Security<span class="ct">6</span></a>-<a class="chip" href="/blog/tags/hive/">Hive<span class="ct">6</span></a>- <a class="chip" href="/blog/tags/autonomous/">Autonomous<span class="ct">5</span></a>+ <a class="chip" href="/blog/tags/observability/">Observability<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/guardrails/">Guardrails<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/autonomous/">Autonomous<span class="ct">5</span></a>- <a class="chip" href="/blog/tags/guardrails/">Guardrails<span class="ct">4</span></a>+ <a class="chip" href="/blog/tags/git/">Git<span class="ct">4</span></a><a class="chip" href="/blog/tags/electron/">Electron<span class="ct">4</span></a><a class="chip" href="/blog/tags/mcp/">MCP<span class="ct">4</span></a>- <a class="chip" href="/blog/tags/workflow/">Workflow<span class="ct">3</span></a>+ <a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">4</span></a>- <a class="chip" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop<span class="ct">3</span></a>+ <a class="chip" href="/blog/tags/reliability/">Reliability<span class="ct">4</span></a>- <a class="chip" href="/blog/tags/terminals/">Terminals<span class="ct">3</span></a>+ <a class="chip" href="/blog/tags/cli-agents/">CLI Agents<span class="ct">4</span></a>- <a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">3</span></a>+ <a class="chip" href="/blog/tags/workflow/">Workflow<span class="ct">3</span></a>++ <a class="chip" href="/blog/tags/terminals/">Terminals<span class="ct">3</span></a><a class="chip" href="/blog/tags/model-routing/">Model Routing<span class="ct">3</span></a>@@ -209,14 +215,14 @@<a class="chip" href="/blog/tags/seo/">SEO<span class="ct">3</span></a>+ <a class="chip" href="/blog/tags/engines/">Engines<span class="ct">3</span></a>+<a class="chip" href="/blog/tags/god/">GOD<span class="ct">2</span></a><a class="chip" href="/blog/tags/messaging/">Messaging<span class="ct">2</span></a><a class="chip" href="/blog/tags/faq/">FAQ<span class="ct">2</span></a>- <a class="chip" href="/blog/tags/git/">Git<span class="ct">2</span></a>-<a class="chip" href="/blog/tags/concurrency/">Concurrency<span class="ct">2</span></a><a class="chip" href="/blog/tags/pixijs/">Pixi.js<span class="ct">2</span></a>@@ -229,8 +235,6 @@<a class="chip" href="/blog/tags/performance/">Performance<span class="ct">2</span></a>- <a class="chip" href="/blog/tags/reliability/">Reliability<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>@@ -241,7 +245,13 @@<a class="chip" href="/blog/tags/codex/">Codex<span class="ct">2</span></a>- <a class="chip" href="/blog/tags/cli-agents/">CLI Agents<span class="ct">2</span></a>+ <a class="chip" href="/blog/tags/code-review/">Code Review<span class="ct">2</span></a>++ <a class="chip" href="/blog/tags/agent-design/">Agent Design<span class="ct">2</span></a>++ <a class="chip" href="/blog/tags/voice/">Voice<span class="ct">2</span></a>++ <a class="chip" href="/blog/tags/ide/">IDE<span class="ct">2</span></a><a class="chip" href="/blog/tags/subagents/">Subagents<span class="ct">1</span></a>@@ -303,9 +313,9 @@<a class="chip" href="/blog/tags/geo/">GEO<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/video/">Video<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/content/">Content<span class="ct">1</span></a><a class="chip" href="/blog/tags/setup/">Setup<span class="ct">1</span></a>@@ -317,8 +327,6 @@<a class="chip" href="/blog/tags/ssrf/">SSRF<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/agent-design/">Agent Design<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/mac-mini/">Mac Mini<span class="ct">1</span></a><a class="chip" href="/blog/tags/ollama/">Ollama<span class="ct">1</span></a>@@ -327,14 +335,44 @@<a class="chip" href="/blog/tags/byok/">BYOK<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/voice/">Voice<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/realtime/">Realtime<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/ide/">IDE<span class="ct">1</span></a>+ <a class="chip" href="/blog/tags/command-center/">Command Center<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/kanban/">Kanban<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/crewai/">CrewAI<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/autogen/">AutoGen<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/langgraph/">LangGraph<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/copilot-cli/">Copilot CLI<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/github-copilot/">GitHub Copilot<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/talk-mode/">Talk Mode<span class="ct">1</span></a><a class="chip" href="/blog/tags/copilot/">Copilot<span class="ct">1</span></a>+ <a class="chip" href="/blog/tags/autonomy/">Autonomy<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/orca/">Orca<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/monaco-ide/">Monaco IDE<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/tmux/">tmux<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/git-worktrees/">Git Worktrees<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/ade/">ADE<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/tooling-landscape/">Tooling Landscape<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/harness-engineering/">Harness Engineering<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/onboarding/">Onboarding<span class="ct">1</span></a>+</div></section>diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.htmlindex bd20dc87..e5344f74 100644--- a/docs/blog/topics/internals/index.html+++ b/docs/blog/topics/internals/index.html@@ -67,13 +67,13 @@<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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.htmlindex 4edd008f..d2888141 100644--- a/docs/blog/topics/memory/index.html+++ b/docs/blog/topics/memory/index.html@@ -67,13 +67,13 @@<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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.htmlindex 074d94e4..f493d9f4 100644--- a/docs/blog/topics/orchestration/index.html+++ b/docs/blog/topics/orchestration/index.html@@ -67,13 +67,13 @@<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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/" aria-current="page">orchestration<span class="ct">9</span></a>diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.htmlindex 29ae0e5a..c7a480ae 100644--- a/docs/blog/topics/story/index.html+++ b/docs/blog/topics/story/index.html@@ -67,13 +67,13 @@<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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.htmlindex 45c354f4..e99ca305 100644--- a/docs/blog/topics/use-cases/index.html+++ b/docs/blog/topics/use-cases/index.html@@ -67,13 +67,13 @@<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">27</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">34</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">21</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">16</span></a><a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</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.htmlindex da8bb5e9..20229775 100644--- a/docs/blog/trigger-ai-agents-from-github-webhook/index.html+++ b/docs/blog/trigger-ai-agents-from-github-webhook/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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/trigger-ai-agents-from-slack/index.html b/docs/blog/trigger-ai-agents-from-slack/index.htmlindex 43bb7891..4909ccf9 100644--- a/docs/blog/trigger-ai-agents-from-slack/index.html+++ b/docs/blog/trigger-ai-agents-from-slack/index.html@@ -267,56 +267,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a></div></div></article>diff --git a/docs/blog/vibe-kanban-alternative/index.html b/docs/blog/vibe-kanban-alternative/index.htmlindex 82beef07..2c782b5f 100644--- a/docs/blog/vibe-kanban-alternative/index.html+++ b/docs/blog/vibe-kanban-alternative/index.html@@ -217,56 +217,56 @@ routing happen for you — free and open source.</p><h2>Related in Comparisons</h2><div class="post-grid"><article class="card">- <a class="thumb t-comparisons" href="/blog/best-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-ai-coding-agents/">The Best AI Coding Agents in 2026: A Field Guide</a></h3>- <p class="dek">A fair 2026 field guide to the best AI coding agents — Cursor, Aider, Cline, Devin, Copilot — by category, plus where a local multi-agent hive fits.</p>+ <h3><a href="/blog/crewai-autogen-vs-a-local-agent-harness/">CrewAI and AutoGen vs a Local Agent Harness: Framework or App?</a></h3>+ <p class="dek">CrewAI, AutoGen (now Microsoft Agent Framework), and LangGraph are frameworks — Python you write to build your own agent system. A multi-agent harness is an app you download that runs a team on your repos today. Here's how to tell which one you actually need.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-ai-coding-agents/" aria-label="Read: The Best AI Coding Agents in 2026: A Field Guide">Read →</a>+ <a class="more" href="/blog/crewai-autogen-vs-a-local-agent-harness/" aria-label="Read: CrewAI and AutoGen vs a Local Agent Harness: Framework or App?">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/cline-vs-munder-difflin/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-05">Jun 5, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/cline-vs-munder-difflin/">Cline vs Munder Difflin: In-Editor Agent or Local Hive?</a></h3>- <p class="dek">A fair comparison of Cline and Munder Difflin — an in-editor BYOK coding agent vs a local multi-agent orchestration hive — and when to pick which.</p>+ <h3><a href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/">GitHub Copilot CLI vs Claude Code as Hive Workers</a></h3>+ <p class="dek">How GitHub Copilot CLI and Claude Code behave as agent engines inside a multi-agent harness: hooks, inbox mail, orchestration, session lifecycle — and why the right answer is to run both.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/cline-vs-munder-difflin/" aria-label="Read: Cline vs Munder Difflin: In-Editor Agent or Local Hive?">Read →</a>+ <a class="more" href="/blog/github-copilot-cli-vs-claude-code-for-hive-work/" aria-label="Read: GitHub Copilot CLI vs Claude Code as Hive Workers">Read →</a></div></div></article><article class="card">- <a class="thumb t-comparisons" href="/blog/best-claude-code-multi-agent-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-comparisons" href="/blog/orca-vs-munder-difflin/" aria-hidden="true" tabindex="-1"><span>COMPARISONS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-04">Jun 4, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/best-claude-code-multi-agent-tools/">The Best Tools to Run Multiple Claude Code Agents (2026)</a></h3>- <p class="dek">An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</p>+ <h3><a href="/blog/orca-vs-munder-difflin/">Orca vs Munder Difflin: Agent IDE or Agent Office?</a></h3>+ <p class="dek">Orca is a YC-backed Agent IDE for driving coding agents side by side in isolated worktrees. Munder Difflin is an agent office that runs itself. An honest comparison of the two — and when each one is the right pick.</p><div class="foot"><span class="tag kind">Comparisons</span>- <a class="more" href="/blog/best-claude-code-multi-agent-tools/" aria-label="Read: The Best Tools to Run Multiple Claude Code Agents (2026)">Read →</a>+ <a class="more" href="/blog/orca-vs-munder-difflin/" aria-label="Read: Orca vs Munder Difflin: Agent IDE or Agent Office?">Read →</a></div></div></article>diff --git a/docs/blog/voice-as-a-control-plane-for-agent-fleets/index.html b/docs/blog/voice-as-a-control-plane-for-agent-fleets/index.htmlnew file mode 100644index 00000000..09e4f321--- /dev/null+++ b/docs/blog/voice-as-a-control-plane-for-agent-fleets/index.html@@ -0,0 +1,326 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Voice Is a Control Plane, Not a Gimmick — Munder Difflin Blog</title>+<meta name="description" content="Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study." />+<link rel="canonical" href="https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/" />++<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="Voice Is a Control Plane, Not a Gimmick — Munder Difflin Blog" />+<meta property="og:description" content="Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study." />+<meta property="og:url" content="https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Concepts" />+<meta property="article:tag" content="Voice" />+<meta property="article:tag" content="Orchestration" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Human-in-the-Loop" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Voice Is a Control Plane, Not a Gimmick — Munder Difflin Blog" />+<meta name="twitter:description" content="Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study." />+<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": "Voice Is a Control Plane, Not a Gimmick",+ "description": "Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/voice-as-a-control-plane-for-agent-fleets/" },+ "keywords": "voice control for ai agents, voice agent orchestration, talk to ai agents by voice, openai realtime api agents, voice commands for agent fleets, hands-free agent orchestration, voice approvals for ai agents",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/"+}+</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": "Voice Is a Control Plane, Not a Gimmick", "item": "https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Why is voice bad for writing code but good for orchestrating agents?", "acceptedAnswer": { "@type": "Answer", "text": "Because the bandwidth is mismatched in one direction and matched in the other. Code is dense, precise, and positional — dictating a diff by voice is slower and more error-prone than typing it. Orchestration commands are the opposite: short, intent-shaped utterances like assign this, what's the status, kill that worker. A sentence of intent fans out into minutes of agent work, so voice carries the command and the agents carry the density." } },+ { "@type": "Question", "name": "What can you actually do by voice in Munder Difflin's Talk mode?", "acceptedAnswer": { "@type": "Answer", "text": "Press Talk and you get a low-latency voice channel to the GOD orchestrator over the OpenAI Realtime API. Michael reads the hive — tasks, board, memory, agents, activity, cost — and can create and assign tasks, dispatch agents, pause, steer, halt, spawn or hire workers, kill them, and edit schedules. Destructive verbs are gated behind spoken echo-back confirmation, and completions are spoken back the moment they land." } },+ { "@type": "Question", "name": "How does Talk mode prevent a misheard command from killing the wrong agent?", "acceptedAnswer": { "@type": "Answer", "text": "Every destructive verb is held behind a spoken echo-back confirmation: Michael repeats the exact action back and requires a distinct confirm token, never a bare yes. There are also hard refusals — he will not kill the GOD agent or target all agents at once, no matter what he heard. Task matching by voice is normalized and scored, and close matches trigger a spoken which-one disambiguation instead of silently mutating the wrong card." } },+ { "@type": "Question", "name": "Can a forgotten-open voice session run up a bill?", "acceptedAnswer": { "@type": "Answer", "text": "No — that failure mode is engineered out. Voice sessions run under a live cost meter with a hard spend cap that auto-disconnects when hit, plus a configurable idle auto-disconnect (default 3 minutes) so an open mic in an empty room shuts itself off. Realtime voice is metered, so both guards exist precisely because the channel costs money while it is open." } },+ { "@type": "Question", "name": "Are voice-issued actions auditable?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Every action taken by voice is attributed to a distinct michael-voice actor in messages, the board, and the activity log, and it notifies the GOD terminal. A voice-driven dispatch never silently impersonates a worker or blends into typed commands — you can always tell, after the fact, which changes to the floor came in through the microphone." } },+ { "@type": "Question", "name": "What do I need to use Talk mode?", "acceptedAnswer": { "@type": "Answer", "text": "Your own OpenAI key with Realtime API access — it's bring-your-own-key, set in Settings → AI Engines. The key is decrypted only in the Electron main process and minted into short-lived ephemeral session tokens; it never reaches the renderer. Without a key the Talk button stays visibly disabled with a needs-OpenAI-key cue rather than failing silently." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>Voice Is a Control Plane, Not a Gimmick</h1>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>Voice is a terrible interface for writing code and a genuinely good interface for running a fleet.</strong> The trick is bandwidth: code is high-bandwidth and precise, but orchestration — <strong>delegation, status, approvals</strong> — is a stream of short, intent-shaped commands that fan out into minutes of agent work. Munder Difflin's <strong>Talk mode</strong> (v0.3.2) is the case study: a realtime voice channel to the GOD orchestrator with <strong>spoken echo-back confirmation</strong> for destructive verbs, a distinct <strong>michael-voice</strong> audit identity, a <strong>hard spend cap</strong>, <strong>idle auto-disconnect</strong>, and <strong>completions spoken back</strong> the moment they land. Voice done as a control plane, not a party trick.</p></div>+<p>Every few months someone demos “coding by voice” and the reaction is always the same: neat, and nobody wants it. Dictating a diff is strictly worse than typing one. So the whole category gets filed under gimmick, and that’s a mistake — because the demo was testing voice against the wrong workload.</p>+<h2 id="the-bandwidth-argument" tabindex="-1">The bandwidth argument <a class="anchor" href="#the-bandwidth-argument" aria-hidden="true">#</a></h2>+<p>Think of any interface as a channel, and ask whether the channel’s bandwidth matches the payload.</p>+<p>Code is a high-bandwidth, high-precision payload. It’s dense with symbols, whitespace-sensitive, positional. Speaking it means serializing structure through a lossy audio channel and hoping transcription preserves <code>!==</code> versus <code>!=</code>. Typing wins. It’s not close.</p>+<p>But <strong>orchestration is a different payload entirely.</strong> When you’re running a fleet of agents, the things <em>you</em> actually emit are tiny:</p>+<ul>+<li><strong>Delegation</strong> — “have someone fix the flaky auth test.”</li>+<li><strong>Status</strong> — “what’s Dwight working on? what’s on the board?”</li>+<li><strong>Approvals</strong> — “yes, kill it” / “no, hold that.”</li>+</ul>+<p>Each of these is a sentence. Each fans out into minutes or hours of high-bandwidth work that the <em>agents</em> perform — reading files, running builds, writing diffs. That’s the asymmetry that makes voice fit: <strong>low-bandwidth commands over high-bandwidth work.</strong> You supply intent; the fleet supplies density. It’s the same division of labor a <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> already imposes on typed input — voice just removes the keyboard from the loop when the keyboard was barely being used anyway.</p>+<p>The other half of the fit: orchestration is naturally <em>ambient</em>. You’re across the room while an overnight mission grinds. A status question shouldn’t cost you a walk to the desk, and a completion shouldn’t wait until you happen to glance at a terminal.</p>+<h2 id="case-study-talk-mode" tabindex="-1">Case study: Talk mode <a class="anchor" href="#case-study-talk-mode" aria-hidden="true">#</a></h2>+<p>Munder Difflin shipped this thesis as a feature in v0.3.2 (the <a href="/blog/launching-munder-difflin-v0-3-2/">launch post</a> has the full tour). Press <strong>Talk</strong> and you get a low-latency voice channel — OpenAI Realtime API over WebRTC, bring-your-own key — to Michael, the GOD orchestrator, running <em>alongside</em> the async terminal floor, not replacing it.</p>+<p>Michael listens, answers, and acts. The read side covers the hive: tasks, board, memory, agents, activity, cost. The action side is the full orchestration verb set: create and assign tasks, dispatch agents, pause / steer / halt, spawn and hire workers, kill them, edit schedules. Notice what’s <em>not</em> in that list: writing code. The voice channel never touches an editor. It only moves work around — exactly the payload the channel can carry.</p>+<p>And the loop closes in both directions. Voice-dispatched work reports back on its own: a completion watcher detects when a task lands and pushes the event into the live session so <strong>Michael speaks it unprompted</strong> — “respond when done” as a first-class behavior, with an on-screen toast, and a queue-to-notification path if the session is already closed. That’s the ambient half delivered: you delegated by sentence, and the result comes back as a sentence.</p>+<h2 id="a-control-plane-needs-guardrails-not-vibes" tabindex="-1">A control plane needs guardrails, not vibes <a class="anchor" href="#a-control-plane-needs-guardrails-not-vibes" aria-hidden="true">#</a></h2>+<p>Here’s where “control plane” stops being a metaphor and starts being an engineering standard. A microphone is a noisy, spoofable, mishearable input device wired to verbs like <em>kill</em>. If you treat that casually, you’ve built a gimmick with a blast radius. Talk mode’s guardrails are the interesting part:</p>+<p><strong>Echo-back confirmation for destructive verbs.</strong> Every destructive action is gated behind a <em>spoken</em> echo-back: Michael repeats exactly what he’s about to do and requires a distinct confirm token — never a bare “yes,” which a stray utterance could trip. On top of that sit hard refusals: he will not kill the GOD agent, and he will not target all agents at once, period. Even task <em>matching</em> is defensive — spoken phrases are normalized and scored against stored titles, and a close call triggers a spoken “which one?” instead of silently mutating the wrong card. This is the same discipline as any <a href="/blog/human-in-the-loop-approving-ai-agents/">human-in-the-loop approval gate</a>, adapted to a channel where the human’s “click” is a phrase.</p>+<p><strong>michael-voice as a distinct actor.</strong> Everything done by voice is attributed to a separate <strong>michael-voice</strong> identity in messages, the board, and the activity log, and it pings the GOD terminal. A voice dispatch is auditable and never impersonates a worker — which matters enormously when you’re later reconstructing <em>why</em> the floor did something (the case for that paper trail is the whole <a href="/blog/observability-for-agent-fleets/">observability argument</a>).</p>+<p><strong>Spend cap and idle disconnect.</strong> Realtime voice is metered, so the session runs under a live cost HUD with a <strong>hard spend cap</strong> that auto-disconnects when hit, plus a configurable <strong>idle auto-disconnect</strong> (default 3 minutes) so a forgotten-open mic can’t quietly run a bill. A control plane you’re afraid to leave enabled isn’t a control plane.</p>+<p><strong>Key hygiene.</strong> It’s BYOK, and the OpenAI key is decrypted main-process-only, minted into short-lived ephemeral session tokens — the real key never reaches the renderer. No key? The Talk button is visibly disabled with a “needs OpenAI key” cue instead of a dead click.</p>+<p>None of these guardrails would matter for a demo. All of them matter for a control plane you use daily — and the whole path (connect, ask, confirm, spawn, kill, dispatch, completion spoken back) was human-verified end-to-end on a real key before it shipped.</p>+<h2 id="the-takeaway" tabindex="-1">The takeaway <a class="anchor" href="#the-takeaway" aria-hidden="true">#</a></h2>+<p>Judge voice by the payload you put on it. As an authoring channel for code, it loses to a keyboard every time. As a <strong>control plane</strong> for a fleet — delegation, status, approvals, completions — it’s the natural interface, <em>provided</em> it’s built like infrastructure: confirmations for anything destructive, a distinct audit identity, caps on spend, and a timeout on silence. That’s the difference between a gimmick and a plane you’d actually fly.</p>+<p>If you want to try the case study, <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">download Munder Difflin</a> — free, MIT-licensed, local-first — and if the idea resonates, a <a href="https://github.com/chaitanyagiri/munder-difflin">star on GitHub</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Why is voice bad for writing code but good for orchestrating agents?</p>+ <p class="a">Because the bandwidth is mismatched in one direction and matched in the other. Code is dense, precise, and positional — dictating a diff by voice is slower and more error-prone than typing it. Orchestration commands are the opposite: short, intent-shaped utterances like assign this, what's the status, kill that worker. A sentence of intent fans out into minutes of agent work, so voice carries the command and the agents carry the density.</p>+ </div>++ <div class="qa">+ <p class="q">What can you actually do by voice in Munder Difflin's Talk mode?</p>+ <p class="a">Press Talk and you get a low-latency voice channel to the GOD orchestrator over the OpenAI Realtime API. Michael reads the hive — tasks, board, memory, agents, activity, cost — and can create and assign tasks, dispatch agents, pause, steer, halt, spawn or hire workers, kill them, and edit schedules. Destructive verbs are gated behind spoken echo-back confirmation, and completions are spoken back the moment they land.</p>+ </div>++ <div class="qa">+ <p class="q">How does Talk mode prevent a misheard command from killing the wrong agent?</p>+ <p class="a">Every destructive verb is held behind a spoken echo-back confirmation: Michael repeats the exact action back and requires a distinct confirm token, never a bare yes. There are also hard refusals — he will not kill the GOD agent or target all agents at once, no matter what he heard. Task matching by voice is normalized and scored, and close matches trigger a spoken which-one disambiguation instead of silently mutating the wrong card.</p>+ </div>++ <div class="qa">+ <p class="q">Can a forgotten-open voice session run up a bill?</p>+ <p class="a">No — that failure mode is engineered out. Voice sessions run under a live cost meter with a hard spend cap that auto-disconnects when hit, plus a configurable idle auto-disconnect (default 3 minutes) so an open mic in an empty room shuts itself off. Realtime voice is metered, so both guards exist precisely because the channel costs money while it is open.</p>+ </div>++ <div class="qa">+ <p class="q">Are voice-issued actions auditable?</p>+ <p class="a">Yes. Every action taken by voice is attributed to a distinct michael-voice actor in messages, the board, and the activity log, and it notifies the GOD terminal. A voice-driven dispatch never silently impersonates a worker or blends into typed commands — you can always tell, after the fact, which changes to the floor came in through the microphone.</p>+ </div>++ <div class="qa">+ <p class="q">What do I need to use Talk mode?</p>+ <p class="a">Your own OpenAI key with Realtime API access — it's bring-your-own-key, set in Settings → AI Engines. The key is decrypted only in the Electron main process and minted into short-lived ephemeral session tokens; it never reaches the renderer. Without a key the Talk button stays visibly disabled with a needs-OpenAI-key cue rather than failing silently.</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/voice/">Voice</a><a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop</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-bandwidth-argument">The bandwidth argument</a></li><li class="lvl-2"><a href="#case-study-talk-mode">Case study: Talk mode</a></li><li class="lvl-2"><a href="#a-control-plane-needs-guardrails-not-vibes">A control plane needs guardrails, not vibes</a></li><li class="lvl-2"><a href="#the-takeaway">The takeaway</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/what-is-an-agent-development-environment/"><span class="k">← Older</span><span class="t">What Is an Agent Development Environment (ADE)?</span></a>+ <a class="pn next" href="/blog/tmux-and-scripts-vs-an-agent-harness/"><span class="k">Newer →</span><span class="t">Running Agents in tmux vs an Agent Harness</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/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/what-is-an-agent-development-environment/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/what-is-an-agent-development-environment/">What Is an Agent Development Environment (ADE)?</a></h3>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/what-is-an-agent-development-environment/" aria-label="Read: What Is an Agent Development Environment (ADE)?">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/what-are-claude-code-agents/index.html b/docs/blog/what-are-claude-code-agents/index.htmlindex e3260daa..aea36c1c 100644--- a/docs/blog/what-are-claude-code-agents/index.html+++ b/docs/blog/what-are-claude-code-agents/index.html@@ -246,56 +246,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex 361c0aa5..04b4562f 100644--- a/docs/blog/what-is-a-multi-agent-harness/index.html+++ b/docs/blog/what-is-a-multi-agent-harness/index.html@@ -233,56 +233,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex dd837a2b..aa8b5a9e 100644--- a/docs/blog/what-is-aeo-for-dev-tools/index.html+++ b/docs/blog/what-is-aeo-for-dev-tools/index.html@@ -366,56 +366,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/what-is-an-agent-development-environment/index.html b/docs/blog/what-is-an-agent-development-environment/index.htmlnew file mode 100644index 00000000..237e539a--- /dev/null+++ b/docs/blog/what-is-an-agent-development-environment/index.html@@ -0,0 +1,329 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>What Is an Agent Development Environment (ADE)? — Munder Difflin Blog</title>+<meta name="description" content="ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick." />+<link rel="canonical" href="https://munderdiffl.in/blog/what-is-an-agent-development-environment/" />++<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="What Is an Agent Development Environment (ADE)? — Munder Difflin Blog" />+<meta property="og:description" content="ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick." />+<meta property="og:url" content="https://munderdiffl.in/blog/what-is-an-agent-development-environment/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Concepts" />+<meta property="article:tag" content="ADE" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Tooling Landscape" />+<meta property="article:tag" content="CLI Agents" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="What Is an Agent Development Environment (ADE)? — Munder Difflin Blog" />+<meta name="twitter:description" content="ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick." />+<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": "What Is an Agent Development Environment (ADE)?",+ "description": "ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/what-is-an-agent-development-environment/" },+ "keywords": "agent development environment, what is an ADE, agentic development environment, agent IDE vs agent CLI, multi-agent coding tools 2026, agent harness vs ADE, parallel coding agents",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/what-is-an-agent-development-environment/"+}+</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": "What Is an Agent Development Environment (ADE)?", "item": "https://munderdiffl.in/blog/what-is-an-agent-development-environment/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is an Agent Development Environment (ADE)?", "acceptedAnswer": { "@type": "Answer", "text": "The term has two meanings in 2026. In Letta's original sense, an ADE is a platform for building and debugging AI agents themselves — inspecting context windows, memory, and reasoning. In the coding-tools sense that Orca popularized, an ADE is a desktop workspace for running multiple coding agents in parallel, each in its own isolated git worktree, with the tooling to review and ship what they produce. Most people saying ADE today mean the second sense." } },+ { "@type": "Question", "name": "How is an ADE different from an AI IDE like Cursor?", "acceptedAnswer": { "@type": "Answer", "text": "An AI IDE is editor-first: you write and steer, and agents assist inside your editing session — Cursor's Agent mode, Composer, and background agents all orbit the file you have open. An ADE is agent-first: the primary objects on screen are agents and their tasks, not files, and you delegate whole goals rather than steering each step. The rough inflection point is when work spans many files or needs several agents running in parallel." } },+ { "@type": "Question", "name": "Is Munder Difflin an ADE?", "acceptedAnswer": { "@type": "Answer", "text": "It's adjacent but a different category: a multi-agent harness, or an agent office. Like an ADE it runs many real CLI agents in parallel worktrees. Unlike most ADEs it adds an orchestrator agent (Michael) that routes work between agents, shared long-term memory, mailboxes so agents message each other, triggers (Slack, webhooks, schedules, voice), and guardrails like budgets, approval gates, and a circuit breaker. An ADE optimizes for you driving N agents; a harness optimizes for the agents coordinating each other while you supervise." } },+ { "@type": "Question", "name": "Why did Munder Difflin add an IDE if it's not an ADE?", "acceptedAnswer": { "@type": "Answer", "text": "Because whatever runs your agents, you still need to read what they wrote. v0.3.3 added a built-in Monaco editor (the VS Code editor engine, self-hosted) over the office floor: a file tree, editor tabs with save, and a side-by-side git diff of every agent change against HEAD. It's a review surface inside the harness, not a pivot to being an editor — the floor, orchestrator, and hive remain the product." } },+ { "@type": "Question", "name": "Do agent CLIs like Claude Code and Codex compete with ADEs?", "acceptedAnswer": { "@type": "Answer", "text": "No — they're the layer underneath. Claude Code and OpenAI Codex CLI are single-agent terminal programs, and they're what ADEs and harnesses actually run. Orca runs your existing CLI agents in parallel worktrees; Munder Difflin spawns them as real node-pty processes and coordinates them. Your CLI subscription is the engine; the ADE or harness is the chassis around it." } },+ { "@type": "Question", "name": "How do I choose between a chat IDE, an agent CLI, an ADE, and a harness?", "acceptedAnswer": { "@type": "Answer", "text": "Match the tool to how much you delegate. Staying in the loop on one change: an AI IDE. Delegating one task end-to-end: an agent CLI. Personally driving several agents in parallel on one repo: an ADE. Running an always-on team that routes work among itself, shares memory, and answers triggers while you supervise: a multi-agent harness like Munder Difflin." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>What Is an Agent Development Environment (ADE)?</h1>+ <p class="dek">ADE means two things in 2026: a platform for building agents (Letta's sense) and a workspace for shipping code with fleets of coding agents (Orca's sense). Here's the full tooling map — chat IDEs, agent CLIs, agent IDEs, and agent harnesses — and how to pick.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>"ADE" means two different things in 2026.</strong> Letta coined <em>Agent Development Environment</em> for a platform to <strong>build and debug agents themselves</strong>. The coding world then adopted it for something else: a workspace for <strong>shipping software with fleets of coding agents</strong> — Orca is the flagship example. The map now has four layers: <strong>AI IDEs</strong> (Cursor — editor-first, you steer), <strong>agent CLIs</strong> (Claude Code, Codex — one agent, one terminal, full delegation), <strong>agent IDEs / ADEs</strong> (Orca, JetBrains Air — you drive N parallel agents), and <strong>agent harnesses</strong> (Munder Difflin — the agents coordinate <em>each other</em> under an orchestrator, with shared memory, triggers, and guardrails). The categories are blurring from every direction — v0.3.3 even put a Monaco IDE <em>inside</em> the harness — but the question that picks your tool hasn't changed: <strong>how much are you delegating?</strong></p></div>+<p>Every few months the agent-tooling world mints a new acronym, and 2026’s is <strong>ADE</strong>. It’s a genuinely useful term — once you notice it’s being used for two different things.</p>+<h2 id="two-meanings-one-acronym" tabindex="-1">Two meanings, one acronym <a class="anchor" href="#two-meanings-one-acronym" aria-hidden="true">#</a></h2>+<p>The original coinage belongs to <a href="https://www.letta.com/blog/introducing-the-agent-development-environment">Letta</a>, which uses <em>Agent Development Environment</em> for a visual platform to <strong>build and debug agents themselves</strong>: inspect an agent’s context window, edit its memory blocks, watch its reasoning, wire its tools. In that sense, an ADE is to agents what an IDE is to code — the artifact under development <em>is the agent</em>.</p>+<p>Then the coding-tools world borrowed the acronym for something adjacent but distinct. <a href="https://github.com/stablyai/orca">Orca</a> calls itself “the ADE for working with a fleet of parallel agents,” and <a href="https://www.augmentcode.com/guides/what-is-an-agentic-development-environment">Augment Code’s guides</a> describe an <em>agentic development environment</em> as an agent-first workspace where developers delegate whole goals instead of steering an editor. In this sense the artifact under development is still <strong>your software</strong> — the ADE is where a fleet of coding agents builds it.</p>+<p>Most people saying “ADE” in a dev-tools context mean the second sense. That’s the sense this post maps.</p>+<h2 id="the-2026-landscape-four-layers-of-delegation" tabindex="-1">The 2026 landscape: four layers of delegation <a class="anchor" href="#the-2026-landscape-four-layers-of-delegation" aria-hidden="true">#</a></h2>+<p>The clean way to sort the tools is not by feature list but by <strong>how much you hand over</strong>.</p>+<p><strong>1. AI IDEs — you steer every step.</strong> <a href="https://cursor.com/">Cursor</a> is the archetype: an editor-first workspace where agents live inside your editing session. Its Agent mode reads the codebase, edits files, runs commands, and iterates; Composer produces reviewable multi-file diffs; background and cloud agents run tasks off to the side. It’s excellent at what it optimizes for — a developer who stays in the loop, file by file, with agents as force multipliers. The center of gravity is still <em>you, in an editor</em>.</p>+<p><strong>2. Agent CLIs — you delegate one task.</strong> <a href="https://claude.com/claude-code">Claude Code</a> and <a href="https://github.com/openai/codex">OpenAI Codex CLI</a> are single-agent terminal programs: give one a goal and it reads files, runs builds and tests, uses git, and verifies its own work by executing it. This is the layer with real terminal-level power — we wrote about <a href="/blog/why-cli-agents-are-powerful/">why CLI agents are so capable</a> — but each session is one agent, one terminal, one task.</p>+<p><strong>3. Agent IDEs / ADEs — you drive N agents in parallel.</strong> Once you’re running four CLI sessions at once, tab-juggling breaks down, and this is the gap ADEs fill. Orca runs your existing CLI agents — Claude Code, Codex, and others, on your own subscriptions — in parallel, each task in an <strong>isolated git worktree</strong> with its own terminal and context, plus review tooling to merge the results. JetBrains is in the same lane with Air, a standalone multi-agent workspace. The defining trait: <em>you</em> are still the dispatcher. You assign every task, watch every lane, and merge every result.</p>+<p><strong>4. Agent harnesses / offices — the agents coordinate each other.</strong> This is where <strong>Munder Difflin</strong> sits, and it’s a different bet. Like an ADE, it runs real CLI agents (seven engines as of v0.3.3, including GitHub Copilot CLI) in isolated worktrees and real pseudo-terminals. Unlike an ADE, you don’t dispatch to each agent yourself: a GOD orchestrator — Michael — routes work, agents message each other through mailboxes, share <a href="/blog/semantic-memory-for-ai-agents/">long-term semantic memory</a>, and get woken by triggers — typing, Slack, webhooks, schedules, even voice. Guardrails (approval gates, per-agent budgets, a circuit breaker, OTel observability) make it safe to leave running. The mental model isn’t “my editor got agents” or “my agents got lanes” — it’s <em>an office you supervise</em>. We’ve written a fuller definition in <a href="/blog/what-is-a-multi-agent-harness/">what is a multi-agent harness</a>.</p>+<h2 id="where-the-categories-blur" tabindex="-1">Where the categories blur <a class="anchor" href="#where-the-categories-blur" aria-hidden="true">#</a></h2>+<p>Nobody stays in their lane, and the direction of travel is telling.</p>+<p>Cursor grew a CLI and cloud agents — the editor reaching toward delegation. ADEs like Orca embed browsers and diff tooling — the dispatcher growing verification surfaces. And Munder Difflin’s v0.3.3 added a <strong>built-in Monaco IDE</strong> — the VS Code editor engine, self-hosted, one click over the office floor, with a file tree, tabs, and side-by-side git diffs of every agent change against HEAD. A harness growing an editor, precisely because the bottleneck in agent-heavy work shifts from <em>writing</em> code to <em>reviewing</em> it.</p>+<p>Everyone is converging on the same shape: <strong>many agents, isolated workspaces, and a first-class place to review what they did.</strong> The categories differ in what they treat as the primary object — the file (IDE), the task (CLI), the lane (ADE), or the <em>team</em> (harness).</p>+<h2 id="how-to-choose" tabindex="-1">How to choose <a class="anchor" href="#how-to-choose" aria-hidden="true">#</a></h2>+<p>Match the tool to your delegation level, not the hype cycle:</p>+<ul>+<li>Reviewing every edit as it happens → an <strong>AI IDE</strong>.</li>+<li>Handing off one well-scoped task → an <strong>agent CLI</strong>.</li>+<li>Personally running several parallel agents on one repo → an <strong>ADE</strong>.</li>+<li>Running an always-on team that routes its own work while you supervise → a <strong>harness</strong>.</li>+</ul>+<p>These stack rather than compete — Orca and Munder Difflin both <em>run</em> Claude Code and Codex; your CLI subscription is the engine either way. For a decision framework with sharper questions (team size, autonomy appetite, budget controls), see <a href="/blog/how-to-choose-a-multi-agent-tool/">how to choose a multi-agent tool</a>.</p>+<p>And if the office model sounds like your level of delegation: Munder Difflin is free, MIT-licensed, and local-first — <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">grab the latest release</a>, and if it earns it, a <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub star</a> helps more people find it.</p>+<p>Sources: <a href="https://www.letta.com/blog/introducing-the-agent-development-environment">Letta — Introducing the Agent Development Environment</a>;+<a href="https://github.com/stablyai/orca">Orca (stablyai/orca)</a>; <a href="https://www.onorca.dev/">Orca — onorca.dev</a>;+<a href="https://www.augmentcode.com/guides/what-is-an-agentic-development-environment">Augment Code — What is an agentic development environment?</a>;+<a href="https://cursor.com/">Cursor</a>; <a href="https://github.com/openai/codex">OpenAI Codex CLI</a>.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is an Agent Development Environment (ADE)?</p>+ <p class="a">The term has two meanings in 2026. In Letta's original sense, an ADE is a platform for building and debugging AI agents themselves — inspecting context windows, memory, and reasoning. In the coding-tools sense that Orca popularized, an ADE is a desktop workspace for running multiple coding agents in parallel, each in its own isolated git worktree, with the tooling to review and ship what they produce. Most people saying ADE today mean the second sense.</p>+ </div>++ <div class="qa">+ <p class="q">How is an ADE different from an AI IDE like Cursor?</p>+ <p class="a">An AI IDE is editor-first: you write and steer, and agents assist inside your editing session — Cursor's Agent mode, Composer, and background agents all orbit the file you have open. An ADE is agent-first: the primary objects on screen are agents and their tasks, not files, and you delegate whole goals rather than steering each step. The rough inflection point is when work spans many files or needs several agents running in parallel.</p>+ </div>++ <div class="qa">+ <p class="q">Is Munder Difflin an ADE?</p>+ <p class="a">It's adjacent but a different category: a multi-agent harness, or an agent office. Like an ADE it runs many real CLI agents in parallel worktrees. Unlike most ADEs it adds an orchestrator agent (Michael) that routes work between agents, shared long-term memory, mailboxes so agents message each other, triggers (Slack, webhooks, schedules, voice), and guardrails like budgets, approval gates, and a circuit breaker. An ADE optimizes for you driving N agents; a harness optimizes for the agents coordinating each other while you supervise.</p>+ </div>++ <div class="qa">+ <p class="q">Why did Munder Difflin add an IDE if it's not an ADE?</p>+ <p class="a">Because whatever runs your agents, you still need to read what they wrote. v0.3.3 added a built-in Monaco editor (the VS Code editor engine, self-hosted) over the office floor: a file tree, editor tabs with save, and a side-by-side git diff of every agent change against HEAD. It's a review surface inside the harness, not a pivot to being an editor — the floor, orchestrator, and hive remain the product.</p>+ </div>++ <div class="qa">+ <p class="q">Do agent CLIs like Claude Code and Codex compete with ADEs?</p>+ <p class="a">No — they're the layer underneath. Claude Code and OpenAI Codex CLI are single-agent terminal programs, and they're what ADEs and harnesses actually run. Orca runs your existing CLI agents in parallel worktrees; Munder Difflin spawns them as real node-pty processes and coordinates them. Your CLI subscription is the engine; the ADE or harness is the chassis around it.</p>+ </div>++ <div class="qa">+ <p class="q">How do I choose between a chat IDE, an agent CLI, an ADE, and a harness?</p>+ <p class="a">Match the tool to how much you delegate. Staying in the loop on one change: an AI IDE. Delegating one task end-to-end: an agent CLI. Personally driving several agents in parallel on one repo: an ADE. Running an always-on team that routes work among itself, shares memory, and answers triggers while you supervise: a multi-agent harness like Munder Difflin.</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/ade/">ADE</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/tooling-landscape/">Tooling Landscape</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="#two-meanings-one-acronym">Two meanings, one acronym</a></li><li class="lvl-2"><a href="#the-2026-landscape-four-layers-of-delegation">The 2026 landscape: four layers of delegation</a></li><li class="lvl-2"><a href="#where-the-categories-blur">Where the categories blur</a></li><li class="lvl-2"><a href="#how-to-choose">How to choose</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/what-is-harness-engineering/"><span class="k">← Older</span><span class="t">What Is Harness Engineering?</span></a>+ <a class="pn next" href="/blog/voice-as-a-control-plane-for-agent-fleets/"><span class="k">Newer →</span><span class="t">Voice Is a Control Plane, Not a Gimmick</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/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/what-is-harness-engineering/index.html b/docs/blog/what-is-harness-engineering/index.htmlnew file mode 100644index 00000000..34b673a3--- /dev/null+++ b/docs/blog/what-is-harness-engineering/index.html@@ -0,0 +1,330 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>What Is Harness Engineering? — Munder Difflin Blog</title>+<meta name="description" content="Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin." />+<link rel="canonical" href="https://munderdiffl.in/blog/what-is-harness-engineering/" />++<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="What Is Harness Engineering? — Munder Difflin Blog" />+<meta property="og:description" content="Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin." />+<meta property="og:url" content="https://munderdiffl.in/blog/what-is-harness-engineering/" />+<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-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Concepts" />+<meta property="article:tag" content="Harness Engineering" />+<meta property="article:tag" content="Reliability" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Architecture" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="What Is Harness Engineering? — Munder Difflin Blog" />+<meta name="twitter:description" content="Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin." />+<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": "What Is Harness Engineering?",+ "description": "Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/what-is-harness-engineering/" },+ "keywords": "harness engineering, what is harness engineering, agent harness, ai agent reliability, the model is a commodity, agent infrastructure, multi-agent harness",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/what-is-harness-engineering/"+}+</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": "What Is Harness Engineering?", "item": "https://munderdiffl.in/blog/what-is-harness-engineering/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is harness engineering?", "acceptedAnswer": { "@type": "Answer", "text": "Harness engineering is the discipline of building the environment around an AI model that turns it into a reliable agent: the process plumbing, lifecycle hooks, message routing, memory, budgets, human approval gates, observability, and recovery mechanics. The working equation is agent = model + harness. The model supplies raw capability; the harness determines whether that capability shows up predictably, safely, and repeatably in production." } },+ { "@type": "Question", "name": "Who coined the term harness engineering?", "acceptedAnswer": { "@type": "Answer", "text": "The term was popularized by Mitchell Hashimoto, co-founder of HashiCorp, in a February 2026 blog post about his AI adoption journey. His core premise: any time an agent makes a mistake, you engineer a solution so the agent never makes that mistake again. The 2026 agent-engineering discourse has since adopted it as the phase that follows prompt engineering and context engineering." } },+ { "@type": "Question", "name": "Why is the harness more important than the model?", "acceptedAnswer": { "@type": "Answer", "text": "Because models are increasingly interchangeable commodities and their failure modes are structural, not intelligence-limited. An agent that loops, forgets, overspends, or silently drops a message doesn't need a smarter model — it needs a circuit breaker, a memory layer, a budget, and a mailbox with delivery guarantees. Reported results back this up: teams have climbed agent benchmarks significantly by changing only the harness, with the model held constant." } },+ { "@type": "Question", "name": "What are the components of an agent harness?", "acceptedAnswer": { "@type": "Answer", "text": "A production harness typically covers: real execution plumbing (PTYs or sandboxes the agent acts through), lifecycle hooks (structured signals for turn start/end and tool use), inter-agent messaging with delivery guarantees, long-term memory, token budgets and cost controls, human-in-the-loop gates for destructive or expensive actions, observability (traces, costs, per-agent telemetry), and session resume so a restart doesn't destroy state." } },+ { "@type": "Question", "name": "Is harness engineering the same as prompt engineering?", "acceptedAnswer": { "@type": "Answer", "text": "No, but it absorbs it. Prompt engineering shapes a single model call; context engineering shapes what the model sees across a task; harness engineering shapes the entire system the model operates inside — including what happens when a call fails, a process dies, a budget is exceeded, or two agents need to hand off work. Prompts are one component of the harness, not a substitute for it." } },+ { "@type": "Question", "name": "Is Munder Difflin a harness?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — that's the category. Munder Difflin is a free, MIT-licensed, local-first multi-agent harness: it wraps the agent CLIs you already run (Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, GitHub Copilot CLI) in node-pty pseudo-terminals, wires them into a hive with mailboxes, shared memory, budgets, a circuit breaker, human approval gates, and observability, and puts a GOD orchestrator in charge." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>What Is Harness Engineering?</h1>+ <p class="dek">Harness engineering is the discipline of building everything around the model — PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability — because that's where agent reliability actually comes from. A definition, and four case studies from inside Munder Difflin.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>5 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>Harness engineering is the discipline of building everything around the model</strong> — the PTY plumbing, lifecycle hooks, mailboxes, memory, budgets, human gates, observability, and session resume that turn a capable model into a <strong>reliable agent</strong>. The 2026 consensus, popularized by Mitchell Hashimoto: <strong>the model is a commodity; the harness is where reliability comes from</strong>. Every time an agent fails, you engineer the harness so that failure becomes structurally impossible. Munder Difflin is this discipline shipped as a product — and its hook shim, node-pty layer, MemPalace, and circuit breaker are worked examples.</p></div>+<p>Ask why an agent failed and you’ll almost never hear “the model wasn’t smart enough.” You’ll hear: it looped for forty minutes, it forgot what it learned yesterday, it blew the budget overnight, it dropped a message and nobody noticed, the process died and took the session with it.</p>+<p>None of those are model problems. All of them are <strong>harness problems</strong>. And in 2026, fixing them got a name.</p>+<h2 id="the-term-and-where-it-came-from" tabindex="-1">The term, and where it came from <a class="anchor" href="#the-term-and-where-it-came-from" aria-hidden="true">#</a></h2>+<p><strong>Harness engineering</strong> was popularized by Mitchell Hashimoto (co-founder of HashiCorp) in a February 2026 post on <a href="https://mitchellh.com/writing/my-ai-adoption-journey">his AI adoption journey</a>. His formulation is disarmingly simple: <em>any time you find an agent makes a mistake, you take the time to engineer a solution such that the agent never makes that mistake again.</em> Not a better prompt. Not a smarter model. A structural fix in the environment the agent operates in, so the failure class is closed permanently.</p>+<p>The broader discourse picked the term up fast, and a rough consensus formed: harness engineering is the <strong>third phase of agent-engineering maturity</strong> — after prompt engineering (shape one call) and context engineering (shape what the model sees), you shape <em>the entire system the model operates inside</em>. Industry write-ups like <a href="https://www.faros.ai/blog/harness-engineering">Faros AI’s guide</a> converge on the same anatomy — tool orchestration, verification loops, context and memory, guardrails, observability — and point at the evidence that motivates it: teams have jumped whole leaderboards on agent benchmarks (Faros cites LangChain climbing Terminal Bench 2.0 from 30th to 5th) <strong>without changing the model at all</strong>. Same model, different harness, different outcome.</p>+<p>That’s the whole thesis in one line: <strong>the model is a commodity input; the harness is the differentiated system.</strong> Frontier models leapfrog each other every quarter, and every serious agent product supports several of them interchangeably. What doesn’t come off a shelf is the machinery that makes any of them dependable.</p>+<h2 id="what-a-harness-actually-contains" tabindex="-1">What a harness actually contains <a class="anchor" href="#what-a-harness-actually-contains" aria-hidden="true">#</a></h2>+<p>Strip the buzzwords and a production harness is a specific list of unglamorous subsystems:</p>+<ul>+<li><strong>Execution plumbing.</strong> A real place for the agent to act — a pseudo-terminal, a sandbox, a worktree — not a simulated one.</li>+<li><strong>Lifecycle hooks.</strong> Structured signals for turn start, turn end, and tool use, so the harness <em>knows</em> what the agent is doing rather than guessing from stdout.</li>+<li><strong>Mailboxes and routing.</strong> Inter-agent messages with delivery guarantees; a dropped handoff must bounce somewhere visible, never vanish.</li>+<li><strong>Memory.</strong> Durable, recallable knowledge that survives the session, so agents stop re-deriving the same facts.</li>+<li><strong>Budgets and breakers.</strong> Hard ceilings on tokens and cost, plus a mechanism that intervenes when an agent runs away.</li>+<li><strong>Human gates.</strong> Approval checkpoints on spend, scope changes, and destructive operations — human-in-the-loop by design.</li>+<li><strong>Observability.</strong> Traces, per-agent cost attribution, live telemetry — <a href="/blog/observability-for-agent-fleets/">you can’t operate a fleet you can’t see</a>.</li>+<li><strong>Session resume.</strong> A restart — of the app, the machine, or one agent — must reattach state, not destroy it.</li>+</ul>+<p>Notice what’s absent: anything about making the model smarter. Harness engineering takes model capability as given and engineers everything else. (For how this differs from a single-agent wrapper, see <a href="/blog/what-is-a-multi-agent-harness/">what a multi-agent harness is</a>.)</p>+<h2 id="four-case-studies-from-inside-munder-difflin" tabindex="-1">Four case studies from inside Munder Difflin <a class="anchor" href="#four-case-studies-from-inside-munder-difflin" aria-hidden="true">#</a></h2>+<p>Munder Difflin is this discipline shipped as a product, so its internals make good worked examples.</p>+<p><strong>The hook shim — lifecycle truth instead of stdout guessing.</strong> Every provider speaks lifecycle differently: Claude Code has native hooks, Antigravity needed a purpose-built <code>agy-hook</code> bridge, Codex gets the protocol injected as its initial prompt. The harness normalizes all of them into one hook server (<code>hooks.ts</code>) that receives structured POST payloads — so “the agent finished its turn” is a <em>signal</em>, not an inference from a quiet terminal. And where a provider has no bridge at all, the harness engineers around the gap honestly: GitHub Copilot CLI’s print mode can’t drain an inbox, so routed mail <strong>bounces to the GOD orchestrator</strong> instead of silently dropping. That is Hashimoto’s rule applied — the “silently lost message” failure class is closed structurally.</p>+<p><strong>node-pty — real terminals, not string simulations.</strong> Each agent is a real CLI process in its own pseudo-terminal, byte-for-byte authentic, with full read/write/resize/kill — paired with per-agent git worktrees so agents never collide on branches. The unglamorous plumbing (a <code>PtyManager</code>, per-id IPC streams, a postinstall that rebuilds the native addon against Electron’s ABI) is exactly the kind of work the model can never do for you, and exactly what makes the agent’s terminal access <em>real</em>.</p>+<p><strong>MemPalace — memory as infrastructure.</strong> Agents write markdown-first long-term memory, mined into a shared semantic index for instant recall, with a MemoryReflector that condenses it so it doesn’t grow without bound. “The agent forgot” stops being a shrug and becomes a subsystem with behavior you can engineer — the deep dive is in <a href="/blog/semantic-memory-for-ai-agents/">semantic memory for AI agents</a>.</p>+<p><strong>The circuit breaker — graduated intervention, not a kill switch.</strong> The cost/runaway guard runs a <strong>steer → constrain → stop</strong> ladder: nudge an agent that’s looping, constrain it if it persists, stop it if it storms errors or blows its per-agent token budget. Paired with approval gates on spend and destructive ops, this is what makes 24/7 autonomy something you can actually sleep through — part of the larger practice of <a href="/blog/building-reliable-ai-agents/">building reliable AI agents</a>.</p>+<h2 id="why-this-is-a-discipline-not-a-feature-list" tabindex="-1">Why this is a discipline, not a feature list <a class="anchor" href="#why-this-is-a-discipline-not-a-feature-list" aria-hidden="true">#</a></h2>+<p>The pattern across all four: <strong>reliability was engineered into the environment, not prompted into the model.</strong> Each subsystem exists because a specific failure mode exists, and each closes that failure mode for every model, every provider, permanently. Swap Claude for Codex or a local model tomorrow — the breaker still breaks, the mail still routes, the memory still recalls. That’s what “the model is a commodity” means in practice: the harness is the part that compounds.</p>+<p>If you want to see a harness rather than read about one, <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">download Munder Difflin</a> — free, MIT-licensed, local-first — and if the idea resonates, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>+<p>Sources: <a href="https://mitchellh.com/writing/my-ai-adoption-journey">Mitchell Hashimoto — My AI Adoption Journey</a>;+<a href="https://www.faros.ai/blog/harness-engineering">Faros AI — Harness Engineering: Making AI Coding Agents Work in 2026</a>.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is harness engineering?</p>+ <p class="a">Harness engineering is the discipline of building the environment around an AI model that turns it into a reliable agent: the process plumbing, lifecycle hooks, message routing, memory, budgets, human approval gates, observability, and recovery mechanics. The working equation is agent = model + harness. The model supplies raw capability; the harness determines whether that capability shows up predictably, safely, and repeatably in production.</p>+ </div>++ <div class="qa">+ <p class="q">Who coined the term harness engineering?</p>+ <p class="a">The term was popularized by Mitchell Hashimoto, co-founder of HashiCorp, in a February 2026 blog post about his AI adoption journey. His core premise: any time an agent makes a mistake, you engineer a solution so the agent never makes that mistake again. The 2026 agent-engineering discourse has since adopted it as the phase that follows prompt engineering and context engineering.</p>+ </div>++ <div class="qa">+ <p class="q">Why is the harness more important than the model?</p>+ <p class="a">Because models are increasingly interchangeable commodities and their failure modes are structural, not intelligence-limited. An agent that loops, forgets, overspends, or silently drops a message doesn't need a smarter model — it needs a circuit breaker, a memory layer, a budget, and a mailbox with delivery guarantees. Reported results back this up: teams have climbed agent benchmarks significantly by changing only the harness, with the model held constant.</p>+ </div>++ <div class="qa">+ <p class="q">What are the components of an agent harness?</p>+ <p class="a">A production harness typically covers: real execution plumbing (PTYs or sandboxes the agent acts through), lifecycle hooks (structured signals for turn start/end and tool use), inter-agent messaging with delivery guarantees, long-term memory, token budgets and cost controls, human-in-the-loop gates for destructive or expensive actions, observability (traces, costs, per-agent telemetry), and session resume so a restart doesn't destroy state.</p>+ </div>++ <div class="qa">+ <p class="q">Is harness engineering the same as prompt engineering?</p>+ <p class="a">No, but it absorbs it. Prompt engineering shapes a single model call; context engineering shapes what the model sees across a task; harness engineering shapes the entire system the model operates inside — including what happens when a call fails, a process dies, a budget is exceeded, or two agents need to hand off work. Prompts are one component of the harness, not a substitute for it.</p>+ </div>++ <div class="qa">+ <p class="q">Is Munder Difflin a harness?</p>+ <p class="a">Yes — that's the category. Munder Difflin is a free, MIT-licensed, local-first multi-agent harness: it wraps the agent CLIs you already run (Claude Code, Codex, Antigravity, OpenCode, Crush, pi.dev, GitHub Copilot CLI) in node-pty pseudo-terminals, wires them into a hive with mailboxes, shared memory, budgets, a circuit breaker, human approval gates, and observability, and puts a GOD orchestrator in charge.</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/harness-engineering/">Harness Engineering</a><a class="tag" href="/blog/tags/reliability/">Reliability</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/architecture/">Architecture</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-term-and-where-it-came-from">The term, and where it came from</a></li><li class="lvl-2"><a href="#what-a-harness-actually-contains">What a harness actually contains</a></li><li class="lvl-2"><a href="#four-case-studies-from-inside-munder-difflin">Four case studies from inside Munder Difflin</a></li><li class="lvl-2"><a href="#why-this-is-a-discipline-not-a-feature-list">Why this is a discipline, not a feature list</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/your-first-hour-with-munder-difflin/"><span class="k">← Older</span><span class="t">Your First Hour With Munder Difflin</span></a>+ <a class="pn next" href="/blog/what-is-an-agent-development-environment/"><span class="k">Newer →</span><span class="t">What Is an Agent Development Environment (ADE)?</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/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/whats-new-in-agentic-ai-june-2026/index.html b/docs/blog/whats-new-in-agentic-ai-june-2026/index.htmlindex 069d5f32..5cb2774c 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@@ -325,56 +325,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/run-munder-difflin-on-a-mac-mini/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/command-center-guide/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-a-mac-mini/">Run Munder Difflin Locally on a Mac Mini</a></h3>- <p class="dek">A step-by-step guide to running a whole Munder Difflin hive offline on an Apple Silicon Mac Mini — how to size models to your unified memory, install Ollama or LM Studio, and wire OpenCode and Crush to a local endpoint.</p>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-a-mac-mini/" aria-label="Read: Run Munder Difflin Locally on a Mac Mini">Read →</a>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/run-munder-difflin-on-open-models/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-22">Jun 22, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>4 min</span></div>- <h3><a href="/blog/run-munder-difflin-on-open-models/">Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider</a></h3>- <p class="dek">Munder Difflin v0.3.1 runs your agent floor on open-weight models — gpt-oss, Qwen3, DeepSeek, Llama, Mistral, GLM, Kimi — either fully local (Ollama/LM Studio/vLLM) or through a third-party OSS provider. Here's how to wire each across the OpenCode, Crush, and pi engines.</p>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/run-munder-difflin-on-open-models/" aria-label="Read: Run Munder Difflin on Open-Source Models — Fully Local or via a Third-Party Provider">Read →</a>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">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">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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'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>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</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>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">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.htmlindex 92f8ecb8..c265b60a 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@@ -276,56 +276,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/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">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">+ <a class="thumb t-concepts" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 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's why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>+ <h3><a href="/blog/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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>+ <a class="more" href="/blog/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">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.htmlindex e3449387..83ed228a 100644--- a/docs/blog/why-cli-agents-are-powerful/index.html+++ b/docs/blog/why-cli-agents-are-powerful/index.html@@ -314,56 +314,56 @@ capability routing (right agent, not the priciest one).</p><h2>Related in Concepts</h2><div class="post-grid"><article class="card">- <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/loop-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-15">Jun 15, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>8 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>- <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>+ <h3><a href="/blog/loop-engineering-for-ai-agents/">Loop Engineering: Designing Agent Loops That Converge</a></h3>+ <p class="dek">Everyone engineers the prompt; almost nobody engineers the loop around it. Stop conditions, drain loops, retry with backoff, compaction cycles, breaker escalation, budgets, and human gates — the outer-loop mechanics that make an agent converge instead of run away.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>+ <a class="more" href="/blog/loop-engineering-for-ai-agents/" aria-label="Read: Loop Engineering: Designing Agent Loops That Converge">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">+ <a class="thumb t-concepts" href="/blog/review-agent-work-where-it-happens/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-10">Jun 10, 2026</time>+ <time datetime="2026-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>4 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>+ <h3><a href="/blog/review-agent-work-where-it-happens/">Review Agent Work Where It Happens</a></h3>+ <p class="dek">AI agents produce diffs faster than humans can review them, and alt-tabbing to an external editor breaks supervision flow. The case for review-in-place: Munder Difflin's built-in Monaco IDE puts a CHANGES rail and side-by-side diffs vs HEAD right on the office floor.</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>+ <a class="more" href="/blog/review-agent-work-where-it-happens/" aria-label="Read: Review Agent Work Where It Happens">Read →</a></div></div></article><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/voice-as-a-control-plane-for-agent-fleets/" 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-07-03">Jul 3, 2026</time><span class="dot" aria-hidden="true"></span>- <span>4 min</span>+ <span>5 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/voice-as-a-control-plane-for-agent-fleets/">Voice Is a Control Plane, Not a Gimmick</a></h3>+ <p class="dek">Voice is a terrible way to write code and a great way to run a fleet. Why low-bandwidth commands over high-bandwidth work is the right split — with Munder Difflin's Talk mode (echo-back confirmation, spend caps, michael-voice attribution) as the case study.</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/voice-as-a-control-plane-for-agent-fleets/" aria-label="Read: Voice Is a Control Plane, Not a Gimmick">Read →</a></div></div></article>diff --git a/docs/blog/your-first-hour-with-munder-difflin/index.html b/docs/blog/your-first-hour-with-munder-difflin/index.htmlnew file mode 100644index 00000000..f5730125--- /dev/null+++ b/docs/blog/your-first-hour-with-munder-difflin/index.html@@ -0,0 +1,332 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Your First Hour With Munder Difflin — Munder Difflin Blog</title>+<meta name="description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />+<link rel="canonical" href="https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" />++<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />+<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="Your First Hour With Munder Difflin — Munder Difflin Blog" />+<meta property="og:description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />+<meta property="og:url" content="https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" />+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />+<meta property="og:locale" content="en_US" />+<meta property="article:published_time" content="2026-07-03T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Onboarding" />+<meta property="article:tag" content="Getting Started" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Local-First" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Your First Hour With Munder Difflin — Munder Difflin Blog" />+<meta name="twitter:description" content="A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running." />+<meta name="twitter: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": "Your First Hour With Munder Difflin",+ "description": "A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-07-03T00:00:00.000Z",+ "dateModified": "2026-07-03T00: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/your-first-hour-with-munder-difflin/" },+ "keywords": "munder difflin onboarding, getting started with munder difflin, multi-agent harness tutorial, first hour with a multi-agent harness, god orchestrator first brief, ai agent approval queue, scheduled agent missions",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/"+}+</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": "Your First Hour With Munder Difflin", "item": "https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "How long does it take to get Munder Difflin running?", "acceptedAnswer": { "@type": "Answer", "text": "About five minutes if you already have Node.js 18+ and one supported agent CLI installed. You clone the repo, run npm install and npm run dev, and the onboarding wizard walks you through the rest: harness home, registered repos, default command, and auto-mode. Signed macOS, Windows, and Linux builds are also available on the releases page." } },+ { "@type": "Question", "name": "What do I need before installing Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "Node.js 18+ with npm, a C/C++ toolchain for node-pty's native addon (Xcode Command Line Tools on macOS), and at least one supported terminal-agent CLI on your PATH — Claude Code, Antigravity, OpenAI Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. If a chosen engine's binary is missing, the harness runs its installer in the terminal and restarts into it automatically." } },+ { "@type": "Question", "name": "Who is Michael and how do I give him work?", "acceptedAnswer": { "@type": "Answer", "text": "Michael is the GOD orchestrator — the one agent you talk to. You type a brief into his terminal (or use the Talk voice channel with your own OpenAI Realtime key) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in Michael's office automatically on first launch." } },+ { "@type": "Question", "name": "Do I have to approve everything the agents do?", "acceptedAnswer": { "@type": "Answer", "text": "No. The GOD orchestrator resolves routine requests itself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest." } },+ { "@type": "Question", "name": "How do I review what an agent actually changed?", "acceptedAnswer": { "@type": "Answer", "text": "Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD — the VS Code editor engine, fully self-hosted, with all filesystem and git access brokered through the main process. There's also a per-agent git tab with status, log, and commit graph." } },+ { "@type": "Question", "name": "Can Munder Difflin keep working after I walk away?", "acceptedAnswer": { "@type": "Answer", "text": "Yes — that's the point. The Schedules tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs 24/7 on hardware you already own." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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>Your First Hour With Munder Difflin</h1>+ <p class="dek">A minute-by-minute walkthrough of your first hour with Munder Difflin: install, the onboarding wizard, your first brief to Michael, watching the floor, approving your first escalation, and leaving a schedule running.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>4 min read</span>+ <span 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><strong>You can go from zero to a running AI office in one hour.</strong> Minute 0: install. Minute 5: the <strong>onboarding wizard</strong> (harness home, repos, auto-mode, orchestrator engine). Minute 10: your <strong>first brief to Michael</strong>, the GOD orchestrator. Minute 20: watch avatars work the floor and open a real desk terminal. Minute 40: your <strong>first approval</strong> and a side-by-side diff in the built-in <strong>Monaco IDE</strong>. Minute 60: set a <strong>schedule</strong> and walk away — the office keeps working.</p></div>+<video controls preload="none" playsinline poster="/media/demo/intro-poster.jpg" style="width:100%; border-radius:12px; margin:12px 0 24px;">+ <source src="/media/demo/intro.mp4" type="video/mp4" />+</video>+<p>Most tools ask you to learn them before they do anything. Munder Difflin is the other kind: within an hour you’ve briefed an orchestrator, watched agents work, approved a real change, and left the office running without you. Here’s that hour, minute by minute.</p>+<h2 id="minute-0-install" tabindex="-1">Minute 0 — Install <a class="anchor" href="#minute-0-install" aria-hidden="true">#</a></h2>+<p>Two paths: grab a signed build (macOS, Windows, Linux) from the <a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">releases page</a>, or clone and run from source with <code>npm install && npm run dev</code>. You need Node.js 18+, a C/C++ toolchain for <code>node-pty</code>, and at least one supported agent CLI on your <code>PATH</code> — Claude Code, Antigravity, Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI.</p>+<p>I won’t repeat the details here; the <a href="/blog/how-to-install-and-use-munder-difflin/">install and usage guide</a> covers prerequisites, troubleshooting, and the <code>node-pty</code> rebuild gotcha. Budget five minutes.</p>+<h2 id="minute-5-the-onboarding-wizard" tabindex="-1">Minute 5 — The onboarding wizard <a class="anchor" href="#minute-5-the-onboarding-wizard" aria-hidden="true">#</a></h2>+<p>First launch drops you into a short wizard, and the four choices it asks for are the actual shape of the product:</p>+<ul>+<li><strong>Harness home</strong> — the folder where the hive lives: per-agent memory, mailboxes, the blackboard, the event log. Plain files in a local git repo, relocatable later.</li>+<li><strong>Registered repos</strong> — the codebases your agents will work on. This is what feeds GitHub issue ingestion and the CI watcher later.</li>+<li><strong>Default command / auto-mode</strong> — which agent CLI new hires run by default, and whether the floor runs in auto-mode (agents proceed without per-tool prompts; the approval gate still catches critical items).</li>+<li><strong>Orchestrator engine</strong> — Michael himself runs on a pluggable engine. Claude Code is the natural default, but the wizard lets you pick, and you can change it later.</li>+</ul>+<p>Finish the wizard and you land on the floor: a pixel-art office, empty except for Michael, who seats himself in his office automatically.</p>+<h2 id="minute-10-your-first-brief-to-michael" tabindex="-1">Minute 10 — Your first brief to Michael <a class="anchor" href="#minute-10-your-first-brief-to-michael" aria-hidden="true">#</a></h2>+<p>You don’t manage the workers. You talk to one agent — the GOD orchestrator — and he runs the floor. Click into Michael’s terminal and type a brief the way you’d brief a colleague: what you want, which repo, what “done” looks like.</p>+<p>Michael adjudicates. He creates tasks on the kanban, assigns them, and routes messages between agent inboxes. Workers you hire via <strong>Add agent</strong> each get a real CLI process in its own pseudo-terminal and, with the git-isolation toggle, their own worktree — so nobody collides on branches. How he decides what to route, resolve, or escalate is its own post: <a href="/blog/how-the-god-orchestrator-works/">how the GOD orchestrator works</a>.</p>+<p>A good first brief is small and self-contained: “read this repo and write a <a href="http://REPORT.md">REPORT.md</a> summarizing the architecture” beats “refactor everything” for hour one.</p>+<h2 id="minute-20-watch-the-floor-then-open-a-desk" tabindex="-1">Minute 20 — Watch the floor, then open a desk <a class="anchor" href="#minute-20-watch-the-floor-then-open-a-desk" aria-hidden="true">#</a></h2>+<p>Now the part that makes the product legible: the floor is not a decoration, it’s the state of the system. Avatars walk to stations as they work. When the hive routes a message, an envelope flies from sender to recipient; escalations fly to the door. The cast is an affectionate parody of The Office, and every movement maps to a real event.</p>+<p>Click any agent and you get their desk: the live terminal (you can type back into it), a sandboxed file browser, and a git tab with status, log, and commit graph. This is the moment the abstraction clicks — that avatar is a real <code>claude</code> process, and you’re reading its actual stdout.</p>+<h2 id="minute-40-your-first-approval-and-the-diff" tabindex="-1">Minute 40 — Your first approval, and the diff <a class="anchor" href="#minute-40-your-first-approval-and-the-diff" aria-hidden="true">#</a></h2>+<p>Sometime in the first hour, something lands in the approvals queue — a spend threshold, a destructive operation, a scope change. This is by design: Michael resolves routine requests himself and escalates only critical items, so the queue stays short and every item in it deserves your attention. (The philosophy behind that gate: <a href="/blog/human-in-the-loop-approving-ai-agents/">approving AI agents without babysitting them</a>.)</p>+<p>Before you click approve, look at the work. Hit the title-bar <strong>IDE</strong> button and the built-in Monaco editor — the VS Code editor engine, fully self-hosted — opens over the floor. The git CHANGES rail lists what changed; click a file for a read-only side-by-side diff against HEAD. Read the diff, approve the item, watch the envelope fly.</p>+<h2 id="minute-60-leave-it-running" tabindex="-1">Minute 60 — Leave it running <a class="anchor" href="#minute-60-leave-it-running" aria-hidden="true">#</a></h2>+<p>The last move of the hour is the one that changes your relationship with the tool: schedule something. The Command Center’s <strong>Schedules</strong> tab takes a label, an interval, a target agent, and a mission body — “every morning, triage new GitHub issues,” say — and a heartbeat re-engages the floor if it goes quiet. Last-fired and next-fired times are right there in the tab.</p>+<p>Close the laptop. It’s local-first, so tomorrow the office is exactly where you left it — probably with mail in your queue. For patterns on what’s worth automating, see <a href="/blog/scheduling-autonomous-agent-missions/">scheduling autonomous agent missions</a>.</p>+<h2 id="the-hour-in-one-line" tabindex="-1">The hour, in one line <a class="anchor" href="#the-hour-in-one-line" aria-hidden="true">#</a></h2>+<p>Install, answer four wizard questions, brief one agent, watch the floor, read one diff, set one schedule — and you’ve gone from “a CLI in a terminal” to “an office that works while you don’t.”</p>+<p><a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest">Download Munder Difflin</a> — free, MIT-licensed, local-first — and if the first hour earns it, <a href="https://github.com/chaitanyagiri/munder-difflin">a GitHub star</a> helps more people find it.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">How long does it take to get Munder Difflin running?</p>+ <p class="a">About five minutes if you already have Node.js 18+ and one supported agent CLI installed. You clone the repo, run npm install and npm run dev, and the onboarding wizard walks you through the rest: harness home, registered repos, default command, and auto-mode. Signed macOS, Windows, and Linux builds are also available on the releases page.</p>+ </div>++ <div class="qa">+ <p class="q">What do I need before installing Munder Difflin?</p>+ <p class="a">Node.js 18+ with npm, a C/C++ toolchain for node-pty's native addon (Xcode Command Line Tools on macOS), and at least one supported terminal-agent CLI on your PATH — Claude Code, Antigravity, OpenAI Codex, OpenCode, Crush, pi.dev, or GitHub Copilot CLI. If a chosen engine's binary is missing, the harness runs its installer in the terminal and restarts into it automatically.</p>+ </div>++ <div class="qa">+ <p class="q">Who is Michael and how do I give him work?</p>+ <p class="a">Michael is the GOD orchestrator — the one agent you talk to. You type a brief into his terminal (or use the Talk voice channel with your own OpenAI Realtime key) and he adjudicates it: creating tasks, assigning them to workers, routing messages between inboxes, and escalating only critical items back to you. He seats himself in Michael's office automatically on first launch.</p>+ </div>++ <div class="qa">+ <p class="q">Do I have to approve everything the agents do?</p>+ <p class="a">No. The GOD orchestrator resolves routine requests itself so the system stays autonomous. Only critical items — spend, destructive operations, scope changes — land in the human-in-the-loop approvals queue for you to act on. A circuit breaker and per-agent token budgets guard the rest.</p>+ </div>++ <div class="qa">+ <p class="q">How do I review what an agent actually changed?</p>+ <p class="a">Open the built-in Monaco IDE from the title-bar IDE button. Its git CHANGES rail lists every modified file, and clicking one opens a read-only side-by-side diff against HEAD — the VS Code editor engine, fully self-hosted, with all filesystem and git access brokered through the main process. There's also a per-agent git tab with status, log, and commit graph.</p>+ </div>++ <div class="qa">+ <p class="q">Can Munder Difflin keep working after I walk away?</p>+ <p class="a">Yes — that's the point. The Schedules tab in the Command Center holds recurring missions with a label, interval, target agent, and body, plus a heartbeat that re-engages the floor when it goes quiet. It's local-first, so the office runs 24/7 on hardware you already own.</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/onboarding/">Onboarding</a><a class="tag" href="/blog/tags/getting-started/">Getting Started</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/local-first/">Local-First</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="#minute-0-install">Minute 0 — Install</a></li><li class="lvl-2"><a href="#minute-5-the-onboarding-wizard">Minute 5 — The onboarding wizard</a></li><li class="lvl-2"><a href="#minute-10-your-first-brief-to-michael">Minute 10 — Your first brief to Michael</a></li><li class="lvl-2"><a href="#minute-20-watch-the-floor-then-open-a-desk">Minute 20 — Watch the floor, then open a desk</a></li><li class="lvl-2"><a href="#minute-40-your-first-approval-and-the-diff">Minute 40 — Your first approval, and the diff</a></li><li class="lvl-2"><a href="#minute-60-leave-it-running">Minute 60 — Leave it running</a></li><li class="lvl-2"><a href="#the-hour-in-one-line">The hour, in one line</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/launching-munder-difflin-v0-3-2/"><span class="k">← Older</span><span class="t">Launching Munder Difflin v0.3.2: Talk to Michael, a Realtime Voice Orchestrator</span></a>+ <a class="pn next" href="/blog/what-is-harness-engineering/"><span class="k">Newer →</span><span class="t">What Is Harness Engineering?</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/command-center-guide/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/command-center-guide/">The Command Center: Kanban, Fleet, and Budgets in One Place</a></h3>+ <p class="dek">A guide to Munder Difflin's Command Center — the task kanban, live fleet monitoring, per-agent budgets and cost telemetry — and when to watch the board instead of the floor.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/command-center-guide/" aria-label="Read: The Command Center: Kanban, Fleet, and Budgets in One Place">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/how-to-add-a-github-copilot-cli-agent/">How to Add a GitHub Copilot CLI Agent to Your Floor</a></h3>+ <p class="dek">A step-by-step v0.3.3 walkthrough: install GitHub Copilot CLI (or let the harness install it for you), hire a Copilot worker, pick a model, and know exactly what print mode can and can't do.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-add-a-github-copilot-cli-agent/" aria-label="Read: How to Add a GitHub Copilot CLI Agent to Your Floor">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/how-to-hire-from-the-agent-gallery/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-07-03">Jul 3, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/how-to-hire-from-the-agent-gallery/">How to Hire From the Agent Gallery</a></h3>+ <p class="dek">A practical guide to Munder Difflin's Agent Gallery: browse six off-the-shelf hires, import one from a link or file, review the pre-filled manifest, customize identity, workspace, engine, and briefing — then spawn it yourself.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/how-to-hire-from-the-agent-gallery/" aria-label="Read: How to Hire From the Agent Gallery">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">+ <img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />+ </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 & 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/sitemap.xml b/docs/sitemap.xmlindex 29db4e51..ac7d3a24 100644--- a/docs/sitemap.xml+++ b/docs/sitemap.xml@@ -10,19 +10,115 @@<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"><url><loc>https://munderdiffl.in/</loc>- <lastmod>2026-07-02</lastmod>+ <lastmod>2026-07-03</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/command-center-guide/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/crewai-autogen-vs-a-local-agent-harness/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/github-copilot-cli-vs-claude-code-for-hive-work/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/how-to-add-a-github-copilot-cli-agent/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/how-to-hire-from-the-agent-gallery/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/how-to-talk-to-your-orchestrator/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/how-to-use-the-built-in-monaco-ide/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/launching-munder-difflin-v0-3-3/</loc><lastmod>2026-07-03</lastmod><changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/loop-engineering-for-ai-agents/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/orca-vs-munder-difflin/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/review-agent-work-where-it-happens/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/run-a-mixed-engine-office/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/tmux-and-scripts-vs-an-agent-harness/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/voice-as-a-control-plane-for-agent-fleets/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/what-is-an-agent-development-environment/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/what-is-harness-engineering/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/your-first-hour-with-munder-difflin/</loc>+ <lastmod>2026-07-03</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/launching-munder-difflin-v0-3-2/</loc><lastmod>2026-06-27</lastmod>@@ -621,54 +717,59 @@<url><loc>https://munderdiffl.in/blog/topics/use-cases/</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/guides/</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/concepts/</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/comparisons/</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/open-source/</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/story/</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/tools/</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/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/human-in-the-loop/</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/cost/</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/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/security/</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/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/autonomous/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/git/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><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/reliability/</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><url><loc>https://munderdiffl.in/blog/tags/workflow/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>- <url><loc>https://munderdiffl.in/blog/tags/human-in-the-loop/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/terminals/</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/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/engines/</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><url><loc>https://munderdiffl.in/blog/tags/faq/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>- <url><loc>https://munderdiffl.in/blog/tags/git/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/concurrency/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/pixijs/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/visualization/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/xtermjs/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><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/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/tutorial/</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/cli-agents/</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/agent-design/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/voice/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/ide/</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><url><loc>https://munderdiffl.in/blog/tags/markdown/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/coordination/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>@@ -699,20 +800,34 @@<url><loc>https://munderdiffl.in/blog/tags/ai-coding-agents/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><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/video/</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/command-injection/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/ssrf/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>- <url><loc>https://munderdiffl.in/blog/tags/agent-design/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/mac-mini/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/ollama/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/lm-studio/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/byok/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>- <url><loc>https://munderdiffl.in/blog/tags/voice/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/realtime/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>- <url><loc>https://munderdiffl.in/blog/tags/ide/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/command-center/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/kanban/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/crewai/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/autogen/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/langgraph/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/copilot-cli/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/github-copilot/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/talk-mode/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/copilot/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/autonomy/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/orca/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/monaco-ide/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/tmux/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/git-worktrees/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/ade/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/tooling-landscape/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/harness-engineering/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/onboarding/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url></urlset>