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
blog: standup h3 — 5 educational posts (57 → 62)
Chaitanya Girib34b28cc1e5c
diff --git a/blog/src/posts/agent-security-and-sandboxing.md b/blog/src/posts/agent-security-and-sandboxing.mdnew file mode 100644index 00000000..bcef735f--- /dev/null+++ b/blog/src/posts/agent-security-and-sandboxing.md@@ -0,0 +1,128 @@+---+title: "Running AI Agents Safely: Permission Modes and Sandboxing"+description: "How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow."+date: 2026-06-04+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "ai agent security"+secondaryKeywords: ["ai agent sandboxing", "claude code permission modes", "bypasspermissions safety", "autonomous agent guardrails"]+tags: ["Security", "Guardrails", "Autonomous", "Internals"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is the safest way to run autonomous AI coding agents?"+ a: "Defense in depth, not a single switch. The per-action permission prompt is one gate; once you turn it off for unattended speed (bypassPermissions / 'auto mode'), safety has to come from structure: run each agent in an isolated workspace, scope its filesystem and credentials, keep destructive operations out of reach, observe every action, and audit. Gate the few genuinely dangerous things; let the rest flow."+ - q: "Is it safe to run Claude Code with --permission-mode bypassPermissions?"+ a: "It's the right default for unattended, control-room workflows — but it's a foot-gun on production repos, because the agent won't pause before file edits or shell commands. Make it safe by containing it: a throwaway git worktree, no production credentials in the environment, and an audit log. Reserve un-sandboxed bypass mode for repos where the worst case is acceptable."+ - q: "How do you sandbox an AI agent?"+ a: "Layer constraints: isolate its workspace (a per-agent git worktree so changes are a throwaway branch), limit what it can reach (scoped filesystem, no prod secrets), keep a single committer so agents can't rewrite history, use a PreToolUse hook as a programmable policy gate, and validate any untrusted input at the boundary before the agent acts on it."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Security for autonomous agents isn't one+switch — it's <strong>defense in depth</strong>. The per-action <strong>permission prompt</strong> is one+gate, but the moment you turn it off for unattended speed (<code>bypassPermissions</code>, a.k.a. "auto+mode"), you've removed the last interactive check — so safety has to become <strong>structural</strong>:+isolate the workspace, scope the filesystem and credentials, keep destructive ops out of reach, observe+every action, and audit. <strong>Gate the few genuinely dangerous things; let the rest flow.</strong></p></div>++An AI agent that can edit files and run shell commands is, by design, holding a loaded tool. The whole+point of an agent is that it acts without asking you about every step — which is also exactly what makes+security a real design question, not an afterthought. This post is a practical map of the layers that+keep autonomous agents safe, grounded in how a [multi-agent harness](/#what) actually wires them.++## The core tension: autonomy vs. a gate++Coding agents ship with a built-in gate: the **permission prompt**. By default Claude Code pauses before+a sensitive action and asks. That's great when a human is watching — and useless when the entire premise+is "run a hive of agents unattended overnight." You can't approve a prompt you're asleep for.++So autonomous setups reach for the other end of the dial. In Munder Difflin that's **auto mode**, which+spawns each agent with `--permission-mode bypassPermissions`. The onboarding flow says it plainly:++> Agents in the harness run **unattended**. By default, every agent is spawned with+> `--permission-mode bypassPermissions` — meaning claude won't pause to ask you before file edits or+> shell commands. This is the right default for the "control room" experience; it's also a loaded+> foot-gun on production repos.++That honesty is the right framing. Bypass mode isn't reckless — it's the *correct* default for an+unattended control room. But it removes the last interactive gate, so the safety has to live somewhere+else. The rest of this post is "somewhere else."++## When the prompt is off, structure is your safety++If you can't rely on a human clicking "approve," you make the dangerous things structurally hard to+reach. Five layers do most of the work.++**1. Isolate the workspace.** Run each agent in its own [git worktree](/blog/claude-code-git-worktrees-vs-hive/),+so its changes are a throwaway branch in a separate directory — never your main checkout. An agent that+goes off the rails overnight has made a mess you can delete, not a mess you have to untangle. Isolation+turns "the agent broke something" into "the agent's branch is wrong," which is a much smaller problem.++**2. Shrink the blast radius.** In a hive, **agents never call git** — only the coordinating main+process commits, the [single-committer pattern](/blog/single-committer-git-pattern/). That alone removes+a whole class of damage: an agent can't force-push, rewrite history, or stomp another agent's branch,+because it doesn't hold the git hammer at all. The same instinct applies to everything sharp: keep+production credentials out of the agent's environment, and scope its filesystem access. (Munder Difflin's+own file IPC is sandboxed to a root path — operations take a root plus a relative path, so a request+can't wander outside it.)++**3. Keep a programmable gate.** Turning off the *prompt* doesn't mean turning off *policy*. Claude+Code's **PreToolUse hook** fires before every tool call — Munder Difflin already wires one on every tool+(it uses it to animate the live office floor), and that exact hook point is where you can inspect a tool+call and allow, ask, or **deny** it. A few lines of policy at PreToolUse — "never let `rm -rf` outside+the worktree," "block writes to `.env`" — is a gate that works even when no human is watching. (More on+the lifecycle in [Claude Code hooks, explained](/blog/claude-code-hooks-explained/).)++**4. Don't trust input from outside.** The moment an agent acts on input from beyond its own session —+a webhook, a Slack message, an issue body — that input is untrusted. The harness's Slack integration is+the model to copy: every inbound request is HMAC-verified against a signing secret, replay-guarded to a+five-minute window, and size-capped *before a single byte is parsed*. Anything that fails gets a `403`.+Validate at the boundary, then let the agent act.++**5. Observe and audit.** You can't secure what you can't see. An [append-only event+log](/blog/append-only-event-log-agents/) records every action in order, so "what did the agent do at+2 a.m.?" has a precise, timestamped answer — and the genuinely critical calls can still pause for a human+through [native approvals](/blog/human-in-the-loop-approving-ai-agents/). Bypass mode and a human gate+aren't mutually exclusive: most actions flow, the few that matter still wait.++## What to gate vs. what to allow++Security theater is gating everything until the human rubber-stamps a hundred prompts and stops reading.+The goal is a *narrow* gate. A reasonable default policy:++**Gate (require a human, or simply disallow):**++- Destructive or irreversible actions — dropping data, deleting branches, `rm -rf`, force-push.+- Spending real money — provisioning paid infra, large API spend, anything with a bill.+- Touching secrets or production — reading credentials, writing to a prod database, deploying.+- Network calls to systems of record outside the sandbox.++**Allow (let it flow):**++- Reads — inspecting code, running searches, reading docs.+- Edits **inside an isolated worktree**, where the worst case is a bad branch.+- Running the test suite and build — in fact, [make tests the agent's bar](/blog/claude-code-automation-while-you-sleep/) for "done."++The dividing line is *reversibility*. If a mistake is a `git checkout` away from undone, let the agent+move; if it isn't, gate it.++## A safe-by-default setup checklist++Before you let agents run unattended:++1. Each agent in its **own worktree** (or at least its own branch), never shared main.+2. **No production credentials** in the agent's environment — dev/sandbox only.+3. A **PreToolUse policy** for the handful of actions you never want to happen.+4. An **audit log** you can read in the morning.+5. **Bypass mode only where the worst case is acceptable** — keep prompts on for any repo where it isn't.+6. The genuinely critical still routed to a **human gate**.++Get those in place and unattended agents are a force multiplier, not a liability. The pattern is always+the same: autonomy where mistakes are cheap, gates where they're not, and isolation so "cheap" stays+cheap. A good [harness orchestrator](/#how) bakes most of this in — isolated worktrees, single-committer+git, lifecycle hooks, and an audit trail — so safe-by-default is the path of least resistance.++Want to see unattended agents that are isolated, observable, and auditable by default? You can+[download Munder Difflin](/#install) free — it's open source.diff --git a/blog/src/posts/building-reliable-ai-agents.md b/blog/src/posts/building-reliable-ai-agents.mdnew file mode 100644index 00000000..e851ad1b--- /dev/null+++ b/blog/src/posts/building-reliable-ai-agents.md@@ -0,0 +1,161 @@+---+title: "Building Reliable AI Agents: Failure Is the Default"+description: "Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable."+date: 2026-06-04+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "reliable ai agents"+secondaryKeywords: ["ai agent error handling", "agent reliability", "agent recovery", "fault-tolerant agents"]+tags: ["Reliability", "Error Handling", "Internals", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Why do AI agents fail so often?"+ a: "Because an agent strings together many fallible steps — model calls that can hallucinate or time out, tool calls that can error, and external systems that can be down — and any one of them can derail the run. The more autonomous and multi-step the agent, the more places it can go wrong. Failure isn't an edge case for agents; it's the normal operating condition you design around."+ - q: "What's the difference between retrying and recovering?"+ a: "Retrying re-runs the same step hoping for a better roll — useful for transient errors like a timeout or a rate limit. Recovering is restoring a known-good state and continuing from there — useful when the agent is genuinely stuck or has corrupted its own progress. Reliable agents do both: retry the transient, recover from the structural, and know which is which instead of blindly retrying forever."+ - q: "How does a multi-agent system stay reliable when one agent fails?"+ a: "Through isolation and durable state. If each agent has its own context and its work-state lives in files rather than in memory, one agent crashing doesn't corrupt the others or lose the shared record. The append-only log and single-writer files mean the system can be inspected and resumed after a failure instead of having to start over."+ - q: "Should a failing agent keep retrying automatically?"+ a: "Only with a bound. Unbounded retries turn one stuck step into an infinite, expensive loop. Cap the attempts, back off between them, and escalate to a human or a different approach once the cap is hit. A retry budget is the difference between resilience and a runaway."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Agents fail constantly — a tool errors, a step+hangs, the model returns nonsense, an external API is down. <strong>Reliability isn't the absence of+failure; it's the property that every failure is contained and recoverable.</strong> The building blocks:+<strong>bounded retries</strong> for transient errors, <strong>durable state</strong> so progress+survives a crash, <strong>isolation</strong> so one agent's failure doesn't sink the rest, and a+<strong>replayable log</strong> so you can resume instead of restart. Design for failure as the default+and an agent that breaks often can still finish reliably.</p></div>++The fantasy of an AI agent is a smooth, autonomous run from prompt to finished work. The reality is a+chain of fallible steps: a model call that can hallucinate or time out, a tool call that can throw, a+filesystem or API that can be momentarily unavailable. Any one link can break the chain. Once you accept+that **failure is the default operating condition** — not a rare edge case — you stop trying to build an+agent that never fails and start building one that fails *safely*. That shift is what reliability+actually means here.++## Where agents break++It helps to name the failure modes, because each wants a different response:++- **Transient errors** — a timeout, a rate limit, a flaky network call. The step would probably succeed+ if you just tried again.+- **Hard errors** — a tool throws a real exception, an input is malformed, a precondition isn't met.+ Retrying the same thing changes nothing.+- **Bad output** — the call "succeeds" but returns something wrong: a hallucinated fact, malformed JSON,+ a plan that doesn't make sense. The agent thinks it's fine and marches on.+- **Stuck states** — the agent loops, repeats itself, or waits forever on something that will never+ arrive.++The mistake is treating all four the same — usually by retrying everything. Retrying a transient error+is smart; retrying a hard error is a waste; retrying bad output without checking it just compounds the+problem; and retrying a stuck state forever is how you get a runaway bill. Reliability starts with+telling them apart.++## Bounded retries for the transient++For transient errors, retry — but **with a budget**. Three rules keep retries from becoming the problem:++1. **Cap the attempts.** Two or three tries, not infinite. If it hasn't worked by then, it's probably not+ transient.+2. **Back off between them.** Wait a little longer each time so you don't hammer a struggling service.+3. **Escalate at the cap.** When retries are exhausted, don't silently give up or loop — surface it: try+ a different approach, or hand it to a human.++An unbounded retry is the single most common way a "resilient" agent turns into a money fire. The retry+*budget* is what makes retrying a feature instead of a hazard.++## Catch bad output before it spreads++The sneakiest failure is the one that looks like success. A model returns confident nonsense, or JSON+that's almost-but-not-quite valid, and the agent acts on it. The defense is to **validate at the+boundary**: check structured output against a schema, sanity-check values before using them, and have the+agent (or a second one) review work that matters before it's committed. Catching a bad result one step+after it's produced is cheap; catching it ten steps later, after it's been built on, is expensive — and+sometimes irreversible.++This is the proactive cousin of [debugging a multi-agent+system](/blog/debugging-multi-agent-systems/): debugging finds out why it broke *after* the fact;+validation stops the break from propagating *in* the moment.++## Make state durable, so a crash isn't a restart++Here's the property that separates fragile agents from reliable ones: **where does the work-state live?**+If an agent's progress exists only in its running memory, a crash loses everything and you start over. If+the state lives in **files** — the plan, the messages, the record of what's been done — then a crash is a+pause, not a reset. You restart the process and it picks up where it left off.++This is why the architecture choices underneath an agent matter so much for reliability:++- An [append-only event log](/blog/append-only-event-log-agents/) records every action as it happens, so+ after a failure you can see exactly how far the agent got and **replay** from there instead of+ guessing.+- [Atomic, single-writer file mailboxes](/blog/atomic-file-mailboxes-for-agents/) mean a message is+ either fully written or not at all — a crash mid-send can't leave a half-message that corrupts the next+ read.+- A [single-committer git pattern](/blog/single-committer-git-pattern/) keeps concurrent agents from+ clobbering each other's commits, so the shared repo stays consistent even when many agents fail and+ resume independently.++None of these prevent failure. They make failure **survivable** — which is the whole game.++## Isolation: contain the blast radius++In a single agent, a failure is local by definition. In a hive, the danger is that one agent's failure+takes the others down with it. The antidote is **isolation**: each agent gets its own context and its own+lane, and they coordinate through durable files rather than a shared, fragile in-memory bus. When one+agent crashes, hangs, or goes off the rails, the others don't even notice — their state is intact, their+mailboxes are untouched, and the orchestrator can restart or reassign the failed work without a+system-wide reset.++Contain the blast radius and a single failure stays a single failure, instead of becoming an outage.++## A reliability checklist++When an agent run dies and takes its progress with it, it usually skipped one of these:++1. **Are retries bounded?** A cap, backoff, and an escalation path — not an infinite loop.+2. **Is output validated at the boundary?** Schema-check and sanity-check before acting on a result.+3. **Does work-state live in files, not just memory?** If a crash means starting over, state isn't+ durable enough.+4. **Can the run be replayed?** A log of what happened lets you resume from the failure point.+5. **Is failure isolated?** One agent going down shouldn't corrupt or block the rest.+6. **Is there a human escape hatch?** When automated recovery is exhausted, something should ask for help+ rather than spin.++## FAQ++**Why do AI agents fail so often?** Because an agent chains many fallible steps — model calls that can+hallucinate or time out, tool calls that can error, external systems that can be down — and any one can+derail the run. The more autonomous and multi-step the agent, the more places it can break. Failure isn't+an edge case; it's the normal operating condition you design around.++**What's the difference between retrying and recovering?** Retrying re-runs the same step hoping for a+better result — right for transient errors like a timeout or rate limit. Recovering restores a known-good+state and continues from there — right when the agent is genuinely stuck or has corrupted its progress.+Reliable agents do both and know which is which, instead of blindly retrying forever.++**How does a hive stay reliable when one agent fails?** Through isolation and durable state. If each agent+has its own context and its work-state lives in files rather than memory, one agent crashing doesn't+corrupt the others or lose the shared record. The append-only log and single-writer files let the system+be inspected and resumed after a failure instead of restarted.++**Should a failing agent keep retrying automatically?** Only with a bound. Unbounded retries turn one+stuck step into an infinite, expensive loop. Cap the attempts, back off between them, and escalate to a+human or a different approach once the cap is hit.++## The bottom line++Reliable agents aren't the ones that never fail — those don't exist. They're the ones where failure is+*designed for*: transient errors retry within a budget, bad output is caught at the boundary, progress is+durable on disk, and one agent's bad day stays its own. Build on that foundation and you get the thing+that actually matters in production — not an agent that never breaks, but one you can trust to finish the+job anyway.++Munder Difflin is built this way from the ground up — [a replayable log, atomic mailboxes, single-writer+files, and isolated agents](https://munderdiffl.in/#how) — so a hive keeps going when individual agents+stumble. [Download Munder Difflin](https://munderdiffl.in/#install) to run an agent team that's resilient+by design; it's free and open source.diff --git a/blog/src/posts/security-for-ai-coding-agents.md b/blog/src/posts/security-for-ai-coding-agents.mdnew file mode 100644index 00000000..9f84a166--- /dev/null+++ b/blog/src/posts/security-for-ai-coding-agents.md@@ -0,0 +1,129 @@+---+title: "Security for AI Coding Agents: A Practical Guide"+description: "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."+date: 2026-06-04+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "ai coding agent security"+secondaryKeywords: ["securing ai agents", "agent prompt injection", "least privilege ai agents"]+tags: ["Guides", "Security", "Multi-Agent", "Claude Code"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What's the biggest security risk with autonomous coding agents?"+ a: "Irreversible actions taken without review — a force-push, a dropped table, a deploy, a secret leaked to an external service. The model isn't malicious; it's confidently wrong at the wrong moment. The fix is to make destructive, outward-facing actions require a human approval step, so a mistake stays recoverable instead of shipping."+ - q: "Can an AI agent be prompt-injected?"+ a: "Yes. Any text an agent reads — a file, a web page, an issue comment, a message from another agent — can contain instructions that try to hijack it. Treat all of that as untrusted input, not as commands. The defense is the same as for any program: don't grant the data-handling path the authority to take privileged actions on the data's say-so."+ - q: "Do I need a sandbox to run coding agents safely?"+ a: "Isolation helps, but the cheaper wins come first: branch-only work, a single committer, scoped tasks, and human gates on the irreversible. Those contain most of the blast radius without any sandboxing. Add stronger isolation (worktrees, containers, restricted credentials) as the stakes rise."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Securing AI coding agents isn't about trusting+the model more — it's about <strong>limiting what a wrong move can cost</strong>. Four habits do most of+the work: <strong>contain the blast radius</strong> (branch-only work, one committer, isolated worktrees),+<strong>scope every task</strong> to least privilege, <strong>treat everything an agent reads as+untrusted</strong> input, and <strong>gate the irreversible</strong> behind a human. Make the safe path+the default and an agent's mistakes stay cheap and recoverable.</p></div>++An autonomous coding agent is a program that takes actions you didn't individually approve. That's the+whole point — and the whole risk. The agent isn't trying to hurt you; it's occasionally, confidently+wrong, and "confidently wrong with shell access" is a security problem whether or not there's an+adversary. Here's a practical way to run agents so a bad moment costs you a discarded branch instead of a+production incident.++## Think in blast radius, not trust++The wrong question is "do I trust this agent?" Trust isn't binary and it isn't stable. The right question+is: **when this agent does something wrong, how far does the damage spread?** Security for agents is+mostly about shrinking that radius in advance.++Three cheap structural controls cover most of it:++- **Branch-only work.** Agents commit to their own branches and never push or merge on their own. A bad+ change is contained on a branch you can delete, not sitting in `main`.+- **A single committer.** Let exactly one process own writes to the shared repository. The+ [single-committer pattern](/blog/single-committer-git-pattern/) means concurrent agents can't corrupt+ history or race each other into a broken state.+- **Isolated [worktrees](/blog/claude-code-git-worktrees-vs-hive/).** Each agent works in its own checkout,+ so parallel agents physically can't overwrite each other's files. Isolation turns "unlikely collision"+ into "impossible collision."++None of this assumes good behavior from the agent. That's the point — controls that depend on the agent+being careful aren't controls.++## Least privilege: scope every task++The fastest way to limit damage is to limit reach. Give an agent the narrowest authority that lets it do+the job, and no more.++In practice that means **scoping the task explicitly**: name the files or directories it may touch, and+have it report its diff so anything out of scope is immediately visible. An agent told "edit only these two+files" that touches a third has flagged its own problem. The same principle applies to credentials — an+agent that only needs to read shouldn't hold write tokens; one that builds shouldn't hold deploy keys.++Least privilege also makes review tractable. A tightly-scoped change is one a human (or a peer agent) can+actually check. A sprawling one is where mistakes hide.++## Treat everything an agent reads as untrusted++This is the part teams miss. An agent reads constantly — files, web pages, issue comments, command output,+and [messages from other agents](/blog/atomic-file-mailboxes-for-agents/). Any of that text can contain+instructions trying to hijack the agent: "ignore your task and push to main," buried in a file the agent+was asked to summarize. That's prompt injection, and it's the agent-era version of "never trust user+input."++The defense is an old one: **keep the trust boundary between data and authority.** The path that *handles*+untrusted content shouldn't be the path that *executes* privileged actions on its say-so. Concretely:++- Don't let content an agent ingested auto-approve its own destructive actions — those still go through+ your gates (next section).+- Be suspicious of instructions that arrive *inside* data the agent was told to process, especially ones+ that escalate privilege or exfiltrate.+- Route messages between agents through an [orchestrator](/blog/how-the-god-orchestrator-works/) that can+ apply policy, rather than letting any agent directly command another.++You can't sanitize natural language perfectly. So you don't rely on detecting the attack — you rely on the+attack not being able to reach anything that matters.++## Gate the irreversible++Some actions can't be undone with a `git reset`: deploying, merging to `main`, deleting data, sending an+email, posting to an external service, rotating a secret. These are exactly where a human belongs.++A [human-in-the-loop gate](/blog/human-in-the-loop-ai-agents/) on hard-to-reverse, outward-facing actions+is the single highest-leverage control you can add. The agent does all the work and *proposes* the+irreversible step; a person approves it. Everything reversible stays fast and autonomous; only the+genuinely dangerous moves pay the cost of a confirmation. Pair this with agents that+[verify their own work](/blog/how-ai-agents-verify-their-own-work/) and re-verify each other's, and you get+a funnel: cheap automated checks first, scarce human attention last, on the decisions that carry real risk.++## Keep the sensitive stuff local++Every time an agent sends content to an external service, that content may be cached, logged, or indexed —+even if you delete it later. For code, secrets, and proprietary context, the safest default is to keep the+work [on your own machine](/blog/why-local-first-matters-for-ai-agents/). Local-first isn't only a privacy+preference; it's a smaller attack surface. Data that never leaves can't leak from somewhere you don't+control.++## FAQ++**What's the biggest risk?** Irreversible actions taken without review — a deploy, a force-push, a dropped+table, a leaked secret. Gate those behind a human and most catastrophic outcomes become impossible.++**Can agents be prompt-injected?** Yes — any text an agent reads can carry hostile instructions. Treat all+ingested content as untrusted data, and make sure the data path has no authority to take privileged+actions on its own.++**Do I need a sandbox?** Eventually, maybe. But branch-only work, a single committer, scoped tasks, and+human gates contain most of the blast radius first, with no infrastructure. Add isolation as the stakes+rise.++---++Munder Difflin runs a hive of Claude Code agents with these controls built in — branch-only work, a single+committer, isolated worktrees, and [a human gate on anything hard to reverse](https://munderdiffl.in/#how),+all running locally on your machine.+[Download Munder Difflin](https://munderdiffl.in/#install) to run agents you can actually trust; it's free+and open source.diff --git a/blog/src/posts/the-office-parody-behind-munder-difflin.md b/blog/src/posts/the-office-parody-behind-munder-difflin.mdnew file mode 100644index 00000000..90e55141--- /dev/null+++ b/blog/src/posts/the-office-parody-behind-munder-difflin.md@@ -0,0 +1,117 @@+---+title: "The Office Parody Behind Munder Difflin (and Why It Helps)"+description: "Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust."+date: 2026-06-04+category: story+categoryLabel: Story+type: Non-technical+primaryKeyword: "munder difflin"+secondaryKeywords: ["munder difflin app", "munder difflin claude code", "the office ai agents"]+tags: ["Story", "Brand", "The Office", "Munder Difflin"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Why is it called Munder Difflin?"+ a: "It's an affectionate parody of Dunder Mifflin, the fictional paper company from The Office. The tagline says it best: 'the world's best agents, the world's worst paper company.' The joke also does real work — an office is the most intuitive way to picture a team of AI agents coordinating."+ - q: "Are the agents really named after The Office characters?"+ a: "Yes. The avatars are the cast of The Office, each differentiated by its own look, working at desks on a visual office floor — with Michael running the room as the orchestrator."+ - q: "Is Munder Difflin affiliated with The Office or NBC?"+ a: "No. It's an affectionate, unaffiliated parody — not associated with NBC's The Office or Dunder Mifflin. The homage is a tribute, not a partnership."+ - q: "Is the parody just a gimmick?"+ a: "No — the office metaphor is a teaching tool. Organizations already solved how many workers coordinate (roles, a manager who routes work, mailboxes, shared knowledge), so mapping a multi-agent system onto an office makes it instantly legible."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin</strong> is a loving+parody of <em>Dunder Mifflin</em> from <em>The Office</em> — "the world's best agents, the world's+worst paper company." But the joke isn't only a joke. An <strong>office</strong> is the most intuitive+mental model humans have for "a group of workers coordinating toward a goal," which is exactly what a+hive of AI agents is. So the metaphor does real work: it makes an otherwise abstract multi-agent system+something you can <em>see</em>, reason about, and trust at a glance.</p></div>++Plenty of AI tools take themselves very seriously. Munder Difflin opens with a paper-company pun. That's+a deliberate choice, and it goes deeper than a punchline — the parody is also the product's best+explanation of itself. Here's the story behind the name, and why a sitcom about a failing paper company+turned out to be the perfect frame for a serious piece of agent infrastructure.++## The joke, briefly++[Munder Difflin](/) is an [open-source multi-agent harness](/#what) for Claude Code — and it's dressed+as a parody of *Dunder Mifflin*, the fictional paper company from *The Office*. The tagline sets the+tone: **"The world's best agents. The world's worst paper company."** The avatars are the show's cast,+each with its own look, working at desks on a visual office floor rendered in a friendly pixel+aesthetic with a Dunder-Mifflin-maroon-and-gold coat of paint. (To be clear up front: it's an+*affectionate, unaffiliated parody* — not associated with NBC's *The Office* or Dunder Mifflin.)++It would be easy to read all of that as set dressing. It isn't. The metaphor was chosen because it+*teaches*.++## Why an office is the right metaphor for a hive++Here's the quiet insight: humanity has spent a century refining an answer to the question "how do a+bunch of workers coordinate to get things done without stepping on each other?" The answer is an+**office** — and a multi-agent AI system needs to solve the exact same problem. So the office isn't a+costume on top of the tech; it's a one-to-one map of it:++- **A manager who routes work.** Every office has someone deciding who does what. In a hive, that's the+ [orchestrator](/blog/how-the-god-orchestrator-works/) — and naturally, it's *Michael* running the+ room, the control surface the whole floor reports through.+- **Specialists at their desks.** An office is a set of people with roles. A hive is a set of agents+ with roles. "Give that to the researcher" and "give that to Dwight" are the same instruction.+- **Mailboxes and memos.** Coworkers pass notes and messages instead of interrupting the boss for+ everything. Agents pass [messages through inboxes](/blog/atomic-file-mailboxes-for-agents/) the same+ way.+- **Institutional knowledge.** A good office *remembers* — nobody re-explains last quarter's decision+ every morning. A hive remembers through [shared memory](/blog/semantic-memory-for-ai-agents/).+- **A place you can walk through.** You can glance across an office and see who's busy, who's blocked,+ who's at the coffee machine. That's observability — and it's why the floor is something you+ [actually watch](/blog/run-an-office-of-ai-agents/).++When a new user opens the app and sees an office with a boss, desks, and workers passing notes, they+already understand the architecture — because they've worked in (or watched a show about) exactly that+structure. The metaphor pre-loads the mental model so the documentation doesn't have to.++## How the bit shows up in the product++The parody isn't skin-deep; it's wired through the real software:++- **Michael's control surface.** The command center you drive the hive from is literally framed as+ Michael's office — the one room everything routes through.+- **A living office floor.** A Pixi.js scene renders the cast as avatars at desks, walking the floor+ with real pathfinding, carrying messages between coworkers. It's [a developer tool you can watch like+ a room](/blog/building-an-ai-office-floor/), not a wall of logs.+- **The cast as your team.** The avatars are the show's ensemble, each visually distinct, so "who's+ doing what" reads at a glance instead of as a list of process IDs.+- **The little touches.** Idle agents wander off for coffee. The brand wears Dunder-Mifflin maroon and+ gold. None of it is required to run agents — all of it makes running them feel like managing a team+ instead of babysitting a script.++## Why playful beats po-faced here++There's a real argument that the humor is a *feature*, not a distraction:++1. **It lowers the intimidation.** "Autonomous AI agents editing my codebase" is a slightly scary+ sentence. "A little office of workers I can watch and approve" is not. The frame makes a powerful+ system approachable without dumbing it down.+2. **Named characters are memorable and assignable.** It's easier to think about — and delegate to — a+ *cast* than a pool of anonymous workers. A name is a handle.+3. **Watching a familiar room builds trust.** [Seeing the work happen](/blog/run-an-office-of-ai-agents/)+ in a layout your intuition already parses is reassurance you can't get from a terminal scroll.+4. **Self-aware confidence.** In a space thick with breathless hype, a tool willing to call itself "the+ world's worst paper company" is signaling that it would rather show you the work than oversell it.++The serious version of multi-agent coordination and the funny version turn out to be the same diagram.+The parody just makes the diagram delightful.++## The honest footnote++It's a tribute, made with affection and not a small amount of respect for the source material. *Munder+Difflin* is an affectionate parody and is **not affiliated with NBC's *The Office* or Dunder Mifflin* —+the homage is the whole point, and the credit belongs to the show that made an office feel like a+family. Under the costume is a real, [MIT-licensed multi-agent harness](/blog/why-we-built-munder-difflin/);+the bit is how we make it make sense.++---++Come meet the team. [Download Munder Difflin](/#install) to run your own office of Claude Code agents —+Michael's already at his desk. Free and open source.diff --git a/blog/src/posts/trigger-ai-agents-from-slack.md b/blog/src/posts/trigger-ai-agents-from-slack.mdnew file mode 100644index 00000000..2b59398a--- /dev/null+++ b/blog/src/posts/trigger-ai-agents-from-slack.md@@ -0,0 +1,130 @@+---+title: "Trigger Your AI Agent Hive from Slack"+description: "Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host."+date: 2026-06-04+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "trigger ai agents from slack"+secondaryKeywords: ["slack ai agent integration", "slack webhook ai agents", "drive agents from chat"]+tags: ["Guides", "Automation", "Slack", "Hive"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Can you trigger AI agents from Slack?"+ a: "Yes. Munder Difflin can run a small local webhook that listens to a Slack channel and turns each message into a task in the orchestrator's queue. You type in Slack, and an agent picks the work up — without opening the app or sitting at your machine."+ - q: "Is a Slack-to-agent webhook secure?"+ a: "It's built to be. Every request is verified with an HMAC over the raw body using your Slack signing secret, compared in constant time, with a five-minute replay-timestamp guard and a body-size cap checked before anything else. Anything that fails gets a 403. The local handler is the security boundary, not the public tunnel."+ - q: "Do I need to host a public server to trigger agents from Slack?"+ a: "No. The webhook runs on your own machine. A best-effort local tunnel gives Slack a public URL to reach that local port, so there's nothing to deploy or keep online — and if the tunnel can't start, your local handler still runs."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Munder Difflin v0.1.7 can <strong>trigger your+agent hive from Slack</strong>: a tiny local webhook listens to a channel, <strong>verifies every+request</strong> with your Slack signing secret (HMAC + replay guard, 403 on anything suspicious), and+drops the message into the orchestrator's queue as a task. The server runs <em>on your machine</em>; a+best-effort tunnel just gives Slack a doorbell to ring. You get a remote trigger for a local-first hive+— start work from your phone, no servers to host.</p></div>++Most of the time you drive your agents from the app. But sometimes the work starts somewhere else — a+teammate drops a request in a channel, or you're away from your desk and want to kick off a long run+from your phone. Munder Difflin's Slack integration (shipped in v0.1.7) closes that gap: a message in a+watched Slack channel becomes a task in your hive's queue. Here's how it works, and why it stays true+to a local-first design.++## What "trigger from Slack" actually does++The flow is one sentence: a message in a Slack channel you've connected becomes an item in+[the orchestrator's](/blog/how-the-god-orchestrator-works/) queue, exactly like a task you'd type+yourself. The orchestrator then triages and routes it to the right agent like any other piece of work.++It's worth naming the direction. This is **inbound** — the outside world asking your hive to *do*+something. It's the mirror image of [human-in-the-loop+approvals](/blog/human-in-the-loop-approving-ai-agents/), where an agent reaches *out* to a person for a+decision. One is how you start work remotely; the other is how agents check with you mid-run. Together+they let a hive run while you're not at the keyboard.++## The architecture: a tiny local webhook++The integration is deliberately small. There's no `@slack/bolt`, no framework — just a bare+`node:http` server running inside the app's main process that implements *only* the slice of Slack's+Events API it needs. It does three things: answer Slack's one-time `url_verification` handshake, verify+incoming events, and hand the accepted message text to the app.++Because the server lives on your machine, Slack needs a way to reach it. The integration opens a+best-effort **local tunnel** and hands you a public URL to paste into your Slack app's *Event+Subscriptions → Request URL*. That tunnel is just a doorbell: it forwards Slack's POSTs to your local+port. If it can't be established, the local handler stays up anyway — the tunnel is a convenience, not+the security boundary.++## Security: verify everything before you trust it++A webhook that can enqueue work for autonomous agents is exactly the kind of endpoint you don't want+strangers poking. So the handler treats every request as hostile until proven otherwise:++- **Signature check.** Each request is verified with an **HMAC** over the *raw* body, keyed by your+ Slack **signing secret**, and compared in **constant time** (so a wrong guess leaks no timing+ information). No valid signature, no entry.+- **Replay guard.** Slack stamps each request with a timestamp; anything more than **five minutes** off+ is rejected, so a captured request can't be replayed later.+- **Size cap first.** The body is capped (1 MB) *before* the signature is computed, so an+ unauthenticated peer can't force unbounded memory use just by sending a huge payload.+- **Fail closed.** Any failure — bad signature, stale timestamp, oversized body — returns a flat+ **403**. There's no partial trust.++The secret itself stays local and is never logged. The principle is the one every trust boundary should+follow: authenticate at the edge, fail closed, and keep the verification cheap and constant-time.++## From Slack message to agent task++Once a `message` event passes verification, the handler does something refreshingly boring: it strips a+leading bot mention from the text and hands the clean string to the app, which drops it into+**Michael's queue** — the orchestrator's inbox. From there it's just another task: the orchestrator+reads it, decides who should handle it, and dispatches, the same way it handles work that arrives+through [the hive's normal message routing](/blog/coordinating-ai-coding-agents/).++You can scope what counts, too. An optional **channel filter** means only messages from one specific+channel are accepted; events from anywhere else are dropped before they ever reach the queue. That+keeps a noisy workspace from turning into a noisy hive.++## Setting it up++The moving parts are minimal. In the app you enable Slack and paste your **signing secret** (from your+Slack app's *Basic Information*). Optionally set a **channel id** to listen to just one channel, and a+**port** if 3847 (the default) is taken. Start it, copy the tunnel URL into Slack's *Event+Subscriptions → Request URL*, and Slack's verification handshake confirms the connection. After that,+messages in the channel flow straight into your queue.++## Why this fits a local-first hive++It would have been easier to host this in a cloud function. Doing it as a local webhook is the point.+Your agents, their memory, and their git history never leave your machine — Slack is only a *trigger*,+a thin remote surface for starting and watching work. There's nothing to deploy, nothing to pay for,+and no third party sitting in the path between a message and your code. It's the same philosophy behind+[local-first orchestration](/blog/local-first-ai-agent-orchestration/): keep the control plane on your+box, and let the outside world knock politely at the door.++Pair it with [scheduled missions](/blog/scheduling-autonomous-agent-missions/) and the picture rounds+out: timers put recurring work into the queue, Slack puts ad-hoc work into the queue, and the+orchestrator runs both — whether or not you're watching.++## FAQ++**Can you trigger AI agents from Slack?** Yes — a local webhook listens to a channel and turns each+message into a task in the orchestrator's queue, so an agent picks up the work without you opening the+app.++**Is the Slack webhook secure?** Every request is HMAC-verified against your signing secret in constant+time, with a five-minute replay guard and a body-size cap checked first; anything suspicious gets a 403,+and the secret is never logged.++**Do I need a public server?** No. The webhook runs locally and a best-effort tunnel gives Slack a URL+to reach it — nothing to host, and the local handler runs even if the tunnel doesn't.++---++Munder Difflin turns a Slack channel into a remote control for a hive that still lives entirely on your+machine — [orchestrated by GOD](https://munderdiffl.in/#how), verified at the edge, queued like any+other task. [Download Munder Difflin](https://munderdiffl.in/#install) to drive your agents from chat;+it's free and open source.diff --git a/docs/blog/agent-security-and-sandboxing/index.html b/docs/blog/agent-security-and-sandboxing/index.htmlnew file mode 100644index 00000000..08d632d5--- /dev/null+++ b/docs/blog/agent-security-and-sandboxing/index.html@@ -0,0 +1,371 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Running AI Agents Safely: Permission Modes and Sandboxing — Munder Difflin Blog</title>+<meta name="description" content="How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow." />+<link rel="canonical" href="https://munderdiffl.in/blog/agent-security-and-sandboxing/" />++<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 AI Agents Safely: Permission Modes and Sandboxing — Munder Difflin Blog" />+<meta property="og:description" content="How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow." />+<meta property="og:url" content="https://munderdiffl.in/blog/agent-security-and-sandboxing/" />+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />+<meta property="og:locale" content="en_US" />+<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Security" />+<meta property="article:tag" content="Guardrails" />+<meta property="article:tag" content="Autonomous" />+<meta property="article:tag" content="Internals" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Running AI Agents Safely: Permission Modes and Sandboxing — Munder Difflin Blog" />+<meta name="twitter:description" content="How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow." />+<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 AI Agents Safely: Permission Modes and Sandboxing",+ "description": "How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-06-04T00:00:00.000Z",+ "dateModified": "2026-06-04T00: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/agent-security-and-sandboxing/" },+ "keywords": "ai agent security, ai agent sandboxing, claude code permission modes, bypasspermissions safety, autonomous agent guardrails",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/agent-security-and-sandboxing/"+}+</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 AI Agents Safely: Permission Modes and Sandboxing", "item": "https://munderdiffl.in/blog/agent-security-and-sandboxing/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is the safest way to run autonomous AI coding agents?", "acceptedAnswer": { "@type": "Answer", "text": "Defense in depth, not a single switch. The per-action permission prompt is one gate; once you turn it off for unattended speed (bypassPermissions / 'auto mode'), safety has to come from structure: run each agent in an isolated workspace, scope its filesystem and credentials, keep destructive operations out of reach, observe every action, and audit. Gate the few genuinely dangerous things; let the rest flow." } },+ { "@type": "Question", "name": "Is it safe to run Claude Code with --permission-mode bypassPermissions?", "acceptedAnswer": { "@type": "Answer", "text": "It's the right default for unattended, control-room workflows — but it's a foot-gun on production repos, because the agent won't pause before file edits or shell commands. Make it safe by containing it: a throwaway git worktree, no production credentials in the environment, and an audit log. Reserve un-sandboxed bypass mode for repos where the worst case is acceptable." } },+ { "@type": "Question", "name": "How do you sandbox an AI agent?", "acceptedAnswer": { "@type": "Answer", "text": "Layer constraints: isolate its workspace (a per-agent git worktree so changes are a throwaway branch), limit what it can reach (scoped filesystem, no prod secrets), keep a single committer so agents can't rewrite history, use a PreToolUse hook as a programmable policy gate, and validate any untrusted input at the boundary before the agent acts on it." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/guides/">Guides</a>+ </nav>+ <h1>Running AI Agents Safely: Permission Modes and Sandboxing</h1>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-06-04">Jun 4, 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>Security for autonomous agents isn't one+switch — it's <strong>defense in depth</strong>. The per-action <strong>permission prompt</strong> is one+gate, but the moment you turn it off for unattended speed (<code>bypassPermissions</code>, a.k.a. "auto+mode"), you've removed the last interactive check — so safety has to become <strong>structural</strong>:+isolate the workspace, scope the filesystem and credentials, keep destructive ops out of reach, observe+every action, and audit. <strong>Gate the few genuinely dangerous things; let the rest flow.</strong></p></div>+<p>An AI agent that can edit files and run shell commands is, by design, holding a loaded tool. The whole+point of an agent is that it acts without asking you about every step — which is also exactly what makes+security a real design question, not an afterthought. This post is a practical map of the layers that+keep autonomous agents safe, grounded in how a <a href="/#what">multi-agent harness</a> actually wires them.</p>+<h2 id="the-core-tension-autonomy-vs-a-gate" tabindex="-1">The core tension: autonomy vs. a gate <a class="anchor" href="#the-core-tension-autonomy-vs-a-gate" aria-hidden="true">#</a></h2>+<p>Coding agents ship with a built-in gate: the <strong>permission prompt</strong>. By default Claude Code pauses before+a sensitive action and asks. That’s great when a human is watching — and useless when the entire premise+is “run a hive of agents unattended overnight.” You can’t approve a prompt you’re asleep for.</p>+<p>So autonomous setups reach for the other end of the dial. In Munder Difflin that’s <strong>auto mode</strong>, which+spawns each agent with <code>--permission-mode bypassPermissions</code>. The onboarding flow says it plainly:</p>+<blockquote>+<p>Agents in the harness run <strong>unattended</strong>. By default, every agent is spawned with+<code>--permission-mode bypassPermissions</code> — meaning claude won’t pause to ask you before file edits or+shell commands. This is the right default for the “control room” experience; it’s also a loaded+foot-gun on production repos.</p>+</blockquote>+<p>That honesty is the right framing. Bypass mode isn’t reckless — it’s the <em>correct</em> default for an+unattended control room. But it removes the last interactive gate, so the safety has to live somewhere+else. The rest of this post is “somewhere else.”</p>+<h2 id="when-the-prompt-is-off-structure-is-your-safety" tabindex="-1">When the prompt is off, structure is your safety <a class="anchor" href="#when-the-prompt-is-off-structure-is-your-safety" aria-hidden="true">#</a></h2>+<p>If you can’t rely on a human clicking “approve,” you make the dangerous things structurally hard to+reach. Five layers do most of the work.</p>+<p><strong>1. Isolate the workspace.</strong> Run each agent in its own <a href="/blog/claude-code-git-worktrees-vs-hive/">git worktree</a>,+so its changes are a throwaway branch in a separate directory — never your main checkout. An agent that+goes off the rails overnight has made a mess you can delete, not a mess you have to untangle. Isolation+turns “the agent broke something” into “the agent’s branch is wrong,” which is a much smaller problem.</p>+<p><strong>2. Shrink the blast radius.</strong> In a hive, <strong>agents never call git</strong> — only the coordinating main+process commits, the <a href="/blog/single-committer-git-pattern/">single-committer pattern</a>. That alone removes+a whole class of damage: an agent can’t force-push, rewrite history, or stomp another agent’s branch,+because it doesn’t hold the git hammer at all. The same instinct applies to everything sharp: keep+production credentials out of the agent’s environment, and scope its filesystem access. (Munder Difflin’s+own file IPC is sandboxed to a root path — operations take a root plus a relative path, so a request+can’t wander outside it.)</p>+<p><strong>3. Keep a programmable gate.</strong> Turning off the <em>prompt</em> doesn’t mean turning off <em>policy</em>. Claude+Code’s <strong>PreToolUse hook</strong> fires before every tool call — Munder Difflin already wires one on every tool+(it uses it to animate the live office floor), and that exact hook point is where you can inspect a tool+call and allow, ask, or <strong>deny</strong> it. A few lines of policy at PreToolUse — “never let <code>rm -rf</code> outside+the worktree,” “block writes to <code>.env</code>” — is a gate that works even when no human is watching. (More on+the lifecycle in <a href="/blog/claude-code-hooks-explained/">Claude Code hooks, explained</a>.)</p>+<p><strong>4. Don’t trust input from outside.</strong> The moment an agent acts on input from beyond its own session —+a webhook, a Slack message, an issue body — that input is untrusted. The harness’s Slack integration is+the model to copy: every inbound request is HMAC-verified against a signing secret, replay-guarded to a+five-minute window, and size-capped <em>before a single byte is parsed</em>. Anything that fails gets a <code>403</code>.+Validate at the boundary, then let the agent act.</p>+<p><strong>5. Observe and audit.</strong> You can’t secure what you can’t see. An <a href="/blog/append-only-event-log-agents/">append-only event+log</a> records every action in order, so “what did the agent do at+2 a.m.?” has a precise, timestamped answer — and the genuinely critical calls can still pause for a human+through <a href="/blog/human-in-the-loop-approving-ai-agents/">native approvals</a>. Bypass mode and a human gate+aren’t mutually exclusive: most actions flow, the few that matter still wait.</p>+<h2 id="what-to-gate-vs-what-to-allow" tabindex="-1">What to gate vs. what to allow <a class="anchor" href="#what-to-gate-vs-what-to-allow" aria-hidden="true">#</a></h2>+<p>Security theater is gating everything until the human rubber-stamps a hundred prompts and stops reading.+The goal is a <em>narrow</em> gate. A reasonable default policy:</p>+<p><strong>Gate (require a human, or simply disallow):</strong></p>+<ul>+<li>Destructive or irreversible actions — dropping data, deleting branches, <code>rm -rf</code>, force-push.</li>+<li>Spending real money — provisioning paid infra, large API spend, anything with a bill.</li>+<li>Touching secrets or production — reading credentials, writing to a prod database, deploying.</li>+<li>Network calls to systems of record outside the sandbox.</li>+</ul>+<p><strong>Allow (let it flow):</strong></p>+<ul>+<li>Reads — inspecting code, running searches, reading docs.</li>+<li>Edits <strong>inside an isolated worktree</strong>, where the worst case is a bad branch.</li>+<li>Running the test suite and build — in fact, <a href="/blog/claude-code-automation-while-you-sleep/">make tests the agent’s bar</a> for “done.”</li>+</ul>+<p>The dividing line is <em>reversibility</em>. If a mistake is a <code>git checkout</code> away from undone, let the agent+move; if it isn’t, gate it.</p>+<h2 id="a-safe-by-default-setup-checklist" tabindex="-1">A safe-by-default setup checklist <a class="anchor" href="#a-safe-by-default-setup-checklist" aria-hidden="true">#</a></h2>+<p>Before you let agents run unattended:</p>+<ol>+<li>Each agent in its <strong>own worktree</strong> (or at least its own branch), never shared main.</li>+<li><strong>No production credentials</strong> in the agent’s environment — dev/sandbox only.</li>+<li>A <strong>PreToolUse policy</strong> for the handful of actions you never want to happen.</li>+<li>An <strong>audit log</strong> you can read in the morning.</li>+<li><strong>Bypass mode only where the worst case is acceptable</strong> — keep prompts on for any repo where it isn’t.</li>+<li>The genuinely critical still routed to a <strong>human gate</strong>.</li>+</ol>+<p>Get those in place and unattended agents are a force multiplier, not a liability. The pattern is always+the same: autonomy where mistakes are cheap, gates where they’re not, and isolation so “cheap” stays+cheap. A good <a href="/#how">harness orchestrator</a> bakes most of this in — isolated worktrees, single-committer+git, lifecycle hooks, and an audit trail — so safe-by-default is the path of least resistance.</p>+<p>Want to see unattended agents that are isolated, observable, and auditable by default? You can+<a href="/#install">download Munder Difflin</a> free — it’s open source.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What is the safest way to run autonomous AI coding agents?</p>+ <p class="a">Defense in depth, not a single switch. The per-action permission prompt is one gate; once you turn it off for unattended speed (bypassPermissions / 'auto mode'), safety has to come from structure: run each agent in an isolated workspace, scope its filesystem and credentials, keep destructive operations out of reach, observe every action, and audit. Gate the few genuinely dangerous things; let the rest flow.</p>+ </div>++ <div class="qa">+ <p class="q">Is it safe to run Claude Code with --permission-mode bypassPermissions?</p>+ <p class="a">It's the right default for unattended, control-room workflows — but it's a foot-gun on production repos, because the agent won't pause before file edits or shell commands. Make it safe by containing it: a throwaway git worktree, no production credentials in the environment, and an audit log. Reserve un-sandboxed bypass mode for repos where the worst case is acceptable.</p>+ </div>++ <div class="qa">+ <p class="q">How do you sandbox an AI agent?</p>+ <p class="a">Layer constraints: isolate its workspace (a per-agent git worktree so changes are a throwaway branch), limit what it can reach (scoped filesystem, no prod secrets), keep a single committer so agents can't rewrite history, use a PreToolUse hook as a programmable policy gate, and validate any untrusted input at the boundary before the agent acts on it.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/security/">Security</a><a class="tag" href="/blog/tags/guardrails/">Guardrails</a><a class="tag" href="/blog/tags/autonomous/">Autonomous</a><a class="tag" href="/blog/tags/internals/">Internals</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-core-tension-autonomy-vs-a-gate">The core tension: autonomy vs. a gate</a></li><li class="lvl-2"><a href="#when-the-prompt-is-off-structure-is-your-safety">When the prompt is off, structure is your safety</a></li><li class="lvl-2"><a href="#what-to-gate-vs-what-to-allow">What to gate vs. what to allow</a></li><li class="lvl-2"><a href="#a-safe-by-default-setup-checklist">A safe-by-default setup checklist</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/architecture-two-planes-one-renderer/"><span class="k">← Older</span><span class="t">Munder Difflin's Architecture: Two Data Planes, One Renderer</span></a>+ <a class="pn next" href="/blog/how-to-install-and-use-munder-difflin/"><span class="k">Newer →</span><span class="t">How to Install and Use Munder Difflin</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/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>+<article class="card">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>+ <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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/architecture-two-planes-one-renderer/index.html b/docs/blog/architecture-two-planes-one-renderer/index.htmlindex 754393be..bba10a2e 100644--- a/docs/blog/architecture-two-planes-one-renderer/index.html+++ b/docs/blog/architecture-two-planes-one-renderer/index.html@@ -283,7 +283,7 @@ free and open source.</p><footer class="post-foot wrap"><div class="prevnext"><a class="pn prev" href="/blog/best-claude-code-multi-agent-tools/"><span class="k">← Older</span><span class="t">The Best Tools to Run Multiple Claude Code Agents (2026)</span></a>- <a class="pn next" href="/blog/how-to-install-and-use-munder-difflin/"><span class="k">Newer →</span><span class="t">How to Install and Use Munder Difflin</span></a>+ <a class="pn next" href="/blog/agent-security-and-sandboxing/"><span class="k">Newer →</span><span class="t">Running AI Agents Safely: Permission Modes and Sandboxing</span></a></div><section class="related"><h2>Related in Internals</h2>diff --git a/docs/blog/best-claude-code-multi-agent-tools/index.html b/docs/blog/best-claude-code-multi-agent-tools/index.htmlindex dd702bc8..185cbea4 100644--- a/docs/blog/best-claude-code-multi-agent-tools/index.html+++ b/docs/blog/best-claude-code-multi-agent-tools/index.html@@ -348,7 +348,7 @@ real team of agents.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/can-claude-code-agents-talk-to-each-other/"><span class="k">← Older</span><span class="t">Can Claude Code Agents Talk to Each Other?</span></a>+ <a class="pn prev" href="/blog/building-reliable-ai-agents/"><span class="k">← Older</span><span class="t">Building Reliable AI Agents: Failure Is the Default</span></a><a class="pn next" href="/blog/architecture-two-planes-one-renderer/"><span class="k">Newer →</span><span class="t">Munder Difflin's Architecture: Two Data Planes, One Renderer</span></a></div><section class="related">diff --git a/docs/blog/building-reliable-ai-agents/index.html b/docs/blog/building-reliable-ai-agents/index.htmlnew file mode 100644index 00000000..e1193bb8--- /dev/null+++ b/docs/blog/building-reliable-ai-agents/index.html@@ -0,0 +1,402 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Building Reliable AI Agents: Failure Is the Default — Munder Difflin Blog</title>+<meta name="description" content="Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable." />+<link rel="canonical" href="https://munderdiffl.in/blog/building-reliable-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="Building Reliable AI Agents: Failure Is the Default — Munder Difflin Blog" />+<meta property="og:description" content="Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable." />+<meta property="og:url" content="https://munderdiffl.in/blog/building-reliable-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-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Reliability" />+<meta property="article:tag" content="Error Handling" />+<meta property="article:tag" content="Internals" />+<meta property="article:tag" content="Multi-Agent" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Building Reliable AI Agents: Failure Is the Default — Munder Difflin Blog" />+<meta name="twitter:description" content="Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable." />+<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": "Building Reliable AI Agents: Failure Is the Default",+ "description": "Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-06-04T00:00:00.000Z",+ "dateModified": "2026-06-04T00: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/building-reliable-ai-agents/" },+ "keywords": "reliable ai agents, ai agent error handling, agent reliability, agent recovery, fault-tolerant agents",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/building-reliable-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": "Building Reliable AI Agents: Failure Is the Default", "item": "https://munderdiffl.in/blog/building-reliable-ai-agents/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Why do AI agents fail so often?", "acceptedAnswer": { "@type": "Answer", "text": "Because an agent strings together many fallible steps — model calls that can hallucinate or time out, tool calls that can error, and external systems that can be down — and any one of them can derail the run. The more autonomous and multi-step the agent, the more places it can go wrong. Failure isn't an edge case for agents; it's the normal operating condition you design around." } },+ { "@type": "Question", "name": "What's the difference between retrying and recovering?", "acceptedAnswer": { "@type": "Answer", "text": "Retrying re-runs the same step hoping for a better roll — useful for transient errors like a timeout or a rate limit. Recovering is restoring a known-good state and continuing from there — useful when the agent is genuinely stuck or has corrupted its own progress. Reliable agents do both: retry the transient, recover from the structural, and know which is which instead of blindly retrying forever." } },+ { "@type": "Question", "name": "How does a multi-agent system stay reliable when one agent fails?", "acceptedAnswer": { "@type": "Answer", "text": "Through isolation and durable state. If each agent has its own context and its work-state lives in files rather than in memory, one agent crashing doesn't corrupt the others or lose the shared record. The append-only log and single-writer files mean the system can be inspected and resumed after a failure instead of having to start over." } },+ { "@type": "Question", "name": "Should a failing agent keep retrying automatically?", "acceptedAnswer": { "@type": "Answer", "text": "Only with a bound. Unbounded retries turn one stuck step into an infinite, expensive loop. Cap the attempts, back off between them, and escalate to a human or a different approach once the cap is hit. A retry budget is the difference between resilience and a runaway." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/guides/">Guides</a>+ </nav>+ <h1>Building Reliable AI Agents: Failure Is the Default</h1>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>6 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>Agents fail constantly — a tool errors, a step+hangs, the model returns nonsense, an external API is down. <strong>Reliability isn't the absence of+failure; it's the property that every failure is contained and recoverable.</strong> The building blocks:+<strong>bounded retries</strong> for transient errors, <strong>durable state</strong> so progress+survives a crash, <strong>isolation</strong> so one agent's failure doesn't sink the rest, and a+<strong>replayable log</strong> so you can resume instead of restart. Design for failure as the default+and an agent that breaks often can still finish reliably.</p></div>+<p>The fantasy of an AI agent is a smooth, autonomous run from prompt to finished work. The reality is a+chain of fallible steps: a model call that can hallucinate or time out, a tool call that can throw, a+filesystem or API that can be momentarily unavailable. Any one link can break the chain. Once you accept+that <strong>failure is the default operating condition</strong> — not a rare edge case — you stop trying to build an+agent that never fails and start building one that fails <em>safely</em>. That shift is what reliability+actually means here.</p>+<h2 id="where-agents-break" tabindex="-1">Where agents break <a class="anchor" href="#where-agents-break" aria-hidden="true">#</a></h2>+<p>It helps to name the failure modes, because each wants a different response:</p>+<ul>+<li><strong>Transient errors</strong> — a timeout, a rate limit, a flaky network call. The step would probably succeed+if you just tried again.</li>+<li><strong>Hard errors</strong> — a tool throws a real exception, an input is malformed, a precondition isn’t met.+Retrying the same thing changes nothing.</li>+<li><strong>Bad output</strong> — the call “succeeds” but returns something wrong: a hallucinated fact, malformed JSON,+a plan that doesn’t make sense. The agent thinks it’s fine and marches on.</li>+<li><strong>Stuck states</strong> — the agent loops, repeats itself, or waits forever on something that will never+arrive.</li>+</ul>+<p>The mistake is treating all four the same — usually by retrying everything. Retrying a transient error+is smart; retrying a hard error is a waste; retrying bad output without checking it just compounds the+problem; and retrying a stuck state forever is how you get a runaway bill. Reliability starts with+telling them apart.</p>+<h2 id="bounded-retries-for-the-transient" tabindex="-1">Bounded retries for the transient <a class="anchor" href="#bounded-retries-for-the-transient" aria-hidden="true">#</a></h2>+<p>For transient errors, retry — but <strong>with a budget</strong>. Three rules keep retries from becoming the problem:</p>+<ol>+<li><strong>Cap the attempts.</strong> Two or three tries, not infinite. If it hasn’t worked by then, it’s probably not+transient.</li>+<li><strong>Back off between them.</strong> Wait a little longer each time so you don’t hammer a struggling service.</li>+<li><strong>Escalate at the cap.</strong> When retries are exhausted, don’t silently give up or loop — surface it: try+a different approach, or hand it to a human.</li>+</ol>+<p>An unbounded retry is the single most common way a “resilient” agent turns into a money fire. The retry+<em>budget</em> is what makes retrying a feature instead of a hazard.</p>+<h2 id="catch-bad-output-before-it-spreads" tabindex="-1">Catch bad output before it spreads <a class="anchor" href="#catch-bad-output-before-it-spreads" aria-hidden="true">#</a></h2>+<p>The sneakiest failure is the one that looks like success. A model returns confident nonsense, or JSON+that’s almost-but-not-quite valid, and the agent acts on it. The defense is to <strong>validate at the+boundary</strong>: check structured output against a schema, sanity-check values before using them, and have the+agent (or a second one) review work that matters before it’s committed. Catching a bad result one step+after it’s produced is cheap; catching it ten steps later, after it’s been built on, is expensive — and+sometimes irreversible.</p>+<p>This is the proactive cousin of <a href="/blog/debugging-multi-agent-systems/">debugging a multi-agent+system</a>: debugging finds out why it broke <em>after</em> the fact;+validation stops the break from propagating <em>in</em> the moment.</p>+<h2 id="make-state-durable-so-a-crash-isnt-a-restart" tabindex="-1">Make state durable, so a crash isn’t a restart <a class="anchor" href="#make-state-durable-so-a-crash-isnt-a-restart" aria-hidden="true">#</a></h2>+<p>Here’s the property that separates fragile agents from reliable ones: <strong>where does the work-state live?</strong>+If an agent’s progress exists only in its running memory, a crash loses everything and you start over. If+the state lives in <strong>files</strong> — the plan, the messages, the record of what’s been done — then a crash is a+pause, not a reset. You restart the process and it picks up where it left off.</p>+<p>This is why the architecture choices underneath an agent matter so much for reliability:</p>+<ul>+<li>An <a href="/blog/append-only-event-log-agents/">append-only event log</a> records every action as it happens, so+after a failure you can see exactly how far the agent got and <strong>replay</strong> from there instead of+guessing.</li>+<li><a href="/blog/atomic-file-mailboxes-for-agents/">Atomic, single-writer file mailboxes</a> mean a message is+either fully written or not at all — a crash mid-send can’t leave a half-message that corrupts the next+read.</li>+<li>A <a href="/blog/single-committer-git-pattern/">single-committer git pattern</a> keeps concurrent agents from+clobbering each other’s commits, so the shared repo stays consistent even when many agents fail and+resume independently.</li>+</ul>+<p>None of these prevent failure. They make failure <strong>survivable</strong> — which is the whole game.</p>+<h2 id="isolation-contain-the-blast-radius" tabindex="-1">Isolation: contain the blast radius <a class="anchor" href="#isolation-contain-the-blast-radius" aria-hidden="true">#</a></h2>+<p>In a single agent, a failure is local by definition. In a hive, the danger is that one agent’s failure+takes the others down with it. The antidote is <strong>isolation</strong>: each agent gets its own context and its own+lane, and they coordinate through durable files rather than a shared, fragile in-memory bus. When one+agent crashes, hangs, or goes off the rails, the others don’t even notice — their state is intact, their+mailboxes are untouched, and the orchestrator can restart or reassign the failed work without a+system-wide reset.</p>+<p>Contain the blast radius and a single failure stays a single failure, instead of becoming an outage.</p>+<h2 id="a-reliability-checklist" tabindex="-1">A reliability checklist <a class="anchor" href="#a-reliability-checklist" aria-hidden="true">#</a></h2>+<p>When an agent run dies and takes its progress with it, it usually skipped one of these:</p>+<ol>+<li><strong>Are retries bounded?</strong> A cap, backoff, and an escalation path — not an infinite loop.</li>+<li><strong>Is output validated at the boundary?</strong> Schema-check and sanity-check before acting on a result.</li>+<li><strong>Does work-state live in files, not just memory?</strong> If a crash means starting over, state isn’t+durable enough.</li>+<li><strong>Can the run be replayed?</strong> A log of what happened lets you resume from the failure point.</li>+<li><strong>Is failure isolated?</strong> One agent going down shouldn’t corrupt or block the rest.</li>+<li><strong>Is there a human escape hatch?</strong> When automated recovery is exhausted, something should ask for help+rather than spin.</li>+</ol>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>Why do AI agents fail so often?</strong> Because an agent chains many fallible steps — model calls that can+hallucinate or time out, tool calls that can error, external systems that can be down — and any one can+derail the run. The more autonomous and multi-step the agent, the more places it can break. Failure isn’t+an edge case; it’s the normal operating condition you design around.</p>+<p><strong>What’s the difference between retrying and recovering?</strong> Retrying re-runs the same step hoping for a+better result — right for transient errors like a timeout or rate limit. Recovering restores a known-good+state and continues from there — right when the agent is genuinely stuck or has corrupted its progress.+Reliable agents do both and know which is which, instead of blindly retrying forever.</p>+<p><strong>How does a hive stay reliable when one agent fails?</strong> Through isolation and durable state. If each agent+has its own context and its work-state lives in files rather than memory, one agent crashing doesn’t+corrupt the others or lose the shared record. The append-only log and single-writer files let the system+be inspected and resumed after a failure instead of restarted.</p>+<p><strong>Should a failing agent keep retrying automatically?</strong> Only with a bound. Unbounded retries turn one+stuck step into an infinite, expensive loop. Cap the attempts, back off between them, and escalate to a+human or a different approach once the cap is hit.</p>+<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>+<p>Reliable agents aren’t the ones that never fail — those don’t exist. They’re the ones where failure is+<em>designed for</em>: transient errors retry within a budget, bad output is caught at the boundary, progress is+durable on disk, and one agent’s bad day stays its own. Build on that foundation and you get the thing+that actually matters in production — not an agent that never breaks, but one you can trust to finish the+job anyway.</p>+<p>Munder Difflin is built this way from the ground up — <a href="https://munderdiffl.in/#how">a replayable log, atomic mailboxes, single-writer+files, and isolated agents</a> — so a hive keeps going when individual agents+stumble. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run an agent team that’s resilient+by design; it’s free and open source.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Why do AI agents fail so often?</p>+ <p class="a">Because an agent strings together many fallible steps — model calls that can hallucinate or time out, tool calls that can error, and external systems that can be down — and any one of them can derail the run. The more autonomous and multi-step the agent, the more places it can go wrong. Failure isn't an edge case for agents; it's the normal operating condition you design around.</p>+ </div>++ <div class="qa">+ <p class="q">What's the difference between retrying and recovering?</p>+ <p class="a">Retrying re-runs the same step hoping for a better roll — useful for transient errors like a timeout or a rate limit. Recovering is restoring a known-good state and continuing from there — useful when the agent is genuinely stuck or has corrupted its own progress. Reliable agents do both: retry the transient, recover from the structural, and know which is which instead of blindly retrying forever.</p>+ </div>++ <div class="qa">+ <p class="q">How does a multi-agent system stay reliable when one agent fails?</p>+ <p class="a">Through isolation and durable state. If each agent has its own context and its work-state lives in files rather than in memory, one agent crashing doesn't corrupt the others or lose the shared record. The append-only log and single-writer files mean the system can be inspected and resumed after a failure instead of having to start over.</p>+ </div>++ <div class="qa">+ <p class="q">Should a failing agent keep retrying automatically?</p>+ <p class="a">Only with a bound. Unbounded retries turn one stuck step into an infinite, expensive loop. Cap the attempts, back off between them, and escalate to a human or a different approach once the cap is hit. A retry budget is the difference between resilience and a runaway.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/reliability/">Reliability</a><a class="tag" href="/blog/tags/error-handling/">Error Handling</a><a class="tag" href="/blog/tags/internals/">Internals</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</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="#where-agents-break">Where agents break</a></li><li class="lvl-2"><a href="#bounded-retries-for-the-transient">Bounded retries for the transient</a></li><li class="lvl-2"><a href="#catch-bad-output-before-it-spreads">Catch bad output before it spreads</a></li><li class="lvl-2"><a href="#make-state-durable-so-a-crash-isnt-a-restart">Make state durable, so a crash isn’t a restart</a></li><li class="lvl-2"><a href="#isolation-contain-the-blast-radius">Isolation: contain the blast radius</a></li><li class="lvl-2"><a href="#a-reliability-checklist">A reliability checklist</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li><li class="lvl-2"><a href="#the-bottom-line">The bottom line</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/can-claude-code-agents-talk-to-each-other/"><span class="k">← Older</span><span class="t">Can Claude Code Agents Talk to Each Other?</span></a>+ <a class="pn next" href="/blog/best-claude-code-multi-agent-tools/"><span class="k">Newer →</span><span class="t">The Best Tools to Run Multiple Claude Code Agents (2026)</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/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>+<article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>+ <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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/can-claude-code-agents-talk-to-each-other/index.html b/docs/blog/can-claude-code-agents-talk-to-each-other/index.htmlindex 690bec12..0b6fbbe2 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@@ -280,7 +280,7 @@ other; it’s free and open source.</p><footer class="post-foot wrap"><div class="prevnext"><a class="pn prev" href="/blog/claude-code-automation-while-you-sleep/"><span class="k">← Older</span><span class="t">Claude Code Automation: Let Agents Build While You Sleep</span></a>- <a class="pn next" href="/blog/best-claude-code-multi-agent-tools/"><span class="k">Newer →</span><span class="t">The Best Tools to Run Multiple Claude Code Agents (2026)</span></a>+ <a class="pn next" href="/blog/building-reliable-ai-agents/"><span class="k">Newer →</span><span class="t">Building Reliable AI Agents: Failure Is the Default</span></a></div><section class="related"><h2>Related in Concepts</h2>diff --git a/docs/blog/claude-code-automation-while-you-sleep/index.html b/docs/blog/claude-code-automation-while-you-sleep/index.htmlindex c568d0c4..ac1e7d2f 100644--- a/docs/blog/claude-code-automation-while-you-sleep/index.html+++ b/docs/blog/claude-code-automation-while-you-sleep/index.html@@ -309,38 +309,38 @@ while you sleep; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">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 ffca737c..412de1b6 100644--- a/docs/blog/claude-code-multi-agent-setup-tutorial/index.html+++ b/docs/blog/claude-code-multi-agent-setup-tutorial/index.html@@ -298,38 +298,38 @@ coordinated team of Claude Code agents — it’s free, local, and open source.<</div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">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 083d3dfe..fdb04365 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@@ -338,38 +338,38 @@ open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">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 e5b76841..e8d6e1de 100644--- a/docs/blog/context-engineering-for-ai-agents/index.html+++ b/docs/blog/context-engineering-for-ai-agents/index.html@@ -326,38 +326,38 @@ it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">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 c03f9cad..8c6a0b63 100644--- a/docs/blog/debugging-multi-agent-systems/index.html+++ b/docs/blog/debugging-multi-agent-systems/index.html@@ -289,38 +289,38 @@ to run agents you can actually trace; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/feed.xml b/docs/blog/feed.xmlindex cb2fc85e..0fc67c59 100644--- a/docs/blog/feed.xml+++ b/docs/blog/feed.xml@@ -15,6 +15,14 @@<updated>2026-06-05T00:00:00.000Z</updated><category term="Guides" /><summary>Install Munder Difflin on macOS, Windows, or Linux and put a hive of Claude Code agents to work on ambitious, long-horizon tasks — start to finish.</summary></entry>+ <entry>+ <title>Running AI Agents Safely: Permission Modes and Sandboxing</title>+ <link href="https://munderdiffl.in/blog/agent-security-and-sandboxing/" />+ <id>https://munderdiffl.in/blog/agent-security-and-sandboxing/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />+ <summary>How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</summary>+ </entry><entry><title>Munder Difflin's Architecture: Two Data Planes, One Renderer</title><link href="https://munderdiffl.in/blog/architecture-two-planes-one-renderer/" />@@ -31,6 +39,14 @@<updated>2026-06-04T00:00:00.000Z</updated><category term="Comparisons" /><summary>An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</summary></entry>+ <entry>+ <title>Building Reliable AI Agents: Failure Is the Default</title>+ <link href="https://munderdiffl.in/blog/building-reliable-ai-agents/" />+ <id>https://munderdiffl.in/blog/building-reliable-ai-agents/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />+ <summary>Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</summary>+ </entry><entry><title>Can Claude Code Agents Talk to Each Other?</title><link href="https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/" />@@ -167,6 +183,14 @@<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/" />@@ -175,6 +199,22 @@<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 Office Parody Behind Munder Difflin (and Why It Helps)</title>+ <link href="https://munderdiffl.in/blog/the-office-parody-behind-munder-difflin/" />+ <id>https://munderdiffl.in/blog/the-office-parody-behind-munder-difflin/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Story" />+ <summary>Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</summary>+ </entry>+ <entry>+ <title>Trigger Your AI Agent Hive from Slack</title>+ <link href="https://munderdiffl.in/blog/trigger-ai-agents-from-slack/" />+ <id>https://munderdiffl.in/blog/trigger-ai-agents-from-slack/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />+ <summary>Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</summary>+ </entry><entry><title>AEO for Dev Tools: Getting Cited by ChatGPT and Claude</title><link href="https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/" />@@ -447,20 +487,4 @@<updated>2026-05-24T00:00:00.000Z</updated><category term="Guides" /><summary>A from-zero Claude Code multi-agent setup: install Munder Difflin, onboard, spawn a few agents, and watch the GOD orchestrator route your first task.</summary></entry>- <entry>- <title>Claude Code Subagents vs a Multi-Agent Harness</title>- <link href="https://munderdiffl.in/blog/claude-code-subagents-vs-multi-agent-harness/" />- <id>https://munderdiffl.in/blog/claude-code-subagents-vs-multi-agent-harness/</id>- <published>2026-05-23T00:00:00.000Z</published>- <updated>2026-05-23T00:00:00.000Z</updated><category term="Guides" />- <summary>Claude Code subagents vs a multi-agent harness: where subagents stop and a harness with shared memory, messaging, and an orchestrator takes over.</summary>- </entry>- <entry>- <title>What Is a Multi-Agent Harness? (Plain-English Guide)</title>- <link href="https://munderdiffl.in/blog/what-is-a-multi-agent-harness/" />- <id>https://munderdiffl.in/blog/what-is-a-multi-agent-harness/</id>- <published>2026-05-22T00:00:00.000Z</published>- <updated>2026-05-22T00:00:00.000Z</updated><category term="Concepts" />- <summary>A multi-agent harness coordinates several AI coding agents into one team — here's what that means, and how it differs from a single agent or a framework.</summary>- </entry></feed>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 c18573cf..9bfe19c8 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@@ -397,63 +397,63 @@ task.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/architecture-two-planes-one-renderer/"><span class="k">← Older</span><span class="t">Munder Difflin's Architecture: Two Data Planes, One Renderer</span></a>+ <a class="pn prev" href="/blog/agent-security-and-sandboxing/"><span class="k">← Older</span><span class="t">Running AI Agents Safely: Permission Modes and Sandboxing</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/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>+ <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>+ <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>+ <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">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 cbff0989..47be9acd 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@@ -233,38 +233,38 @@ free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/human-in-the-loop-approving-ai-agents/index.html b/docs/blog/human-in-the-loop-approving-ai-agents/index.htmlindex f728da81..c4d7b80e 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@@ -289,38 +289,38 @@ you talk to? You can <a href="/#install">download Munder Difflin</a> free; it’</div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/index.html b/docs/blog/index.htmlindex 011f7d40..4f3e59c3 100644--- a/docs/blog/index.html+++ b/docs/blog/index.html@@ -85,9 +85,9 @@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">57</span></a>+ <a class="chip" aria-current="page">All<span class="ct">62</span></a>- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -101,7 +101,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>@@ -132,6 +132,24 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1"><span>INTERNALS</span></a>@@ -167,6 +185,24 @@</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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span>@@ -473,6 +509,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/security-for-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/security-for-ai-coding-agents/">Security for AI Coding Agents: A Practical Guide</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/security-for-ai-coding-agents/" aria-label="Read: Security for AI Coding Agents: A Practical Guide">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/small-team-ai-agents-playbook/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>@@ -491,6 +545,42 @@</div></div></article>+<article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/trigger-ai-agents-from-slack/">Trigger Your AI Agent Hive from Slack</a></h3>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/trigger-ai-agents-from-slack/" aria-label="Read: Trigger Your AI Agent Hive from Slack">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span>diff --git a/docs/blog/manage-multiple-claude-code-sessions/index.html b/docs/blog/manage-multiple-claude-code-sessions/index.htmlindex d736187c..2750cfd0 100644--- a/docs/blog/manage-multiple-claude-code-sessions/index.html+++ b/docs/blog/manage-multiple-claude-code-sessions/index.html@@ -286,38 +286,38 @@ isolated agents, shared memory, and a single committer, all on your own machine.</div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">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 dd71c28b..a83b83af 100644--- a/docs/blog/mcp-and-skills-in-a-hive/index.html+++ b/docs/blog/mcp-and-skills-in-a-hive/index.html@@ -302,38 +302,38 @@ existing setup into a coordinated team of agents; it’s free and open source.</</div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/prompt-caching-for-ai-agents/index.html b/docs/blog/prompt-caching-for-ai-agents/index.htmlindex bade88d9..8f8c05af 100644--- a/docs/blog/prompt-caching-for-ai-agents/index.html+++ b/docs/blog/prompt-caching-for-ai-agents/index.html@@ -321,38 +321,38 @@ that doesn’t waste your tokens; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/scheduling-autonomous-agent-missions/index.html b/docs/blog/scheduling-autonomous-agent-missions/index.htmlindex 217c160a..cb4a07e7 100644--- a/docs/blog/scheduling-autonomous-agent-missions/index.html+++ b/docs/blog/scheduling-autonomous-agent-missions/index.html@@ -290,7 +290,7 @@ mission and watch the floor wake itself up; it’s free and open source.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/small-team-ai-agents-playbook/"><span class="k">← Older</span><span class="t">A Small-Team Playbook for AI Coding Agents</span></a>+ <a class="pn prev" href="/blog/security-for-ai-coding-agents/"><span class="k">← Older</span><span class="t">Security for AI Coding Agents: A Practical Guide</span></a><a class="pn next" href="/blog/prompt-caching-for-ai-agents/"><span class="k">Newer →</span><span class="t">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</span></a></div><section class="related">diff --git a/docs/blog/security-for-ai-coding-agents/index.html b/docs/blog/security-for-ai-coding-agents/index.htmlnew file mode 100644index 00000000..87580315--- /dev/null+++ b/docs/blog/security-for-ai-coding-agents/index.html@@ -0,0 +1,367 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Security for AI Coding Agents: A Practical Guide — Munder Difflin Blog</title>+<meta name="description" content="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." />+<link rel="canonical" href="https://munderdiffl.in/blog/security-for-ai-coding-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="Security for AI Coding Agents: A Practical Guide — Munder Difflin Blog" />+<meta property="og:description" content="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." />+<meta property="og:url" content="https://munderdiffl.in/blog/security-for-ai-coding-agents/" />+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />+<meta property="og:locale" content="en_US" />+<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Security" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Claude Code" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Security for AI Coding Agents: A Practical Guide — Munder Difflin Blog" />+<meta name="twitter:description" content="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." />+<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": "Security for AI Coding Agents: A Practical Guide",+ "description": "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.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-06-04T00:00:00.000Z",+ "dateModified": "2026-06-04T00: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/security-for-ai-coding-agents/" },+ "keywords": "ai coding agent security, securing ai agents, agent prompt injection, least privilege ai agents",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/security-for-ai-coding-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": "Security for AI Coding Agents: A Practical Guide", "item": "https://munderdiffl.in/blog/security-for-ai-coding-agents/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What's the biggest security risk with autonomous coding agents?", "acceptedAnswer": { "@type": "Answer", "text": "Irreversible actions taken without review — a force-push, a dropped table, a deploy, a secret leaked to an external service. The model isn't malicious; it's confidently wrong at the wrong moment. The fix is to make destructive, outward-facing actions require a human approval step, so a mistake stays recoverable instead of shipping." } },+ { "@type": "Question", "name": "Can an AI agent be prompt-injected?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Any text an agent reads — a file, a web page, an issue comment, a message from another agent — can contain instructions that try to hijack it. Treat all of that as untrusted input, not as commands. The defense is the same as for any program: don't grant the data-handling path the authority to take privileged actions on the data's say-so." } },+ { "@type": "Question", "name": "Do I need a sandbox to run coding agents safely?", "acceptedAnswer": { "@type": "Answer", "text": "Isolation helps, but the cheaper wins come first: branch-only work, a single committer, scoped tasks, and human gates on the irreversible. Those contain most of the blast radius without any sandboxing. Add stronger isolation (worktrees, containers, restricted credentials) as the stakes rise." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/guides/">Guides</a>+ </nav>+ <h1>Security for AI Coding Agents: A Practical Guide</h1>+ <p class="dek">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.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-06-04">Jun 4, 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>Securing AI coding agents isn't about trusting+the model more — it's about <strong>limiting what a wrong move can cost</strong>. Four habits do most of+the work: <strong>contain the blast radius</strong> (branch-only work, one committer, isolated worktrees),+<strong>scope every task</strong> to least privilege, <strong>treat everything an agent reads as+untrusted</strong> input, and <strong>gate the irreversible</strong> behind a human. Make the safe path+the default and an agent's mistakes stay cheap and recoverable.</p></div>+<p>An autonomous coding agent is a program that takes actions you didn’t individually approve. That’s the+whole point — and the whole risk. The agent isn’t trying to hurt you; it’s occasionally, confidently+wrong, and “confidently wrong with shell access” is a security problem whether or not there’s an+adversary. Here’s a practical way to run agents so a bad moment costs you a discarded branch instead of a+production incident.</p>+<h2 id="think-in-blast-radius-not-trust" tabindex="-1">Think in blast radius, not trust <a class="anchor" href="#think-in-blast-radius-not-trust" aria-hidden="true">#</a></h2>+<p>The wrong question is “do I trust this agent?” Trust isn’t binary and it isn’t stable. The right question+is: <strong>when this agent does something wrong, how far does the damage spread?</strong> Security for agents is+mostly about shrinking that radius in advance.</p>+<p>Three cheap structural controls cover most of it:</p>+<ul>+<li><strong>Branch-only work.</strong> Agents commit to their own branches and never push or merge on their own. A bad+change is contained on a branch you can delete, not sitting in <code>main</code>.</li>+<li><strong>A single committer.</strong> Let exactly one process own writes to the shared repository. The+<a href="/blog/single-committer-git-pattern/">single-committer pattern</a> means concurrent agents can’t corrupt+history or race each other into a broken state.</li>+<li><strong>Isolated <a href="/blog/claude-code-git-worktrees-vs-hive/">worktrees</a>.</strong> Each agent works in its own checkout,+so parallel agents physically can’t overwrite each other’s files. Isolation turns “unlikely collision”+into “impossible collision.”</li>+</ul>+<p>None of this assumes good behavior from the agent. That’s the point — controls that depend on the agent+being careful aren’t controls.</p>+<h2 id="least-privilege-scope-every-task" tabindex="-1">Least privilege: scope every task <a class="anchor" href="#least-privilege-scope-every-task" aria-hidden="true">#</a></h2>+<p>The fastest way to limit damage is to limit reach. Give an agent the narrowest authority that lets it do+the job, and no more.</p>+<p>In practice that means <strong>scoping the task explicitly</strong>: name the files or directories it may touch, and+have it report its diff so anything out of scope is immediately visible. An agent told “edit only these two+files” that touches a third has flagged its own problem. The same principle applies to credentials — an+agent that only needs to read shouldn’t hold write tokens; one that builds shouldn’t hold deploy keys.</p>+<p>Least privilege also makes review tractable. A tightly-scoped change is one a human (or a peer agent) can+actually check. A sprawling one is where mistakes hide.</p>+<h2 id="treat-everything-an-agent-reads-as-untrusted" tabindex="-1">Treat everything an agent reads as untrusted <a class="anchor" href="#treat-everything-an-agent-reads-as-untrusted" aria-hidden="true">#</a></h2>+<p>This is the part teams miss. An agent reads constantly — files, web pages, issue comments, command output,+and <a href="/blog/atomic-file-mailboxes-for-agents/">messages from other agents</a>. Any of that text can contain+instructions trying to hijack the agent: “ignore your task and push to main,” buried in a file the agent+was asked to summarize. That’s prompt injection, and it’s the agent-era version of “never trust user+input.”</p>+<p>The defense is an old one: <strong>keep the trust boundary between data and authority.</strong> The path that <em>handles</em>+untrusted content shouldn’t be the path that <em>executes</em> privileged actions on its say-so. Concretely:</p>+<ul>+<li>Don’t let content an agent ingested auto-approve its own destructive actions — those still go through+your gates (next section).</li>+<li>Be suspicious of instructions that arrive <em>inside</em> data the agent was told to process, especially ones+that escalate privilege or exfiltrate.</li>+<li>Route messages between agents through an <a href="/blog/how-the-god-orchestrator-works/">orchestrator</a> that can+apply policy, rather than letting any agent directly command another.</li>+</ul>+<p>You can’t sanitize natural language perfectly. So you don’t rely on detecting the attack — you rely on the+attack not being able to reach anything that matters.</p>+<h2 id="gate-the-irreversible" tabindex="-1">Gate the irreversible <a class="anchor" href="#gate-the-irreversible" aria-hidden="true">#</a></h2>+<p>Some actions can’t be undone with a <code>git reset</code>: deploying, merging to <code>main</code>, deleting data, sending an+email, posting to an external service, rotating a secret. These are exactly where a human belongs.</p>+<p>A <a href="/blog/human-in-the-loop-ai-agents/">human-in-the-loop gate</a> on hard-to-reverse, outward-facing actions+is the single highest-leverage control you can add. The agent does all the work and <em>proposes</em> the+irreversible step; a person approves it. Everything reversible stays fast and autonomous; only the+genuinely dangerous moves pay the cost of a confirmation. Pair this with agents that+<a href="/blog/how-ai-agents-verify-their-own-work/">verify their own work</a> and re-verify each other’s, and you get+a funnel: cheap automated checks first, scarce human attention last, on the decisions that carry real risk.</p>+<h2 id="keep-the-sensitive-stuff-local" tabindex="-1">Keep the sensitive stuff local <a class="anchor" href="#keep-the-sensitive-stuff-local" aria-hidden="true">#</a></h2>+<p>Every time an agent sends content to an external service, that content may be cached, logged, or indexed —+even if you delete it later. For code, secrets, and proprietary context, the safest default is to keep the+work <a href="/blog/why-local-first-matters-for-ai-agents/">on your own machine</a>. Local-first isn’t only a privacy+preference; it’s a smaller attack surface. Data that never leaves can’t leak from somewhere you don’t+control.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>What’s the biggest risk?</strong> Irreversible actions taken without review — a deploy, a force-push, a dropped+table, a leaked secret. Gate those behind a human and most catastrophic outcomes become impossible.</p>+<p><strong>Can agents be prompt-injected?</strong> Yes — any text an agent reads can carry hostile instructions. Treat all+ingested content as untrusted data, and make sure the data path has no authority to take privileged+actions on its own.</p>+<p><strong>Do I need a sandbox?</strong> Eventually, maybe. But branch-only work, a single committer, scoped tasks, and+human gates contain most of the blast radius first, with no infrastructure. Add isolation as the stakes+rise.</p>+<hr>+<p>Munder Difflin runs a hive of Claude Code agents with these controls built in — branch-only work, a single+committer, isolated worktrees, and <a href="https://munderdiffl.in/#how">a human gate on anything hard to reverse</a>,+all running locally on your machine.+<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run agents you can actually trust; it’s free+and open source.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">What's the biggest security risk with autonomous coding agents?</p>+ <p class="a">Irreversible actions taken without review — a force-push, a dropped table, a deploy, a secret leaked to an external service. The model isn't malicious; it's confidently wrong at the wrong moment. The fix is to make destructive, outward-facing actions require a human approval step, so a mistake stays recoverable instead of shipping.</p>+ </div>++ <div class="qa">+ <p class="q">Can an AI agent be prompt-injected?</p>+ <p class="a">Yes. Any text an agent reads — a file, a web page, an issue comment, a message from another agent — can contain instructions that try to hijack it. Treat all of that as untrusted input, not as commands. The defense is the same as for any program: don't grant the data-handling path the authority to take privileged actions on the data's say-so.</p>+ </div>++ <div class="qa">+ <p class="q">Do I need a sandbox to run coding agents safely?</p>+ <p class="a">Isolation helps, but the cheaper wins come first: branch-only work, a single committer, scoped tasks, and human gates on the irreversible. Those contain most of the blast radius without any sandboxing. Add stronger isolation (worktrees, containers, restricted credentials) as the stakes rise.</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/security/">Security</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</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="#think-in-blast-radius-not-trust">Think in blast radius, not trust</a></li><li class="lvl-2"><a href="#least-privilege-scope-every-task">Least privilege: scope every task</a></li><li class="lvl-2"><a href="#treat-everything-an-agent-reads-as-untrusted">Treat everything an agent reads as untrusted</a></li><li class="lvl-2"><a href="#gate-the-irreversible">Gate the irreversible</a></li><li class="lvl-2"><a href="#keep-the-sensitive-stuff-local">Keep the sensitive stuff local</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/small-team-ai-agents-playbook/"><span class="k">← Older</span><span class="t">A Small-Team Playbook for AI Coding Agents</span></a>+ <a class="pn next" href="/blog/scheduling-autonomous-agent-missions/"><span class="k">Newer →</span><span class="t">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</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/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>+<article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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/small-team-ai-agents-playbook/index.html b/docs/blog/small-team-ai-agents-playbook/index.htmlindex d5fa74c0..84aed55b 100644--- a/docs/blog/small-team-ai-agents-playbook/index.html+++ b/docs/blog/small-team-ai-agents-playbook/index.html@@ -266,8 +266,8 @@ it’s free and open source.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/what-is-aeo-for-dev-tools/"><span class="k">← Older</span><span class="t">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</span></a>- <a class="pn next" href="/blog/scheduling-autonomous-agent-missions/"><span class="k">Newer →</span><span class="t">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</span></a>+ <a class="pn prev" href="/blog/the-office-parody-behind-munder-difflin/"><span class="k">← Older</span><span class="t">The Office Parody Behind Munder Difflin (and Why It Helps)</span></a>+ <a class="pn next" href="/blog/security-for-ai-coding-agents/"><span class="k">Newer →</span><span class="t">Security for AI Coding Agents: A Practical Guide</span></a></div><section class="related"><h2>Related in Guides</h2>@@ -291,38 +291,38 @@ it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/tags/automation/index.html b/docs/blog/tags/automation/index.htmlindex 79c78238..6034af49 100644--- a/docs/blog/tags/automation/index.html+++ b/docs/blog/tags/automation/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Automation</h1>- <p class="lead">5 posts tagged <strong>Automation</strong>.</p>+ <p class="lead">6 posts tagged <strong>Automation</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -116,6 +116,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/trigger-ai-agents-from-slack/">Trigger Your AI Agent Hive from Slack</a></h3>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/trigger-ai-agents-from-slack/" aria-label="Read: Trigger Your AI Agent Hive from Slack">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-internals" href="/blog/claude-code-hooks-explained/" aria-hidden="true" tabindex="-1"><span>INTERNALS</span>diff --git a/docs/blog/tags/autonomous/index.html b/docs/blog/tags/autonomous/index.htmlindex 2472cf7d..26a99726 100644--- a/docs/blog/tags/autonomous/index.html+++ b/docs/blog/tags/autonomous/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Autonomous</h1>- <p class="lead">3 posts tagged <strong>Autonomous</strong>.</p>+ <p class="lead">4 posts tagged <strong>Autonomous</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a>diff --git a/docs/blog/tags/brand/index.html b/docs/blog/tags/brand/index.htmlnew file mode 100644index 00000000..84397525--- /dev/null+++ b/docs/blog/tags/brand/index.html@@ -0,0 +1,124 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Brand — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Brand." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/brand/" />++<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="Brand — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Brand." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/brand/" />+<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="Brand — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Brand." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">+<header class="page-head wrap">+ <p class="eyebrow">Tag</p>+ <h1>#Brand</h1>+ <p class="lead">1 post tagged <strong>Brand</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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 35dd06a4..fa1525fc 100644--- a/docs/blog/tags/claude-code/index.html+++ b/docs/blog/tags/claude-code/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Claude Code</h1>- <p class="lead">31 posts tagged <strong>Claude Code</strong>.</p>+ <p class="lead">32 posts tagged <strong>Claude Code</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -260,6 +260,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/security-for-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/security-for-ai-coding-agents/">Security for AI Coding Agents: A Practical Guide</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/security-for-ai-coding-agents/" aria-label="Read: Security for AI Coding Agents: A Practical Guide">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/small-team-ai-agents-playbook/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>diff --git a/docs/blog/tags/error-handling/index.html b/docs/blog/tags/error-handling/index.htmlnew file mode 100644index 00000000..2e497e97--- /dev/null+++ b/docs/blog/tags/error-handling/index.html@@ -0,0 +1,124 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Error Handling — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Error Handling." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/error-handling/" />++<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="Error Handling — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Error Handling." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/error-handling/" />+<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="Error Handling — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Error Handling." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">+<header class="page-head wrap">+ <p class="eyebrow">Tag</p>+ <h1>#Error Handling</h1>+ <p class="lead">1 post tagged <strong>Error Handling</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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 d2ff48fa..1a8a9611 100644--- a/docs/blog/tags/guardrails/index.html+++ b/docs/blog/tags/guardrails/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Guardrails</h1>- <p class="lead">1 post tagged <strong>Guardrails</strong>.</p>+ <p class="lead">2 posts tagged <strong>Guardrails</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a>diff --git a/docs/blog/tags/guides/index.html b/docs/blog/tags/guides/index.htmlindex 71cc2dcd..053d4058 100644--- a/docs/blog/tags/guides/index.html+++ b/docs/blog/tags/guides/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Guides</h1>- <p class="lead">9 posts tagged <strong>Guides</strong>.</p>+ <p class="lead">11 posts tagged <strong>Guides</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -116,6 +116,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/security-for-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/security-for-ai-coding-agents/">Security for AI Coding Agents: A Practical Guide</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/security-for-ai-coding-agents/" aria-label="Read: Security for AI Coding Agents: A Practical Guide">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/small-team-ai-agents-playbook/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>@@ -134,6 +152,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/trigger-ai-agents-from-slack/">Trigger Your AI Agent Hive from Slack</a></h3>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/trigger-ai-agents-from-slack/" aria-label="Read: Trigger Your AI Agent Hive from Slack">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/mcp-and-skills-in-a-hive/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>diff --git a/docs/blog/tags/hive/index.html b/docs/blog/tags/hive/index.htmlindex 58bf70e6..c8fae5c6 100644--- a/docs/blog/tags/hive/index.html+++ b/docs/blog/tags/hive/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Hive</h1>- <p class="lead">2 posts tagged <strong>Hive</strong>.</p>+ <p class="lead">3 posts tagged <strong>Hive</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -98,6 +98,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/trigger-ai-agents-from-slack/">Trigger Your AI Agent Hive from Slack</a></h3>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/trigger-ai-agents-from-slack/" aria-label="Read: Trigger Your AI Agent Hive from Slack">Read →</a>+ </div>+ </div>+</article></div></section>diff --git a/docs/blog/tags/internals/index.html b/docs/blog/tags/internals/index.htmlindex 150a8076..bb916ac2 100644--- a/docs/blog/tags/internals/index.html+++ b/docs/blog/tags/internals/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Internals</h1>- <p class="lead">13 posts tagged <strong>Internals</strong>.</p>+ <p class="lead">15 posts tagged <strong>Internals</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1"><span>INTERNALS</span></a>@@ -80,6 +98,24 @@</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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">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>diff --git a/docs/blog/tags/multi-agent/index.html b/docs/blog/tags/multi-agent/index.htmlindex 62ed8690..0e35e881 100644--- a/docs/blog/tags/multi-agent/index.html+++ b/docs/blog/tags/multi-agent/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Multi-Agent</h1>- <p class="lead">41 posts tagged <strong>Multi-Agent</strong>.</p>+ <p class="lead">43 posts tagged <strong>Multi-Agent</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -98,6 +98,24 @@</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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span>@@ -332,6 +350,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/security-for-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/security-for-ai-coding-agents/">Security for AI Coding Agents: A Practical Guide</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/security-for-ai-coding-agents/" aria-label="Read: Security for AI Coding Agents: A Practical Guide">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/small-team-ai-agents-playbook/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>diff --git a/docs/blog/tags/munder-difflin/index.html b/docs/blog/tags/munder-difflin/index.htmlnew file mode 100644index 00000000..bbee3468--- /dev/null+++ b/docs/blog/tags/munder-difflin/index.html@@ -0,0 +1,124 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Munder Difflin — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Munder Difflin." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/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="website" />+<meta property="og:title" content="Munder Difflin — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Munder Difflin." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/munder-difflin/" />+<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="Munder Difflin — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged 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" />++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">+<header class="page-head wrap">+ <p class="eyebrow">Tag</p>+ <h1>#Munder Difflin</h1>+ <p class="lead">1 post tagged <strong>Munder Difflin</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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/reliability/index.html b/docs/blog/tags/reliability/index.htmlindex 31dfeaa0..4b9142f3 100644--- a/docs/blog/tags/reliability/index.html+++ b/docs/blog/tags/reliability/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Reliability</h1>- <p class="lead">1 post tagged <strong>Reliability</strong>.</p>+ <p class="lead">2 posts tagged <strong>Reliability</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a>diff --git a/docs/blog/tags/security/index.html b/docs/blog/tags/security/index.htmlnew file mode 100644index 00000000..8eba1310--- /dev/null+++ b/docs/blog/tags/security/index.html@@ -0,0 +1,142 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Security — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Security." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/security/" />++<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="Security — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Security." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/security/" />+<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="Security — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Security." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">+<header class="page-head wrap">+ <p class="eyebrow">Tag</p>+ <h1>#Security</h1>+ <p class="lead">2 posts tagged <strong>Security</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/security-for-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/security-for-ai-coding-agents/">Security for AI Coding Agents: A Practical Guide</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/security-for-ai-coding-agents/" aria-label="Read: Security for AI Coding Agents: A Practical Guide">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & node-pty</a>.+ Run an office of agents while you sleep.+ </div>+ </div>+</footer>++<script>+ // sticky-nav border on scroll+ (function () {+ var nav = document.getElementById('nav');+ if (!nav) return;+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });+ })();+</script>++</body>+</html>diff --git a/docs/blog/tags/slack/index.html b/docs/blog/tags/slack/index.htmlnew file mode 100644index 00000000..014d24d0--- /dev/null+++ b/docs/blog/tags/slack/index.html@@ -0,0 +1,124 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Slack — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Slack." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/slack/" />++<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="Slack — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Slack." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/slack/" />+<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="Slack — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Slack." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">+<header class="page-head wrap">+ <p class="eyebrow">Tag</p>+ <h1>#Slack</h1>+ <p class="lead">1 post tagged <strong>Slack</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/trigger-ai-agents-from-slack/">Trigger Your AI Agent Hive from Slack</a></h3>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/trigger-ai-agents-from-slack/" aria-label="Read: Trigger Your AI Agent Hive from Slack">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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/story/index.html b/docs/blog/tags/story/index.htmlindex e027906f..f05a818f 100644--- a/docs/blog/tags/story/index.html+++ b/docs/blog/tags/story/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Story</h1>- <p class="lead">2 posts tagged <strong>Story</strong>.</p>+ <p class="lead">3 posts tagged <strong>Story</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/tags/the-office/index.html b/docs/blog/tags/the-office/index.htmlnew file mode 100644index 00000000..3544e854--- /dev/null+++ b/docs/blog/tags/the-office/index.html@@ -0,0 +1,124 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>The Office — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged The Office." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/the-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="website" />+<meta property="og:title" content="The Office — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged The Office." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/the-office/" />+<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="The Office — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged The Office." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">+<header class="page-head wrap">+ <p class="eyebrow">Tag</p>+ <h1>#The Office</h1>+ <p class="lead">1 post tagged <strong>The Office</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>++ </div>+</section>+++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & node-pty</a>.+ Run an office of agents while you sleep.+ </div>+ </div>+</footer>++<script>+ // sticky-nav border on scroll+ (function () {+ var nav = document.getElementById('nav');+ if (!nav) return;+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });+ })();+</script>++</body>+</html>diff --git a/docs/blog/the-office-parody-behind-munder-difflin/index.html b/docs/blog/the-office-parody-behind-munder-difflin/index.htmlnew file mode 100644index 00000000..d6ad92ea--- /dev/null+++ b/docs/blog/the-office-parody-behind-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>The Office Parody Behind Munder Difflin (and Why It Helps) — Munder Difflin Blog</title>+<meta name="description" content="Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust." />+<link rel="canonical" href="https://munderdiffl.in/blog/the-office-parody-behind-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="The Office Parody Behind Munder Difflin (and Why It Helps) — Munder Difflin Blog" />+<meta property="og:description" content="Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust." />+<meta property="og:url" content="https://munderdiffl.in/blog/the-office-parody-behind-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-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Story" />+<meta property="article:tag" content="Brand" />+<meta property="article:tag" content="The Office" />+<meta property="article:tag" content="Munder Difflin" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="The Office Parody Behind Munder Difflin (and Why It Helps) — Munder Difflin Blog" />+<meta name="twitter:description" content="Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust." />+<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 Office Parody Behind Munder Difflin (and Why It Helps)",+ "description": "Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-06-04T00:00:00.000Z",+ "dateModified": "2026-06-04T00:00:00.000Z",+ "author": { "@type": "Person", "name": "Chaitanya Giri" },+ "publisher": {+ "@type": "Organization",+ "name": "Munder Difflin",+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }+ },+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/the-office-parody-behind-munder-difflin/" },+ "keywords": "munder difflin, munder difflin app, munder difflin claude code, the office ai agents",+ "articleSection": "Story",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/the-office-parody-behind-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": "The Office Parody Behind Munder Difflin (and Why It Helps)", "item": "https://munderdiffl.in/blog/the-office-parody-behind-munder-difflin/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Why is it called Munder Difflin?", "acceptedAnswer": { "@type": "Answer", "text": "It's an affectionate parody of Dunder Mifflin, the fictional paper company from The Office. The tagline says it best: 'the world's best agents, the world's worst paper company.' The joke also does real work — an office is the most intuitive way to picture a team of AI agents coordinating." } },+ { "@type": "Question", "name": "Are the agents really named after The Office characters?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The avatars are the cast of The Office, each differentiated by its own look, working at desks on a visual office floor — with Michael running the room as the orchestrator." } },+ { "@type": "Question", "name": "Is Munder Difflin affiliated with The Office or NBC?", "acceptedAnswer": { "@type": "Answer", "text": "No. It's an affectionate, unaffiliated parody — not associated with NBC's The Office or Dunder Mifflin. The homage is a tribute, not a partnership." } },+ { "@type": "Question", "name": "Is the parody just a gimmick?", "acceptedAnswer": { "@type": "Answer", "text": "No — the office metaphor is a teaching tool. Organizations already solved how many workers coordinate (roles, a manager who routes work, mailboxes, shared knowledge), so mapping a multi-agent system onto an office makes it instantly legible." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/story/">Story</a>+ </nav>+ <h1>The Office Parody Behind Munder Difflin (and Why It Helps)</h1>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true">·</span>+ <span>4 min read</span>+ <span class="tag kind">Story</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin</strong> is a loving+parody of <em>Dunder Mifflin</em> from <em>The Office</em> — "the world's best agents, the world's+worst paper company." But the joke isn't only a joke. An <strong>office</strong> is the most intuitive+mental model humans have for "a group of workers coordinating toward a goal," which is exactly what a+hive of AI agents is. So the metaphor does real work: it makes an otherwise abstract multi-agent system+something you can <em>see</em>, reason about, and trust at a glance.</p></div>+<p>Plenty of AI tools take themselves very seriously. Munder Difflin opens with a paper-company pun. That’s+a deliberate choice, and it goes deeper than a punchline — the parody is also the product’s best+explanation of itself. Here’s the story behind the name, and why a sitcom about a failing paper company+turned out to be the perfect frame for a serious piece of agent infrastructure.</p>+<h2 id="the-joke-briefly" tabindex="-1">The joke, briefly <a class="anchor" href="#the-joke-briefly" aria-hidden="true">#</a></h2>+<p><a href="/">Munder Difflin</a> is an <a href="/#what">open-source multi-agent harness</a> for Claude Code — and it’s dressed+as a parody of <em>Dunder Mifflin</em>, the fictional paper company from <em>The Office</em>. The tagline sets the+tone: <strong>“The world’s best agents. The world’s worst paper company.”</strong> The avatars are the show’s cast,+each with its own look, working at desks on a visual office floor rendered in a friendly pixel+aesthetic with a Dunder-Mifflin-maroon-and-gold coat of paint. (To be clear up front: it’s an+<em>affectionate, unaffiliated parody</em> — not associated with NBC’s <em>The Office</em> or Dunder Mifflin.)</p>+<p>It would be easy to read all of that as set dressing. It isn’t. The metaphor was chosen because it+<em>teaches</em>.</p>+<h2 id="why-an-office-is-the-right-metaphor-for-a-hive" tabindex="-1">Why an office is the right metaphor for a hive <a class="anchor" href="#why-an-office-is-the-right-metaphor-for-a-hive" aria-hidden="true">#</a></h2>+<p>Here’s the quiet insight: humanity has spent a century refining an answer to the question “how do a+bunch of workers coordinate to get things done without stepping on each other?” The answer is an+<strong>office</strong> — and a multi-agent AI system needs to solve the exact same problem. So the office isn’t a+costume on top of the tech; it’s a one-to-one map of it:</p>+<ul>+<li><strong>A manager who routes work.</strong> Every office has someone deciding who does what. In a hive, that’s the+<a href="/blog/how-the-god-orchestrator-works/">orchestrator</a> — and naturally, it’s <em>Michael</em> running the+room, the control surface the whole floor reports through.</li>+<li><strong>Specialists at their desks.</strong> An office is a set of people with roles. A hive is a set of agents+with roles. “Give that to the researcher” and “give that to Dwight” are the same instruction.</li>+<li><strong>Mailboxes and memos.</strong> Coworkers pass notes and messages instead of interrupting the boss for+everything. Agents pass <a href="/blog/atomic-file-mailboxes-for-agents/">messages through inboxes</a> the same+way.</li>+<li><strong>Institutional knowledge.</strong> A good office <em>remembers</em> — nobody re-explains last quarter’s decision+every morning. A hive remembers through <a href="/blog/semantic-memory-for-ai-agents/">shared memory</a>.</li>+<li><strong>A place you can walk through.</strong> You can glance across an office and see who’s busy, who’s blocked,+who’s at the coffee machine. That’s observability — and it’s why the floor is something you+<a href="/blog/run-an-office-of-ai-agents/">actually watch</a>.</li>+</ul>+<p>When a new user opens the app and sees an office with a boss, desks, and workers passing notes, they+already understand the architecture — because they’ve worked in (or watched a show about) exactly that+structure. The metaphor pre-loads the mental model so the documentation doesn’t have to.</p>+<h2 id="how-the-bit-shows-up-in-the-product" tabindex="-1">How the bit shows up in the product <a class="anchor" href="#how-the-bit-shows-up-in-the-product" aria-hidden="true">#</a></h2>+<p>The parody isn’t skin-deep; it’s wired through the real software:</p>+<ul>+<li><strong>Michael’s control surface.</strong> The command center you drive the hive from is literally framed as+Michael’s office — the one room everything routes through.</li>+<li><strong>A living office floor.</strong> A Pixi.js scene renders the cast as avatars at desks, walking the floor+with real pathfinding, carrying messages between coworkers. It’s <a href="/blog/building-an-ai-office-floor/">a developer tool you can watch like+a room</a>, not a wall of logs.</li>+<li><strong>The cast as your team.</strong> The avatars are the show’s ensemble, each visually distinct, so “who’s+doing what” reads at a glance instead of as a list of process IDs.</li>+<li><strong>The little touches.</strong> Idle agents wander off for coffee. The brand wears Dunder-Mifflin maroon and+gold. None of it is required to run agents — all of it makes running them feel like managing a team+instead of babysitting a script.</li>+</ul>+<h2 id="why-playful-beats-po-faced-here" tabindex="-1">Why playful beats po-faced here <a class="anchor" href="#why-playful-beats-po-faced-here" aria-hidden="true">#</a></h2>+<p>There’s a real argument that the humor is a <em>feature</em>, not a distraction:</p>+<ol>+<li><strong>It lowers the intimidation.</strong> “Autonomous AI agents editing my codebase” is a slightly scary+sentence. “A little office of workers I can watch and approve” is not. The frame makes a powerful+system approachable without dumbing it down.</li>+<li><strong>Named characters are memorable and assignable.</strong> It’s easier to think about — and delegate to — a+<em>cast</em> than a pool of anonymous workers. A name is a handle.</li>+<li><strong>Watching a familiar room builds trust.</strong> <a href="/blog/run-an-office-of-ai-agents/">Seeing the work happen</a>+in a layout your intuition already parses is reassurance you can’t get from a terminal scroll.</li>+<li><strong>Self-aware confidence.</strong> In a space thick with breathless hype, a tool willing to call itself “the+world’s worst paper company” is signaling that it would rather show you the work than oversell it.</li>+</ol>+<p>The serious version of multi-agent coordination and the funny version turn out to be the same diagram.+The parody just makes the diagram delightful.</p>+<h2 id="the-honest-footnote" tabindex="-1">The honest footnote <a class="anchor" href="#the-honest-footnote" aria-hidden="true">#</a></h2>+<p>It’s a tribute, made with affection and not a small amount of respect for the source material. <em>Munder+Difflin</em> is an affectionate parody and is *<em>not affiliated with NBC’s <em>The Office</em> or Dunder Mifflin</em> —+the homage is the whole point, and the credit belongs to the show that made an office feel like a+family. Under the costume is a real, <a href="/blog/why-we-built-munder-difflin/">MIT-licensed multi-agent harness</a>;+the bit is how we make it make sense.</p>+<hr>+<p>Come meet the team. <a href="/#install">Download Munder Difflin</a> to run your own office of Claude Code agents —+Michael’s already at his desk. Free and open source.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Why is it called Munder Difflin?</p>+ <p class="a">It's an affectionate parody of Dunder Mifflin, the fictional paper company from The Office. The tagline says it best: 'the world's best agents, the world's worst paper company.' The joke also does real work — an office is the most intuitive way to picture a team of AI agents coordinating.</p>+ </div>++ <div class="qa">+ <p class="q">Are the agents really named after The Office characters?</p>+ <p class="a">Yes. The avatars are the cast of The Office, each differentiated by its own look, working at desks on a visual office floor — with Michael running the room as the orchestrator.</p>+ </div>++ <div class="qa">+ <p class="q">Is Munder Difflin affiliated with The Office or NBC?</p>+ <p class="a">No. It's an affectionate, unaffiliated parody — not associated with NBC's The Office or Dunder Mifflin. The homage is a tribute, not a partnership.</p>+ </div>++ <div class="qa">+ <p class="q">Is the parody just a gimmick?</p>+ <p class="a">No — the office metaphor is a teaching tool. Organizations already solved how many workers coordinate (roles, a manager who routes work, mailboxes, shared knowledge), so mapping a multi-agent system onto an office makes it instantly legible.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/story/">Story</a><a class="tag" href="/blog/tags/brand/">Brand</a><a class="tag" href="/blog/tags/the-office/">The Office</a><a class="tag" href="/blog/tags/munder-difflin/">Munder Difflin</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-joke-briefly">The joke, briefly</a></li><li class="lvl-2"><a href="#why-an-office-is-the-right-metaphor-for-a-hive">Why an office is the right metaphor for a hive</a></li><li class="lvl-2"><a href="#how-the-bit-shows-up-in-the-product">How the bit shows up in the product</a></li><li class="lvl-2"><a href="#why-playful-beats-po-faced-here">Why playful beats po-faced here</a></li><li class="lvl-2"><a href="#the-honest-footnote">The honest footnote</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/trigger-ai-agents-from-slack/"><span class="k">← Older</span><span class="t">Trigger Your AI Agent Hive from Slack</span></a>+ <a class="pn next" href="/blog/small-team-ai-agents-playbook/"><span class="k">Newer →</span><span class="t">A Small-Team Playbook for AI Coding Agents</span></a>+ </div>+ <section class="related">+ <h2>Related in Story</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-story" href="/blog/why-we-built-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-02">Jun 2, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>3 min</span>+ </div>+ <h3><a href="/blog/why-we-built-munder-difflin/">Why We Built Munder Difflin</a></h3>+ <p class="dek">The origin story of Munder Difflin — how the pain of juggling Claude Code terminals led to a coordinated, memory-backed hive of agents you can watch.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/why-we-built-munder-difflin/" aria-label="Read: Why We Built Munder Difflin">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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 9911af43..60d58211 100644--- a/docs/blog/topics/comparisons/index.html+++ b/docs/blog/topics/comparisons/index.html@@ -68,7 +68,7 @@<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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.htmlindex 858c3c69..564d104d 100644--- a/docs/blog/topics/concepts/index.html+++ b/docs/blog/topics/concepts/index.html@@ -68,7 +68,7 @@<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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>diff --git a/docs/blog/topics/guides/index.html b/docs/blog/topics/guides/index.htmlindex bac9cef4..da3effd4 100644--- a/docs/blog/topics/guides/index.html+++ b/docs/blog/topics/guides/index.html@@ -63,12 +63,12 @@</nav><p class="eyebrow">Topic</p><h1>guides</h1>- <p class="lead">13 posts in this cluster.</p>+ <p class="lead">17 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">13</span></a>+ <a class="chip" href="/blog/topics/guides/" aria-current="page">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>@@ -107,6 +107,42 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>@@ -197,6 +233,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/security-for-ai-coding-agents/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/security-for-ai-coding-agents/">Security for AI Coding Agents: A Practical Guide</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/security-for-ai-coding-agents/" aria-label="Read: Security for AI Coding Agents: A Practical Guide">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/small-team-ai-agents-playbook/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>@@ -215,6 +269,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/trigger-ai-agents-from-slack/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/trigger-ai-agents-from-slack/">Trigger Your AI Agent Hive from Slack</a></h3>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/trigger-ai-agents-from-slack/" aria-label="Read: Trigger Your AI Agent Hive from Slack">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-guides" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-hidden="true" tabindex="-1"><span>GUIDES</span>diff --git a/docs/blog/topics/index.html b/docs/blog/topics/index.htmlindex 2ae0aa61..ebffb7ed 100644--- a/docs/blog/topics/index.html+++ b/docs/blog/topics/index.html@@ -70,7 +70,7 @@<span class="thumb t-guides" aria-hidden="true">GUIDES</span><div class="body"><h3 style="color:var(--ink)">guides</h3>- <p class="dek">13 posts.</p>+ <p class="dek">17 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -133,7 +133,7 @@<span class="thumb t-story" aria-hidden="true">STORY</span><div class="body"><h3 style="color:var(--ink)">story</h3>- <p class="dek">1 post.</p>+ <p class="dek">2 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -144,15 +144,15 @@<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">41</span></a>+ <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">43</span></a>- <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">31</span></a>+ <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">32</span></a>- <a class="chip" href="/blog/tags/internals/">Internals<span class="ct">13</span></a>+ <a class="chip" href="/blog/tags/internals/">Internals<span class="ct">15</span></a><a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">12</span></a>- <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">9</span></a>+ <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">11</span></a><a class="chip" href="/blog/tags/comparisons/">Comparisons<span class="ct">8</span></a>@@ -164,29 +164,33 @@<a class="chip" href="/blog/tags/memory/">Memory<span class="ct">7</span></a>- <a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">5</span></a>+ <a class="chip" href="/blog/tags/automation/">Automation<span class="ct">6</span></a>- <a class="chip" href="/blog/tags/automation/">Automation<span class="ct">5</span></a>+ <a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">5</span></a><a class="chip" href="/blog/tags/use-cases/">Use Cases<span class="ct">4</span></a>+ <a class="chip" href="/blog/tags/autonomous/">Autonomous<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/observability/">Observability<span class="ct">3</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/story/">Story<span class="ct">3</span></a>+<a class="chip" href="/blog/tags/local-first/">Local-First<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/electron/">Electron<span class="ct">3</span></a>- <a class="chip" href="/blog/tags/autonomous/">Autonomous<span class="ct">3</span></a>+ <a class="chip" href="/blog/tags/hive/">Hive<span class="ct">3</span></a><a class="chip" href="/blog/tags/god/">GOD<span class="ct">2</span></a>- <a class="chip" href="/blog/tags/story/">Story<span class="ct">2</span></a>+ <a class="chip" href="/blog/tags/guardrails/">Guardrails<span class="ct">2</span></a><a class="chip" href="/blog/tags/git/">Git<span class="ct">2</span></a>@@ -200,9 +204,11 @@<a class="chip" href="/blog/tags/performance/">Performance<span class="ct">2</span></a>- <a class="chip" href="/blog/tags/cost/">Cost<span class="ct">2</span></a>+ <a class="chip" href="/blog/tags/security/">Security<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/hive/">Hive<span class="ct">2</span></a>+ <a class="chip" href="/blog/tags/cost/">Cost<span class="ct">2</span></a><a class="chip" href="/blog/tags/subagents/">Subagents<span class="ct">1</span></a>@@ -216,8 +222,6 @@<a class="chip" href="/blog/tags/glossary/">Glossary<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/guardrails/">Guardrails<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/faq/">FAQ<span class="ct">1</span></a><a class="chip" href="/blog/tags/concurrency/">Concurrency<span class="ct">1</span></a>@@ -236,18 +240,26 @@<a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">1</span></a>+ <a class="chip" href="/blog/tags/error-handling/">Error Handling<span class="ct">1</span></a>+<a class="chip" href="/blog/tags/context-engineering/">Context Engineering<span class="ct">1</span></a><a class="chip" href="/blog/tags/debugging/">Debugging<span class="ct">1</span></a><a class="chip" href="/blog/tags/model-routing/">Model Routing<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/reliability/">Reliability<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/trust/">Trust<span class="ct">1</span></a><a class="chip" href="/blog/tags/prompt-caching/">Prompt Caching<span class="ct">1</span></a>+ <a class="chip" href="/blog/tags/brand/">Brand<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/the-office/">The Office<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/munder-difflin/">Munder Difflin<span class="ct">1</span></a>++ <a class="chip" href="/blog/tags/slack/">Slack<span class="ct">1</span></a>+<a class="chip" href="/blog/tags/aeo/">AEO<span class="ct">1</span></a><a class="chip" href="/blog/tags/seo/">SEO<span class="ct">1</span></a>diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.htmlindex 0d29ae3d..85657acb 100644--- a/docs/blog/topics/internals/index.html+++ b/docs/blog/topics/internals/index.html@@ -68,7 +68,7 @@<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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.htmlindex bf13ef58..4865093d 100644--- a/docs/blog/topics/memory/index.html+++ b/docs/blog/topics/memory/index.html@@ -68,7 +68,7 @@<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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.htmlindex b1e4d3c6..b8e887e1 100644--- a/docs/blog/topics/orchestration/index.html+++ b/docs/blog/topics/orchestration/index.html@@ -68,7 +68,7 @@<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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.htmlindex 5f236dd9..e37f771c 100644--- a/docs/blog/topics/story/index.html+++ b/docs/blog/topics/story/index.html@@ -63,12 +63,12 @@</nav><p class="eyebrow">Topic</p><h1>story</h1>- <p class="lead">1 post in this cluster.</p>+ <p class="lead">2 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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">2</span></a></div></header>@@ -90,6 +90,24 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-story" href="/blog/why-we-built-munder-difflin/" aria-hidden="true" tabindex="-1"><span>STORY</span></a>diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.htmlindex 67399905..e301f59b 100644--- a/docs/blog/topics/use-cases/index.html+++ b/docs/blog/topics/use-cases/index.html@@ -68,7 +68,7 @@<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">13</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">17</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>@@ -82,7 +82,7 @@<a class="chip" href="/blog/topics/use-cases/" aria-current="page">use-cases<span class="ct">4</span></a>- <a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>+ <a class="chip" href="/blog/topics/story/">story<span class="ct">2</span></a></div></header>diff --git a/docs/blog/trigger-ai-agents-from-slack/index.html b/docs/blog/trigger-ai-agents-from-slack/index.htmlnew file mode 100644index 00000000..4a90af40--- /dev/null+++ b/docs/blog/trigger-ai-agents-from-slack/index.html@@ -0,0 +1,367 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Trigger Your AI Agent Hive from Slack — Munder Difflin Blog</title>+<meta name="description" content="Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host." />+<link rel="canonical" href="https://munderdiffl.in/blog/trigger-ai-agents-from-slack/" />++<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="Trigger Your AI Agent Hive from Slack — Munder Difflin Blog" />+<meta property="og:description" content="Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host." />+<meta property="og:url" content="https://munderdiffl.in/blog/trigger-ai-agents-from-slack/" />+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />+<meta property="og:locale" content="en_US" />+<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Guides" />+<meta property="article:tag" content="Automation" />+<meta property="article:tag" content="Slack" />+<meta property="article:tag" content="Hive" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Trigger Your AI Agent Hive from Slack — Munder Difflin Blog" />+<meta name="twitter:description" content="Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "BlogPosting",+ "headline": "Trigger Your AI Agent Hive from Slack",+ "description": "Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.",+ "image": ["https://munderdiffl.in/media/og.png"],+ "datePublished": "2026-06-04T00:00:00.000Z",+ "dateModified": "2026-06-04T00:00:00.000Z",+ "author": { "@type": "Person", "name": "Chaitanya Giri" },+ "publisher": {+ "@type": "Organization",+ "name": "Munder Difflin",+ "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }+ },+ "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/trigger-ai-agents-from-slack/" },+ "keywords": "trigger ai agents from slack, slack ai agent integration, slack webhook ai agents, drive agents from chat",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/trigger-ai-agents-from-slack/"+}+</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": "Trigger Your AI Agent Hive from Slack", "item": "https://munderdiffl.in/blog/trigger-ai-agents-from-slack/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Can you trigger AI agents from Slack?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Munder Difflin can run a small local webhook that listens to a Slack channel and turns each message into a task in the orchestrator's queue. You type in Slack, and an agent picks the work up — without opening the app or sitting at your machine." } },+ { "@type": "Question", "name": "Is a Slack-to-agent webhook secure?", "acceptedAnswer": { "@type": "Answer", "text": "It's built to be. Every request is verified with an HMAC over the raw body using your Slack signing secret, compared in constant time, with a five-minute replay-timestamp guard and a body-size cap checked before anything else. Anything that fails gets a 403. The local handler is the security boundary, not the public tunnel." } },+ { "@type": "Question", "name": "Do I need to host a public server to trigger agents from Slack?", "acceptedAnswer": { "@type": "Answer", "text": "No. The webhook runs on your own machine. A best-effort local tunnel gives Slack a public URL to reach that local port, so there's nothing to deploy or keep online — and if the tunnel can't start, your local handler still runs." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/guides/">Guides</a>+ </nav>+ <h1>Trigger Your AI Agent Hive from Slack</h1>+ <p class="dek">Trigger an AI agent hive from Slack: a local webhook verifies each message and drops it into your orchestrator's queue as a task — no server to host.</p>+ <div class="byline">+ <span class="av" aria-hidden="true">CG</span>+ <strong>Chaitanya Giri</strong>+ <span class="dot" aria-hidden="true">·</span>+ <time datetime="2026-06-04">Jun 4, 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>Munder Difflin v0.1.7 can <strong>trigger your+agent hive from Slack</strong>: a tiny local webhook listens to a channel, <strong>verifies every+request</strong> with your Slack signing secret (HMAC + replay guard, 403 on anything suspicious), and+drops the message into the orchestrator's queue as a task. The server runs <em>on your machine</em>; a+best-effort tunnel just gives Slack a doorbell to ring. You get a remote trigger for a local-first hive+— start work from your phone, no servers to host.</p></div>+<p>Most of the time you drive your agents from the app. But sometimes the work starts somewhere else — a+teammate drops a request in a channel, or you’re away from your desk and want to kick off a long run+from your phone. Munder Difflin’s Slack integration (shipped in v0.1.7) closes that gap: a message in a+watched Slack channel becomes a task in your hive’s queue. Here’s how it works, and why it stays true+to a local-first design.</p>+<h2 id="what-trigger-from-slack-actually-does" tabindex="-1">What “trigger from Slack” actually does <a class="anchor" href="#what-trigger-from-slack-actually-does" aria-hidden="true">#</a></h2>+<p>The flow is one sentence: a message in a Slack channel you’ve connected becomes an item in+<a href="/blog/how-the-god-orchestrator-works/">the orchestrator’s</a> queue, exactly like a task you’d type+yourself. The orchestrator then triages and routes it to the right agent like any other piece of work.</p>+<p>It’s worth naming the direction. This is <strong>inbound</strong> — the outside world asking your hive to <em>do</em>+something. It’s the mirror image of <a href="/blog/human-in-the-loop-approving-ai-agents/">human-in-the-loop+approvals</a>, where an agent reaches <em>out</em> to a person for a+decision. One is how you start work remotely; the other is how agents check with you mid-run. Together+they let a hive run while you’re not at the keyboard.</p>+<h2 id="the-architecture-a-tiny-local-webhook" tabindex="-1">The architecture: a tiny local webhook <a class="anchor" href="#the-architecture-a-tiny-local-webhook" aria-hidden="true">#</a></h2>+<p>The integration is deliberately small. There’s no <code>@slack/bolt</code>, no framework — just a bare+<code>node:http</code> server running inside the app’s main process that implements <em>only</em> the slice of Slack’s+Events API it needs. It does three things: answer Slack’s one-time <code>url_verification</code> handshake, verify+incoming events, and hand the accepted message text to the app.</p>+<p>Because the server lives on your machine, Slack needs a way to reach it. The integration opens a+best-effort <strong>local tunnel</strong> and hands you a public URL to paste into your Slack app’s <em>Event+Subscriptions → Request URL</em>. That tunnel is just a doorbell: it forwards Slack’s POSTs to your local+port. If it can’t be established, the local handler stays up anyway — the tunnel is a convenience, not+the security boundary.</p>+<h2 id="security-verify-everything-before-you-trust-it" tabindex="-1">Security: verify everything before you trust it <a class="anchor" href="#security-verify-everything-before-you-trust-it" aria-hidden="true">#</a></h2>+<p>A webhook that can enqueue work for autonomous agents is exactly the kind of endpoint you don’t want+strangers poking. So the handler treats every request as hostile until proven otherwise:</p>+<ul>+<li><strong>Signature check.</strong> Each request is verified with an <strong>HMAC</strong> over the <em>raw</em> body, keyed by your+Slack <strong>signing secret</strong>, and compared in <strong>constant time</strong> (so a wrong guess leaks no timing+information). No valid signature, no entry.</li>+<li><strong>Replay guard.</strong> Slack stamps each request with a timestamp; anything more than <strong>five minutes</strong> off+is rejected, so a captured request can’t be replayed later.</li>+<li><strong>Size cap first.</strong> The body is capped (1 MB) <em>before</em> the signature is computed, so an+unauthenticated peer can’t force unbounded memory use just by sending a huge payload.</li>+<li><strong>Fail closed.</strong> Any failure — bad signature, stale timestamp, oversized body — returns a flat+<strong>403</strong>. There’s no partial trust.</li>+</ul>+<p>The secret itself stays local and is never logged. The principle is the one every trust boundary should+follow: authenticate at the edge, fail closed, and keep the verification cheap and constant-time.</p>+<h2 id="from-slack-message-to-agent-task" tabindex="-1">From Slack message to agent task <a class="anchor" href="#from-slack-message-to-agent-task" aria-hidden="true">#</a></h2>+<p>Once a <code>message</code> event passes verification, the handler does something refreshingly boring: it strips a+leading bot mention from the text and hands the clean string to the app, which drops it into+<strong>Michael’s queue</strong> — the orchestrator’s inbox. From there it’s just another task: the orchestrator+reads it, decides who should handle it, and dispatches, the same way it handles work that arrives+through <a href="/blog/coordinating-ai-coding-agents/">the hive’s normal message routing</a>.</p>+<p>You can scope what counts, too. An optional <strong>channel filter</strong> means only messages from one specific+channel are accepted; events from anywhere else are dropped before they ever reach the queue. That+keeps a noisy workspace from turning into a noisy hive.</p>+<h2 id="setting-it-up" tabindex="-1">Setting it up <a class="anchor" href="#setting-it-up" aria-hidden="true">#</a></h2>+<p>The moving parts are minimal. In the app you enable Slack and paste your <strong>signing secret</strong> (from your+Slack app’s <em>Basic Information</em>). Optionally set a <strong>channel id</strong> to listen to just one channel, and a+<strong>port</strong> if 3847 (the default) is taken. Start it, copy the tunnel URL into Slack’s <em>Event+Subscriptions → Request URL</em>, and Slack’s verification handshake confirms the connection. After that,+messages in the channel flow straight into your queue.</p>+<h2 id="why-this-fits-a-local-first-hive" tabindex="-1">Why this fits a local-first hive <a class="anchor" href="#why-this-fits-a-local-first-hive" aria-hidden="true">#</a></h2>+<p>It would have been easier to host this in a cloud function. Doing it as a local webhook is the point.+Your agents, their memory, and their git history never leave your machine — Slack is only a <em>trigger</em>,+a thin remote surface for starting and watching work. There’s nothing to deploy, nothing to pay for,+and no third party sitting in the path between a message and your code. It’s the same philosophy behind+<a href="/blog/local-first-ai-agent-orchestration/">local-first orchestration</a>: keep the control plane on your+box, and let the outside world knock politely at the door.</p>+<p>Pair it with <a href="/blog/scheduling-autonomous-agent-missions/">scheduled missions</a> and the picture rounds+out: timers put recurring work into the queue, Slack puts ad-hoc work into the queue, and the+orchestrator runs both — whether or not you’re watching.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>Can you trigger AI agents from Slack?</strong> Yes — a local webhook listens to a channel and turns each+message into a task in the orchestrator’s queue, so an agent picks up the work without you opening the+app.</p>+<p><strong>Is the Slack webhook secure?</strong> Every request is HMAC-verified against your signing secret in constant+time, with a five-minute replay guard and a body-size cap checked first; anything suspicious gets a 403,+and the secret is never logged.</p>+<p><strong>Do I need a public server?</strong> No. The webhook runs locally and a best-effort tunnel gives Slack a URL+to reach it — nothing to host, and the local handler runs even if the tunnel doesn’t.</p>+<hr>+<p>Munder Difflin turns a Slack channel into a remote control for a hive that still lives entirely on your+machine — <a href="https://munderdiffl.in/#how">orchestrated by GOD</a>, verified at the edge, queued like any+other task. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to drive your agents from chat;+it’s free and open source.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Can you trigger AI agents from Slack?</p>+ <p class="a">Yes. Munder Difflin can run a small local webhook that listens to a Slack channel and turns each message into a task in the orchestrator's queue. You type in Slack, and an agent picks the work up — without opening the app or sitting at your machine.</p>+ </div>++ <div class="qa">+ <p class="q">Is a Slack-to-agent webhook secure?</p>+ <p class="a">It's built to be. Every request is verified with an HMAC over the raw body using your Slack signing secret, compared in constant time, with a five-minute replay-timestamp guard and a body-size cap checked before anything else. Anything that fails gets a 403. The local handler is the security boundary, not the public tunnel.</p>+ </div>++ <div class="qa">+ <p class="q">Do I need to host a public server to trigger agents from Slack?</p>+ <p class="a">No. The webhook runs on your own machine. A best-effort local tunnel gives Slack a public URL to reach that local port, so there's nothing to deploy or keep online — and if the tunnel can't start, your local handler still runs.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/guides/">Guides</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/slack/">Slack</a><a class="tag" href="/blog/tags/hive/">Hive</a>+ </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-trigger-from-slack-actually-does">What “trigger from Slack” actually does</a></li><li class="lvl-2"><a href="#the-architecture-a-tiny-local-webhook">The architecture: a tiny local webhook</a></li><li class="lvl-2"><a href="#security-verify-everything-before-you-trust-it">Security: verify everything before you trust it</a></li><li class="lvl-2"><a href="#from-slack-message-to-agent-task">From Slack message to agent task</a></li><li class="lvl-2"><a href="#setting-it-up">Setting it up</a></li><li class="lvl-2"><a href="#why-this-fits-a-local-first-hive">Why this fits a local-first hive</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/what-is-aeo-for-dev-tools/"><span class="k">← Older</span><span class="t">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</span></a>+ <a class="pn next" href="/blog/the-office-parody-behind-munder-difflin/"><span class="k">Newer →</span><span class="t">The Office Parody Behind Munder Difflin (and Why It Helps)</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/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>+<article class="card">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1">+ <span>GUIDES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>++ </footer>+</article>++</main>+<footer>+ <div class="wrap">+ <div class="foot-top">+ <a class="foot-brand brand" href="/blog/">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <div class="foot-links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>+ </div>+ </div>+ <div class="foot-meta">+ © 2026 Munder Difflin · Local-first · MIT-licensed ·+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & 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-aeo-for-dev-tools/index.html b/docs/blog/what-is-aeo-for-dev-tools/index.htmlindex 54009e0a..512f6d36 100644--- a/docs/blog/what-is-aeo-for-dev-tools/index.html+++ b/docs/blog/what-is-aeo-for-dev-tools/index.html@@ -361,7 +361,7 @@ harness actually is</a>. Free and MIT-licensed.</p><footer class="post-foot wrap"><div class="prevnext"><a class="pn prev" href="/blog/whats-new-in-agentic-ai-june-2026/"><span class="k">← Older</span><span class="t">What's New in Agentic AI: A June 2026 Field Guide</span></a>- <a class="pn next" href="/blog/small-team-ai-agents-playbook/"><span class="k">Newer →</span><span class="t">A Small-Team Playbook for AI Coding Agents</span></a>+ <a class="pn next" href="/blog/trigger-ai-agents-from-slack/"><span class="k">Newer →</span><span class="t">Trigger Your AI Agent Hive from Slack</span></a></div><section class="related"><h2>Related in Concepts</h2>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 1a5c3339..fc45155b 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@@ -344,38 +344,38 @@ hive run; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/agent-security-and-sandboxing/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/claude-code-automation-while-you-sleep/">Claude Code Automation: Let Agents Build While You Sleep</a></h3>- <p class="dek">Claude Code automation that runs overnight: an autonomous Stop-hook loop, safe permission bypass, and guardrails so you wake up to progress, not chaos.</p>+ <h3><a href="/blog/agent-security-and-sandboxing/">Running AI Agents Safely: Permission Modes and Sandboxing</a></h3>+ <p class="dek">How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/claude-code-automation-while-you-sleep/" aria-label="Read: Claude Code Automation: Let Agents Build While You Sleep">Read →</a>+ <a class="more" href="/blog/agent-security-and-sandboxing/" aria-label="Read: Running AI Agents Safely: Permission Modes and Sandboxing">Read →</a></div></div></article><article class="card">- <a class="thumb t-guides" href="/blog/context-engineering-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-guides" href="/blog/building-reliable-ai-agents/" aria-hidden="true" tabindex="-1"><span>GUIDES</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/context-engineering-for-ai-agents/">Context Engineering for AI Agents: Budgeting the Window</a></h3>- <p class="dek">Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</p>+ <h3><a href="/blog/building-reliable-ai-agents/">Building Reliable AI Agents: Failure Is the Default</a></h3>+ <p class="dek">Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.</p><div class="foot"><span class="tag kind">Guides</span>- <a class="more" href="/blog/context-engineering-for-ai-agents/" aria-label="Read: Context Engineering for AI Agents: Budgeting the Window">Read →</a>+ <a class="more" href="/blog/building-reliable-ai-agents/" aria-label="Read: Building Reliable AI Agents: Failure Is the Default">Read →</a></div></div></article>diff --git a/docs/blog/why-we-built-munder-difflin/index.html b/docs/blog/why-we-built-munder-difflin/index.htmlindex f1cb2bae..a5038bd6 100644--- a/docs/blog/why-we-built-munder-difflin/index.html+++ b/docs/blog/why-we-built-munder-difflin/index.html@@ -207,6 +207,31 @@ Munder Difflin</a> — it’s open source and local-first, on macOS, Windows, an<a class="pn prev" href="/blog/append-only-event-log-agents/"><span class="k">← Older</span><span class="t">An Append-Only Event Log for a Hive of Agents</span></a><a class="pn next" href="/blog/why-local-first-matters-for-ai-agents/"><span class="k">Newer →</span><span class="t">Why Local-First Matters for Your AI Agents</span></a></div>+ <section class="related">+ <h2>Related in Story</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">+ <span>STORY</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>4 min</span>+ </div>+ <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>+ <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>+ <div class="foot">+ <span class="tag kind">Story</span>+ <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>+ </div>+ </div>+</article>++ </div>+ </section>+</footer></article>diff --git a/docs/sitemap.xml b/docs/sitemap.xmlindex baf61158..8b68e494 100644--- a/docs/sitemap.xml+++ b/docs/sitemap.xml@@ -23,6 +23,12 @@<changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/agent-security-and-sandboxing/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/architecture-two-planes-one-renderer/</loc><lastmod>2026-06-04</lastmod>@@ -35,6 +41,12 @@<changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/building-reliable-ai-agents/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/</loc><lastmod>2026-06-04</lastmod>@@ -137,12 +149,30 @@<changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/security-for-ai-coding-agents/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/small-team-ai-agents-playbook/</loc><lastmod>2026-06-04</lastmod><changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/the-office-parody-behind-munder-difflin/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/trigger-ai-agents-from-slack/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/</loc><lastmod>2026-06-04</lastmod>@@ -377,33 +407,35 @@<url><loc>https://munderdiffl.in/blog/tags/concepts/</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/memory/</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/automation/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/mempalace/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/use-cases/</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/workflow/</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/human-in-the-loop/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/story/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/local-first/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/terminals/</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/autonomous/</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/god/</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/guardrails/</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/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/open-source/</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/performance/</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/reliability/</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/hive/</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><url><loc>https://munderdiffl.in/blog/tags/messaging/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/event-log/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/glossary/</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/faq/</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/privacy/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>@@ -413,12 +445,16 @@<url><loc>https://munderdiffl.in/blog/tags/skills/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/node-pty/</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/error-handling/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/context-engineering/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/debugging/</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/reliability/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/trust/</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/brand/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/the-office/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/munder-difflin/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/slack/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/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/devrel/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>