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 h2 — 6 educational posts (50 → 56)
Chaitanya Giri4660a47afa83
diff --git a/blog/src/posts/how-ai-agents-verify-their-own-work.md b/blog/src/posts/how-ai-agents-verify-their-own-work.mdnew file mode 100644index 00000000..9fb54c71--- /dev/null+++ b/blog/src/posts/how-ai-agents-verify-their-own-work.md@@ -0,0 +1,140 @@+---+title: "How AI Agents Verify Their Own Work (Before Saying 'Done')"+description: "The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent."+date: 2026-06-04+category: concepts+categoryLabel: Concepts+type: Technical+primaryKeyword: "ai agent self-verification"+secondaryKeywords: ["verify ai agent output", "reproducible agent checks", "autonomous coding agent reliability"]+tags: ["Concepts", "Multi-Agent", "Claude Code", "Reliability"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Why do AI coding agents report success when the work is actually broken?"+ a: "Because generating a confident summary is easy and checking it is work. A model will happily write 'typecheck passes, build is green' from intent rather than evidence unless the harness forces it to actually run the commands and read the output. The fix isn't a better model — it's making the agent prove each claim with a command whose output it pastes back."+ - q: "What does it mean to verify a fix 'reproducibly'?"+ a: "It means the check passes in a clean environment the reviewer can reproduce — not one that happens to work because of leftover state. An agent in a fresh git worktree with no installed dependencies can't honestly say 'build is green' until it actually has them; otherwise the claim is unverifiable. Reproducible means: same inputs, same commands, same green, on another machine."+ - q: "Should a second agent re-verify the first agent's work?"+ a: "For anything that integrates or ships, yes. Independent re-verification catches the failure mode where an agent's self-check was subtly wrong — it re-runs the checks from scratch and confirms the diff is exactly what was claimed. It's cheap insurance against a confident but wrong 'done'."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>An autonomous agent's most useful skill isn't+writing code — it's <strong>not lying to you by accident</strong>. The discipline: prove every claim with+a command whose output you can read, run the check in an environment a reviewer can <strong>reproduce</strong>,+verify the <em>fix</em> rather than the <em>intent</em>, and have a second agent re-verify anything that+ships. "Done" should mean "checked," not "looks right."</p></div>++The scariest output from an autonomous coding agent isn't an error — it's a confident "✅ done, all tests+pass" that nobody ran. An error you can see; a false green you trust, ship, and discover in production.++If you run [agents that work while you sleep](/blog/claude-code-automation-while-you-sleep/), what decides+whether you wake up to progress or a mess isn't how smart the model is. It's how rigorously the agent+verifies its own work before it says it's finished. Here's the discipline, drawn from how agents actually+operate inside a hive.++## The core failure: plausible beats checked++A language model is very good at producing a *plausible* summary. Asked whether the build passes, it can+write a fluent "build is green, typecheck clean" with zero commands run — because the sentence is likely,+not because it's true. That's the central reliability problem of autonomous agents: **generating a claim+is cheaper than verifying it**, so without pressure the agent drifts to the cheap path.++The fix is structural, not motivational. You don't ask the agent to "be careful." You make every factual+claim cost a command:++- "Typecheck passes" → run it, paste the tail of the output.+- "The fix removes the noise" → show the before *and* after, not a description of the after.+- "Only two files changed" → `git diff --stat`, not memory.++A claim with no command behind it is a guess wearing a lab coat. Treat your own output as untrusted until+a tool confirms it.++## Reproducible, or it didn't happen++Here's a real trap. An agent works in an isolated [git worktree](/blog/claude-code-git-worktrees-vs-hive/)+— a clean checkout on its own branch — edits code, and reports "typecheck and build both green."++But a fresh worktree has **no `node_modules`**. If the agent never installed or linked dependencies, the+build would have errored immediately — so a "green" report is at best unverifiable and at worst fabricated+from intent. The reviewer pulls the branch, runs the same command, gets a wall of "cannot find module,"+and now trusts nothing the agent said.++The discipline is *reproducibility*: a check only counts if it passes in an environment the reviewer can+recreate. In a fresh worktree, make the dependencies real *before* claiming green:++```bash+ln -s ../main/node_modules ./node_modules # link the main checkout's deps+npm run typecheck # now this is a claim you can stand behind+npm run build # paste the result — green that reproduces is green+```++"It works on my branch" is worthless if your branch is a state no one else can reach.++## Verify the fix, not the intent++A subtler failure than skipping the check: running a check that doesn't prove the thing you fixed. You+patched the cause, the code compiles, so you call it done — but you never confirmed the *symptom* is gone.++A real example from agent memory hygiene. The task: stop a [semantic memory](/blog/semantic-memory-for-ai-agents/)+indexer from ingesting config files that swamped recall. The fix added an ignore rule so the miner skipped+them; typecheck and build passed — intent satisfied. But re-running the indexer showed the noise *still+there*, because mining is **additive**: it stops filing new junk but doesn't delete what's already indexed.+The fix was correct and incomplete at once. Only checking the actual symptom — running the recall digest+and reading it — surfaced the gap, which needed a separate prune pass to truly clean the index.++The lesson generalizes: **decide what "fixed" looks like as an observable, then observe it.** Not "the code+changed" — "the broken behavior is gone, here's the before and after."++> **Rule of thumb:** a fix isn't verified by the change that caused it. It's verified by the absence of the+> problem it was meant to remove. Show the problem gone, with evidence.++## A second pair of eyes++Self-verification catches most of it. For anything that integrates or ships, add one layer: a different+agent re-runs the checks from scratch and confirms the diff is exactly what was claimed.++This isn't bureaucracy — it catches the case where an agent's *own* verification was subtly wrong (checked+the wrong file, ran in a dirty environment, misread output). In practice it looks like an+[orchestrator](/blog/how-the-god-orchestrator-works/) independently re-running the typecheck and confirming+"exactly these two files changed, zero stray bytes, passes here too" before folding the work in. It pairs+naturally with [human-in-the-loop gates](/blog/human-in-the-loop-ai-agents/): the agent verifies, a peer+re-verifies, and the human approves what's hard to reverse. Each layer assumes the one before it can be+wrong — which is why the chain holds.++## A self-verification checklist++Before an agent writes "done," it should answer yes to all of these:++- **Did I run it, or imagine it?** Every claim has a command and visible output behind it.+- **Can someone else reproduce my green?** No leftover state, uninstalled deps, or dirty tree.+- **Did I verify the symptom, not just the change?** Before/after evidence the problem is gone.+- **Is the diff exactly what I claimed?** Scope respected, no surprise files, no binary cruft.+- **What did I *not* check?** Name the gaps — a stated limitation beats a silent one.++That last point matters most. An agent that says "typecheck and build pass, but the runtime behavior needs+a real app launch I can't do from here" is *more* trustworthy than one claiming everything is perfect.+Calibrated honesty about what wasn't verified is itself a form of verification — it tells the human exactly+where to look. Verification is what converts raw [capability](/blog/coordinating-ai-coding-agents/) into+*reliable* capability.++## FAQ++**Why do agents report success when the work is broken?** Because writing a confident summary is easier+than checking one. Unless the harness forces the agent to run the command and read the output, it fills in+a plausible result. Make every claim earn a command.++**What makes a check "reproducible"?** It passes in a clean environment someone else can recreate — not one+that works only because of leftover state. Same inputs, same commands, same green, on another machine.++**Does this replace human review?** No — it front-loads it. Agents verify and re-verify each other to catch+the obvious failures cheaply, so scarce human attention lands on the decisions that actually carry risk.++---++Munder Difflin runs a hive of Claude Code agents that verify their own work and+[re-verify each other's before anything integrates](https://munderdiffl.in/#how) — locally, with a human+gate on anything that ships.+[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/local-first-ai-agent-orchestration.md b/blog/src/posts/local-first-ai-agent-orchestration.mdnew file mode 100644index 00000000..18965025--- /dev/null+++ b/blog/src/posts/local-first-ai-agent-orchestration.md@@ -0,0 +1,147 @@+---+title: "Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud"+description: "How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine."+date: 2026-06-04+category: orchestration+categoryLabel: Orchestration+type: Technical+primaryKeyword: "local-first ai agent orchestration"+secondaryKeywords: ["orchestrate ai agents locally", "no-server agent coordination", "local multi-agent architecture"]+tags: ["Orchestration", "Local-First", "Internals", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is local-first AI agent orchestration?"+ a: "It's coordinating multiple AI agents — routing work between them, scheduling tasks, storing memory — entirely on your own machine instead of a vendor's cloud. The agents still call the model API, but the control plane (the loop, the message router, the scheduler, the audit log) runs as local processes and reads and writes local files."+ - q: "Do you need a server or message broker to coordinate AI agents?"+ a: "No. A hive can coordinate through plain files: each agent has an inbox and outbox folder, and a small router process drains outboxes into the right inboxes on a timer. There's no Redis, no queue service, no daemon to keep alive — delivery is an atomic file rename, so it's safe under concurrency without locks."+ - q: "What are the limits of orchestrating agents on one machine?"+ a: "Two real ones. The orchestration only runs while your machine is on — timers and the router live in a local process, so closing the app pauses the schedule. And concurrency is bounded by your CPU and RAM rather than an elastic cloud. In exchange you get zero infrastructure, a full local audit trail, and complete ownership of your data."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Local-first orchestration</strong>+means the whole control plane for a team of agents — the loop that keeps them working, the+<strong>message router</strong>, the <strong>scheduler</strong>, and the <strong>audit log</strong> —+runs as processes on <em>your</em> machine and coordinates through <em>local files</em>, not a cloud+service. Agents are local child processes; they talk through inbox/outbox folders drained by an+in-process router; tasks fire on local timers; git is the audit trail. No broker, no queue service, no+control-plane server. This is the <em>how</em>; for the <em>why</em>, see <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters</a>.</p></div>++It's one thing to argue that keeping your agents [on your own+machine](/blog/why-local-first-matters-for-ai-agents/) is better for control, privacy, and cost. It's+another to explain how a team of agents actually *coordinates* without a cloud control plane in the+middle. If there's no orchestration server, what routes the work? This post is the mechanics —+grounded in how Munder Difflin's hive is built — of running real multi-agent orchestration with nothing+but local processes and files.++## Where the orchestration loop actually runs++Start with the obvious question: what is "the orchestrator"? In a cloud platform it's a service you+never see. Locally, it's just a process on your machine — in Munder Difflin's case, the desktop app's+main process. It boots the message router, arms the scheduler, and manages the agents. There's no+remote brain; the coordination logic is code running next to your editor.++The agents themselves are equally concrete. Each one is a **local child process** — the harness spawns+the `claude` CLI through [node-pty](/blog/node-pty-electron-real-terminals/), the same way a terminal+would, and talks to it over a pseudo-terminal. An "agent" isn't an abstraction in someone's datacenter;+it's a real OS process you could see in your activity monitor. The model call goes out to the API; the+agent that makes it lives on your box.++## Coordination without a broker++The interesting part is how those local processes talk to each other. The instinct from distributed+systems is to reach for a message broker — Redis, RabbitMQ, a cloud queue. A local-first hive does+something far simpler: **files**.++Every agent gets a workspace with an `inbox/` and an `outbox/` folder. To send a message, an agent+writes one JSON file into its own outbox. A small **router**, running on a timer inside the main+process, scans every outbox on each tick and delivers what it finds — moving the message into the+recipient's inbox with an atomic write. (In the code, that's a `routerTimer` driving a `deliver()`+step that writes each message into the target's inbox folder; a `broadcast` simply fans the same+message out to every agent's inbox.)++That one design decision buys a lot, and we unpack it fully in [atomic file mailboxes for+agents](/blog/atomic-file-mailboxes-for-agents/):++- **No infrastructure.** The "message bus" is a directory and the rename syscall. Nothing to install,+ nothing to keep alive.+- **Conflict-free concurrency.** Each file has exactly one writer and delivery is an atomic rename, so+ busy agents never corrupt each other's mail — no locks required.+- **Durable and replayable.** Messages are files. A crash loses nothing already written, and you can+ read the whole exchange back later.++It's the backbone of [how a hive coordinates its agents](/blog/coordinating-ai-coding-agents/), and it+never leaves your disk.++## Scheduling on your own clock++Recurring work doesn't need a cloud cron either. The scheduler arms ordinary in-process timers — a+`setTimeout` into a steady `setInterval` — and when one fires it just drops a `request` message into an+agent's inbox, exactly like any other message. Each mission remembers when it last fired, so restarts+resume the cadence instead of resetting it. The full mechanism is in [scheduling autonomous agent+missions](/blog/scheduling-autonomous-agent-missions/). The point for orchestration: your hive's sense+of time is a timer in a process on your laptop, not a job in someone's scheduler.++## State that never leaves the box++Coordination also needs memory, and here too everything is local:++- **Config** lives in a plain JSON file on disk — which agents exist, which missions are armed, your+ preferences.+- **Per-agent memory** is a markdown file each agent reads at the start of a task and appends to as it+ learns.+- **The audit log is git.** A [single committer](/blog/single-committer-git-pattern/) — the+ orchestrator process — records the message and file changes, so "who did what, in what order" is+ answerable from your own repo history, not a vendor's dashboard.+- **Semantic memory** runs locally too: a [searchable knowledge store](/blog/semantic-memory-for-ai-agents/)+ the whole team can query, indexed on your machine.++Nothing in that list is a network call. The team's shared brain is a folder you own.++## The loop is local, too++What keeps an agent *going* without you clicking "continue"? A local hook. When an agent finishes a+turn, a Stop hook checks its inbox; if fresh messages are waiting, it tells the agent to keep working,+and when the queue is empty it lets the agent rest. That's the [autonomous+loop](/blog/claude-code-automation-while-you-sleep/) — and it's wired through the same local files, run+by [the orchestrator](/blog/how-the-god-orchestrator-works/) on your machine, with no remote scheduler+deciding when your agents wake up.++## What it costs — and what you keep++Local-first orchestration isn't free of trade-offs, and it's worth being honest about them:++- **It runs while your machine does.** The router and the timers are in a local process, so closing the+ app pauses delivery and the schedule. Overdue missions catch up on the next launch, but there's no+ always-on cloud firing at 3 a.m. with the lid shut.+- **Concurrency is bounded by your hardware.** You scale with your own CPU and RAM, not an elastic+ fleet. For a team of agents working one codebase, that's usually plenty — but it's a ceiling, not a+ dial you pay to raise.++In return you get the things a control-plane server quietly takes away: **zero infrastructure** to run+or secure, a **complete audit trail** in your own git history, and **full ownership** of your code,+messages, and memory. For agents that touch your whole project, that trade is the whole point — and+it's the practical side of [why local-first matters](/blog/why-local-first-matters-for-ai-agents/).++## FAQ++**What is local-first AI agent orchestration?** Coordinating multiple agents — routing work,+scheduling tasks, storing memory — entirely on your own machine. The agents call the model API, but the+control plane (loop, router, scheduler, audit log) is local code reading and writing local files.++**Do I need a server or broker to coordinate agents?** No. Agents coordinate through inbox/outbox+folders that a small router drains on a timer, delivering messages with atomic file renames. No Redis,+no queue service, no daemon.++**What are the limits?** Orchestration only runs while your machine is on, and concurrency is bounded by+your hardware. In exchange you get no infrastructure, a full local audit trail, and complete data+ownership.++---++Munder Difflin is local-first orchestration you can watch: a hive of Claude Code agents coordinating+through file mailboxes, local timers, and a git audit log — [all run by a GOD+orchestrator](https://munderdiffl.in/#how) on your own machine. [Download Munder+Difflin](https://munderdiffl.in/#install) to run a coordinated team of agents with no cloud in the+loop; it's free and open source.diff --git a/blog/src/posts/open-source-ai-tools-on-purpose.md b/blog/src/posts/open-source-ai-tools-on-purpose.mdnew file mode 100644index 00000000..ed3ded2a--- /dev/null+++ b/blog/src/posts/open-source-ai-tools-on-purpose.md@@ -0,0 +1,127 @@+---+title: "Building AI Dev Tools in the Open, On Purpose"+description: "Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it."+date: 2026-06-04+category: concepts+categoryLabel: Concepts+type: Non-technical+primaryKeyword: "open source ai agents"+secondaryKeywords: ["open source ai tools", "mit license", "building in public", "local-first ai"]+tags: ["Open Source", "Local-First", "Trust", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Why does it matter whether an AI agent tool is open source?"+ a: "Because agents act autonomously on your behalf — they read your code, call tools with your keys, and keep memory of your work. A closed, autonomous tool asks you to trust all of that on faith. An open one lets you read exactly what it does, audit it, and fix or fork it if you disagree. For software that operates this independently, inspectability isn't a nice-to-have; it's the basis of trust."+ - q: "What does MIT-licensed actually give me as a user?"+ a: "The MIT license is permissive: you can read the full source, run it for any purpose, modify it, and fork it, with essentially no strings beyond keeping the copyright notice. Practically that means no lock-in — if the project changed direction or disappeared, your copy keeps working and you can carry it forward yourself."+ - q: "Isn't open source just a marketing label these days?"+ a: "It can be, when 'open' means a crippled core with the useful parts behind a cloud subscription. The honest version is open source plus local-first: the whole thing runs on your machine, your data and memory stay local, and the code that orchestrates your agents is the code you can read. That combination is what makes 'open' mean something for a dev tool."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>AI agents read your code, call tools with your+keys, and remember your work — so an agent tool asks for an unusual amount of trust. The answer isn't to+trust harder; it's to make the tool <strong>inspectable</strong>. Munder Difflin is+<strong>MIT-licensed and local-first on purpose</strong>: the orchestrator, the agents, and their memory+all run on your machine, and the code that drives them is code you can read, audit, and fork. For+software this autonomous, open source isn't ideology — it's how you replace blind trust with+verification.</p></div>++There's a lot of AI agent tooling being built right now, and a striking amount of it is closed: a cloud+service you send your code to, a black box that acts on your repo, a "core" that's open while the parts+that matter sit behind a subscription. [Munder Difflin](https://munderdiffl.in/#opensource) went the+other way — MIT-licensed, source-available, local-first — and not as an afterthought. It's a deliberate+choice about what a tool like this *should* be. Here's the case for building agent tooling in the open,+on purpose.++## Agents raise the trust bar++A linter or a formatter is a utility: it does one bounded thing and you can eyeball the result. An+**agent** is different in kind. It runs semi-autonomously, decides its own next steps, reads and writes+your files, calls tools using your credentials, and — increasingly — keeps a persistent+[memory](/blog/markdown-first-agent-memory/) of your project across sessions. A *hive* of them does all+that in parallel.++That's a lot of latitude to hand to software. And the more autonomous the software, the worse a black+box feels: with a closed agent you're not trusting a single output, you're trusting every decision it+will make on your behalf, forever, without being able to look. The reasonable response isn't to trust+harder. It's to demand that the tool be **inspectable** — that you can read what the orchestrator does+with your code before you let it loose on it.++Open source is what makes that possible. It turns "trust us" into "check for yourself."++## What "open, on purpose" actually buys you++Being [MIT-licensed](https://munderdiffl.in/#opensource) and built in the open isn't a badge; it changes+what you can do as a user:++- **Auditability.** You can read exactly how work gets routed, what an agent is allowed to touch, and+ where your data goes. No guessing about a remote service's behavior.+- **No lock-in.** Permissive licensing means your copy keeps working regardless of what happens to the+ project. You're never one pricing change or shutdown away from losing your workflow.+- **Forkability.** Disagree with a decision? Change it. Need a behavior the maintainers won't add? Fork+ it. The tool bends to your needs instead of the reverse.+- **Longevity.** Open code outlives the company or the moment. The work you build on top of it is safe+ in a way that a closed SaaS can't promise.++## Open *and* local-first — the combination is the point++"Open source" alone can still be hollow if the useful half lives in someone else's cloud. The version+that actually means something pairs open code with **local-first** execution: the orchestrator, the+agents, and their memory all run on *your* machine, and your code and notes never have to leave it.++That pairing is deliberate in Munder Difflin, and the two halves reinforce each other. Local-first gives+you [control and privacy](/blog/why-local-first-matters-for-ai-agents/); open source lets you *verify*+that the local-first promise is real rather than taking it on faith. Closed-and-local is unverifiable;+open-and-cloud still ships your data away. Open-and-local is the only quadrant where you can both keep+your data and confirm what the tool is doing with it.++## Built in public — including this post++Building in the open also means the work itself is visible: the commits, the architecture decisions, the+[reasons behind them](/blog/why-we-built-munder-difflin/). There's a fitting proof of it in your hands+right now — this blog is written and maintained by the hive of agents the tool runs, working in their+own branches and committing source for review. The system documenting itself in public is about as+on-the-nose a demonstration of "built in the open" as you'll find.++It also lowers the bar to contribute. When the code and the thinking are both public, a user who hits a+rough edge can read the relevant file, understand it, and propose a fix — instead of filing a ticket into+a void and hoping.++## The honest tradeoffs++Open source isn't free of cost, and pretending otherwise would be exactly the kind of marketing this post+is arguing against. Building in the open means no proprietary moat, support that leans on community and+docs rather than a guaranteed SLA, and the ongoing effort of keeping a public project healthy. Those are+real.++But weigh them against the alternative for *this* category of software: a closed, autonomous agent that+touches everything and explains nothing. For a dev tool that operates with this much independence, the+trust and control you get from open-and-local outweigh the convenience of a black box. That's the bet —+made on purpose.++## FAQ++**Why does it matter whether an AI agent tool is open source?** Because agents act autonomously on your+behalf — reading your code, calling tools with your keys, holding memory of your work. A closed tool asks+you to trust all of that on faith; an open one lets you read what it does, audit it, and fork it if you+disagree. For software this independent, inspectability is the basis of trust.++**What does MIT-licensed actually give me?** It's permissive: read the source, run it for any purpose,+modify it, fork it — essentially no strings beyond keeping the copyright notice. In practice that means+no lock-in. If the project changed course or vanished, your copy keeps working and you can carry it+forward.++**Isn't "open source" just a label sometimes?** It can be, when "open" means a hollow core with the+useful parts behind a cloud subscription. The honest version is open source *plus* local-first: the whole+thing runs on your machine, your data stays local, and the orchestration code is the code you can read.++## The bottom line++The more an agent can do on your behalf, the more it matters that you can see what it's doing. Open+source plus local-first is how a tool earns that trust — not by asking for it, but by making itself+checkable. Munder Difflin is MIT and built in the open [on+purpose](https://munderdiffl.in/#opensource), because that's the only honest way to ship software this+autonomous. [Download Munder Difflin](https://munderdiffl.in/#install) and read every line you're running+— it's free and open source.diff --git a/blog/src/posts/overnight-ai-coding-realistic-expectations.md b/blog/src/posts/overnight-ai-coding-realistic-expectations.mdnew file mode 100644index 00000000..93cbf337--- /dev/null+++ b/blog/src/posts/overnight-ai-coding-realistic-expectations.md@@ -0,0 +1,140 @@+---+title: "Overnight AI Coding: What's Realistic (and What's Not)"+description: "An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning."+date: 2026-06-04+category: use-cases+categoryLabel: Use Cases+type: Non-technical+primaryKeyword: "overnight ai coding"+secondaryKeywords: ["autonomous coding agents", "ai coding limits", "can ai code overnight"]+tags: ["Use Cases", "Autonomous", "Human-in-the-Loop", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "Can AI coding agents really work overnight?"+ a: "Yes, for well-scoped, verifiable work — tests, migrations, refactors, doc sweeps — agents can make real progress unattended. They struggle with ambiguous goals, decisions that need taste, and anything they can't check themselves."+ - q: "Is it safe to let coding agents run while you sleep?"+ a: "It's safe when you set guardrails: branch-only changes (never straight to main), human approval for spend and destructive actions, and an audit log you can read in the morning. Without those, unattended agents can do unattended damage."+ - q: "What's the biggest mistake with overnight AI coding?"+ a: "Giving a vague goal with no way for the agent to verify success. Agents that can run tests and check their own output make progress; agents told to 'improve the app' wander."+ - q: "Will I wake up to finished features?"+ a: "Sometimes — but expect to wake up to progress that needs review, not merged production code. The realistic win is a reviewable branch and a clear log, not a hands-off release."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Overnight AI coding is <strong>real</strong>,+but the honest version isn't "wake up to shipped features." It's: agents make genuine progress on+<strong>well-scoped, verifiable</strong> work while you sleep, behind guardrails — branch-only changes,+human approval for the dangerous stuff, and an audit log you read with coffee. Set the scope and the+guardrails right and it's a force multiplier. Skip them and you wake up to a mess. Here's what actually+works, what doesn't, and how to set it up so morning-you is happy.</p></div>++The pitch writes itself: close the laptop, let a hive of agents code through the night, wake up to+finished work. It's a good pitch — and like most good pitches, the truth is more interesting than the+slogan. Agents *can* do real work overnight. They also fail in specific, predictable ways. This is the+realistic version, so you can get the upside without the 3 a.m. surprises. If you want the optimistic+companion, read [letting agents build while you sleep](/blog/claude-code-automation-while-you-sleep/) —+this post is the counterweight that keeps it honest.++## What overnight agents actually do well++The work that survives unattended has one thing in common: **the agent can tell whether it succeeded.**+When success is checkable, an agent can iterate toward it without you. That covers a lot:++- **Test-guarded changes.** Writing tests, fixing failing ones, raising coverage — the test suite is+ the oracle, so the agent knows when it's done.+- **Mechanical migrations.** Renames, dependency bumps, codemods, framework upgrades across many files+ — repetitive, verifiable, and exactly the kind of tedium you'd rather not do by hand.+- **Refactors with a safety net.** Extracting modules, deleting dead code, tightening types — anything+ where "still compiles, tests still pass" is a real signal.+- **Documentation and cleanup.** Doc sweeps, changelog drafting, comment passes, fixing lint — low-risk,+ high-toil, easy to review in the morning.++Give a team of agents a stack of these with clear acceptance criteria and they'll genuinely chip+through it overnight. That's the realistic win, and it's a good one.++## Where it breaks++The failure modes are just as predictable. Overnight agents struggle when:++- **The goal is ambiguous.** "Improve the dashboard" has no finish line, so the agent wanders or+ gilds. "Make the dashboard's first paint under 1s, verified by the perf test" has one.+- **The work needs taste.** Product judgment, API design, naming that future humans will live with —+ these need a person. An agent will *pick something*, but unattended is the wrong time to discover you+ disagree.+- **Verification is impossible.** If the agent can't check its own output — no tests, no types, no+ reproducible run — it's flying blind, and you're reviewing blind in the morning.+- **It hits a real decision.** Spending money, deleting data, a destructive migration, a scope change+ nobody anticipated. The right move here isn't "guess confidently" — it's "stop and ask."++Notice the pattern: the failures aren't about raw capability. They're about **scope and judgment**. The+fix isn't a smarter model; it's a better setup.++## The guardrails that make overnight work safe++Unattended doesn't have to mean ungoverned. The difference between "wake up to progress" and "wake up+to a mess" is a handful of guardrails — and they're the same ones a good+[multi-agent harness](/#what) builds in:++- **Branch-only, never straight to main.** Overnight agents commit to their own branches/worktrees. The+ worst case is a branch you delete, not a broken `main`. Merging stays a deliberate, human-gated step.+- **Human-in-the-loop for the dangerous stuff.** The system runs autonomously on routine work but+ *pauses for approval* on the things that matter — spend, destructive operations, scope changes. Done+ right, this doesn't slow you down; it just stops the few actions you'd regret. (More on designing+ that: [human-in-the-loop AI agents](/blog/human-in-the-loop-ai-agents/).)+- **An orchestrator that escalates instead of guessing.** When an agent gets blocked or two agents+ conflict, a coordinator should resolve the routine cases and *escalate* the genuine decisions to a+ queue you read in the morning — not paper over them with a confident wrong answer.+- **An audit log you can actually read.** The single most valuable overnight artifact isn't the diff —+ it's a chronological record of what each agent did and why, so morning review takes minutes, not+ hours.+- **Durable memory for continuity.** Agents that record what they learned (and recall it) don't loop on+ the same dead end all night or re-litigate a decision they already made.++None of these are exotic. They're the boring infrastructure that turns "agents running unsupervised"+into "agents running *supervised by design*."++## A realistic overnight setup++If you want to try it tonight, here's the honest checklist:++1. **Queue verifiable tasks, not vibes.** Each task gets a one-line goal *and* a way to check it+ ("tests green," "build passes," "endpoint returns 200"). If you can't state the check, it's not an+ overnight task — it's a morning conversation.+2. **Scope small.** Several narrow tasks beat one sprawling one. Small tasks fail cheaply and review+ fast.+3. **Isolate the blast radius.** Branches or worktrees per agent, never the shared main checkout.+4. **Set the escalation rules.** Decide up front what the agents may do autonomously and what must wait+ for you. Default the ambiguous cases to "ask."+5. **Leave breadcrumbs for morning-you.** Make sure there's a log and a short status per task. You're+ optimizing your *review time*, not just the agents' run time.++## What still needs you in the morning++This is the part the slogans skip. Overnight agents change *when* the work happens, not *whether you're+accountable for it*. You still:++- **Review the diffs.** "Tests pass" is necessary, not sufficient — read the change.+- **Make the taste calls** the agents correctly deferred.+- **Decide what merges.** The realistic deliverable is a reviewable branch plus a clear log, not an+ auto-merged release.++That's not a limitation to apologize for — it's the right division of labor. Agents are spectacular at+toil and iteration; you're irreplaceable at judgment and accountability. Overnight coding works best+when the setup respects that line instead of pretending it doesn't exist.++## The honest bottom line++**Can AI code overnight? Yes — for well-scoped, verifiable work, behind guardrails, with you reviewing+in the morning.** Treat it as a tireless junior team that needs clear tickets and a review gate, and+you'll get a real multiplier. Treat it as a magic "ship while I sleep" button and you'll get a cleanup+job. The technology is ready for the first framing today; the second is still a slogan.++If watching that team work (and reading its log) sounds useful, that's exactly what+[running an office of AI agents](/blog/run-an-office-of-ai-agents/) is about.++---++Munder Difflin is a local, open-source [multi-agent harness](/#why) built for exactly this: agents that+work on isolated branches, escalate the decisions that matter, and leave a readable trail.+[Download Munder Difflin](/#install) to run your own overnight team — free and MIT-licensed.diff --git a/blog/src/posts/prompt-caching-for-ai-agents.md b/blog/src/posts/prompt-caching-for-ai-agents.mdnew file mode 100644index 00000000..ae497eb2--- /dev/null+++ b/blog/src/posts/prompt-caching-for-ai-agents.md@@ -0,0 +1,157 @@+---+title: "Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice"+description: "An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it."+date: 2026-06-04+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "prompt caching for ai agents"+secondaryKeywords: ["prompt caching", "llm prompt caching", "agent cost optimization", "kv cache"]+tags: ["Prompt Caching", "Cost", "Performance", "Multi-Agent"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "What is prompt caching?"+ a: "Prompt caching lets an LLM provider store the processed form of a stable prefix of your prompt — typically the system instructions, tool definitions, and any large fixed context — so that subsequent requests reusing that exact prefix skip the work of reprocessing it. You pay full price to write the cache once, then a small fraction of the input price on every later request that hits it, and the response starts faster."+ - q: "Why does prompt caching matter so much for agents?"+ a: "An agent is a loop: it sends the same system prompt, the same tool list, and often the same large context on every single turn, with only the newest messages changing. Without caching you re-pay for that entire stable prefix dozens of times in one session. With caching you pay for it once and read it cheaply thereafter, which for a long agent run is usually the single biggest cost reduction available — and it cuts latency too."+ - q: "How do I structure a prompt so it caches well?"+ a: "Put the stable content first and the volatile content last. Caches match on an exact prefix, so the system prompt, tool definitions, and fixed context go at the front, and the changing turn-by-turn messages go at the end. Any change near the front invalidates everything after it, so never edit or reorder the prefix mid-session — append, don't rewrite."+ - q: "What are the limits of prompt caching?"+ a: "Caches expire after a short time-to-live (often around five minutes by default), so an agent that goes idle loses its cache and re-pays the write. Caching only helps input tokens, not output, and it doesn't change answer quality — it's purely a cost and latency optimization. And because matching is exact-prefix, a single changed token near the front busts the cache."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>An agent is a loop that re-sends the same+system prompt, tools, and context on <em>every</em> turn — and naively you pay full price for that+prefix every time. <strong>Prompt caching</strong> makes you pay for the stable prefix once (a small+write premium) and a fraction of the price on every later turn that reuses it. The design rules:+<strong>stable content first, volatile content last</strong>; never rewrite the prefix mid-session+(append, don't edit); and keep turns flowing so the cache doesn't expire. For a long-running agent it's+usually the single biggest lever on both <strong>cost and latency</strong>.</p></div>++Last time we looked at [routing the right task to the right model](/blog/do-more-with-less-model-routing/)+as the first big cost lever for a hive of agents. Here's the second, and it's one people leave on the+table constantly: **prompt caching**. The model-routing argument is about *which* model you call;+prompt caching is about *not re-paying for the same tokens* every time you call it. Both matter; this+one is almost free once you understand the shape of an agent's prompt.++## An agent re-sends almost the same prompt every turn++Step back and look at what an agent actually sends to the model on each turn of its loop:++- a **system prompt** — its role, rules, and instructions (stable for the whole session),+- a set of **tool definitions** — often long, and identical every turn,+- some **fixed context** — a codebase summary, project docs, a style guide (stable),+- and then the **conversation so far** plus the **newest message or tool result** (this is the only+ part that actually changes).++The first three are the same on turn 1 and turn 40. Yet without caching, every turn re-sends and the+model re-processes that entire prefix from scratch — and you pay input-token price for all of it, every+single time. On a long agent run with a big system prompt and a fat tool list, the *stable* prefix can+dwarf the changing part. You're paying for the same tokens dozens of times.++That's the waste prompt caching removes.++## What caching actually does++Every major provider now offers some form of it (Anthropic, OpenAI, and Google all do). The mechanics+vary, but the shape is the same:++1. The provider stores the **processed form** of a prefix of your prompt.+2. The **first** request that establishes the cache pays a small **write premium** over normal input+ price (Anthropic, for example, charges around 1.25× to write).+3. **Every later** request whose prompt begins with that exact prefix pays only a **fraction** of the+ input price for the cached part — on the order of **a tenth** — and the response also starts faster,+ because the expensive prefix didn't have to be reprocessed.++So the trade is: pay a little extra once, then pay almost nothing for that prefix on every subsequent+turn. For a one-shot call that never repeats, caching isn't worth the write premium. For an *agent* —+which repeats the same prefix constantly — it's close to a no-brainer. The break-even is usually just+two or three reuses, and agents reuse far more than that.++## The one rule: stable first, volatile last++Caches match on an **exact prefix**. The provider walks your prompt from the start and reuses the cache+up to the first byte that differs. Everything after that point is reprocessed and re-priced. That single+fact dictates the whole design:++> Put everything stable at the **front** of the prompt, and everything that changes turn-to-turn at the+> **back**.++Concretely, order your prompt as: **system prompt → tool definitions → fixed context → conversation+history → newest message**. That way the longest possible run of bytes at the front is identical every+turn, so the cache covers the maximum amount, and only the short, genuinely-new tail gets reprocessed.++The corollary is a discipline that trips people up: **never edit or reorder the prefix mid-session.** If+you insert a note into the system prompt on turn 20, or shuffle your tool list, or rewrite the fixed+context, you change a byte near the front and **invalidate the cache for everything after it** — you're+back to paying full price. The cache-friendly move is always to **append** new information at the end,+never to rewrite the beginning.++This is exactly where caching and [context engineering](/blog/semantic-memory-for-ai-agents/) have to+agree with each other. Curating the window is good — but if your curation *rewrites the front* of the+context on every turn, you've quietly destroyed your cache. Cache-aware context engineering means: keep+the stable prefix truly stable, and do your adding at the tail.++## Watch the clock: caches expire++The second gotcha is **time-to-live**. Cached prefixes don't live forever; a common default is around+**five minutes** of inactivity before the cache is dropped (some providers offer a longer, pricier TTL).+For an agent in a tight loop, this is invisible — turns come fast enough that the cache stays warm. But+an agent that **goes idle** — waiting on a human approval, blocked on a slow tool, parked between tasks —+can let its cache lapse and pay the write premium all over again when it resumes.++The practical implications:++- Keep active agents **looping** rather than sleeping mid-task when you can.+- For work with unavoidable long pauses, consider a provider's **extended-TTL** option, or accept the+ re-write cost as the price of the pause.+- Be aware that the cost math shifts the moment an agent stalls — which is one more reason+ [human-in-the-loop checkpoints](/blog/human-in-the-loop-ai-agents/) should be rare and high-signal,+ not sprinkled everywhere.++## The multi-agent angle++In a single agent, caching is a per-session win. In a [hive](/blog/coordinating-ai-coding-agents/) it+compounds, because many agents share structure. If your agents are built from the **same system-prompt+template and the same tool definitions**, each one's prefix is independently cacheable — and if you keep+that shared scaffold **byte-identical** across agents (same ordering, same formatting), you make every+agent's prompt as cache-friendly as it can be.++Two concrete habits pay off:++- **Standardize the scaffold.** A shared, fixed prefix format across roles means every agent benefits+ from the same caching behavior, and you reason about cost once instead of per-agent.+- **Give sub-agents a stable brief.** When an orchestrator spins up a short-lived sub-agent, a+ consistent, front-loaded brief lets even brief agents cache their setup — useful when you fan out many+ similar sub-agents at once.++The general principle, same as everywhere else in agent design: **shared, stable structure is cheaper+than bespoke, churning structure** — here it's literally cheaper, in tokens.++## A quick checklist++When an agent's bill looks too high for what it's doing, before anything else:++1. **Is caching even on?** Some APIs cache automatically above a token threshold; others require you to+ mark the cacheable prefix explicitly. Know which yours is.+2. **Is the prompt ordered stable-first?** If volatile content is near the front, the cache covers+ almost nothing. Reorder.+3. **Are you rewriting the prefix mid-session?** Find the edit and turn it into an append.+4. **Are agents stalling long enough to lose the cache?** If so, either tighten the loop or accept the+ re-write.+5. **Is the prefix long enough to be worth it?** Tiny prompts that barely repeat don't recover the write+ premium — caching is for the big, oft-repeated scaffolds, which is most agents.++## The bottom line++Prompt caching is the rare optimization that costs almost nothing to adopt and pays back immediately:+you don't change *what* your agent does or *how well* it does it — you just stop paying repeatedly for+the tokens it was always going to send. Pair it with [smart model+routing](/blog/do-more-with-less-model-routing/) and you've pulled the two biggest cost levers an agent+team has: the right model for the task, and full price for the stable prefix exactly once.++Munder Difflin is built to run [a hive](/#how) efficiently — lean models by default, stable shared scaffolds, and+work that keeps flowing. [Download Munder Difflin](https://munderdiffl.in/#install) to run an agent team+that doesn't waste your tokens; it's free and open source.diff --git a/blog/src/posts/small-team-ai-agents-playbook.md b/blog/src/posts/small-team-ai-agents-playbook.mdnew file mode 100644index 00000000..29ef44e2--- /dev/null+++ b/blog/src/posts/small-team-ai-agents-playbook.md@@ -0,0 +1,134 @@+---+title: "A Small-Team Playbook for AI Coding Agents"+description: "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."+date: 2026-06-04+category: guides+categoryLabel: Guides+type: Technical+primaryKeyword: "ai coding agents for small teams"+secondaryKeywords: ["multi-agent playbook", "adopting ai agents", "small team ai workflow"]+tags: ["Guides", "Multi-Agent", "Claude Code", "Workflow"]+author:+ name: Chaitanya Giri+ initials: CG+faq:+ - q: "How many AI agents should a small team start with?"+ a: "Start with one orchestrator and two or three specialists, not ten. A small set is easy to supervise, and you learn the coordination patterns — handoffs, reviews, guardrails — at a scale where mistakes are cheap. Add agents only when a specific bottleneck is begging for one, and let the orchestrator route work to them."+ - q: "What's the biggest mistake teams make adopting agents?"+ a: "Skipping guardrails. Teams wire up agents that can commit, push, and merge freely, then spend their time cleaning up. The fix is to make the safe path the default: branch-only work, a single committer, human approval on anything hard to reverse, and isolated worktrees so agents can't step on each other."+ - q: "Do agents replace code review?"+ a: "No — they add a layer before it. Agents verify their own work and re-verify each other's, which catches the obvious failures early, but a human still approves anything that ships. Think of it as a funnel: cheap automated checks first, scarce human attention last, on the decisions that matter."+---++<div class="callout tldr"><span class="ic">TL;DR</span><p>Adopting AI coding agents as a small team isn't+about having more agents — it's about <strong>roles, cadence, and guardrails</strong>. Start with one+orchestrator plus a few specialists. Run a predictable cadence with file-based handoffs and a shared+board. Make the safe path the default: branch-only work, a single committer, human gates on anything hard+to reverse, and isolated worktrees. Get those three things right and a handful of agents behaves like a+small, reliable team instead of a swarm you're constantly chasing.</p></div>++The instinct when you first run [multiple coding agents](/blog/how-to-run-multiple-claude-code-agents/) is+to launch a dozen and watch them go. It feels productive for about an hour, until two of them edit the+same file, a third pushes a half-finished branch, and you're refereeing instead of building. The teams+that succeed with agents don't have more agents — they have *structure*. This is a practical playbook for+that structure: who does what, how the work flows, and which rails keep it from going off the road.++## Roles: one orchestrator, a few specialists++Treat your agents like a small team with a lead, not a pile of interchangeable workers.++Start with **one orchestrator** — the agent that holds the plan, breaks work into tasks, assigns them, and+decides what's ready to integrate. Everything routes through it, so there's a single place that knows the+state of the world. (This is the role the [GOD orchestrator](/blog/how-the-god-orchestrator-works/) plays+in a hive — the human's proxy on the floor.)++Around it, run **two or three specialists**: maybe one for a feature area, one for review and verification,+one for docs or research. The point isn't rigid job titles — it's that each agent has a *lane*, so when a+task lands you know who it goes to and the agents aren't all reaching for the same files.++Resist scaling the headcount early. A small set is supervisable; you can read every handoff and catch+problems while they're cheap. Add an agent only when a real bottleneck asks for one, and let the+orchestrator [coordinate the work](/blog/coordinating-ai-coding-agents/) rather than having agents+free-lance.++## Cadence: predictable handoffs beat constant chatter++Agents coordinate best the same way a remote team does — asynchronously, in writing, on a rhythm.++**Use file-based handoffs.** Instead of agents interrupting each other, have them drop messages into each+other's inbox as plain files, picked up on the next cycle. [Atomic file mailboxes](/blog/atomic-file-mailboxes-for-agents/)+make this dead simple and debuggable: every request and reply is a file you can read, replay, or audit.+There's no shared mutable channel to corrupt.++**Keep a shared board.** One markdown file the orchestrator owns, holding the current plan and decisions,+gives every agent the same picture without a meeting. It's the team's working memory between cycles.++**Run a standup on an interval.** A periodic check-in — every hour, every morning, whatever fits — where+agents report what they did, what's next, and whether they're still on track, keeps drift from compounding+silently. It's also where you catch two agents about to collide and re-route before they do.++Pair this with durable [markdown memory](/blog/markdown-first-agent-memory/) so the team stops re-learning+the same facts every session. The cadence is what turns a set of independent agents into something that+accumulates progress instead of restarting cold.++## Guardrails: make the safe path the default++This is where most agent adoptions live or die. Capable agents with no rails will eventually do something+expensive. The trick is to make the *safe* action the path of least resistance.++- **Branch-only by default.** Agents work on their own branches and never push or merge on their own. The+ orchestrator (and a human) decide what lands. A bad change stays contained on a branch instead of in main.+- **One committer.** Let exactly one process own commits to the shared repo so concurrent agents never+ corrupt each other's history. The [single-committer pattern](/blog/single-committer-git-pattern/) removes+ a whole class of race conditions.+- **Isolated worktrees.** Give each agent its own [git worktree](/blog/claude-code-git-worktrees-vs-hive/)+ so parallel work physically can't touch the same files. Collisions become impossible instead of merely+ unlikely.+- **Human gates on the hard-to-reverse.** Deploys, merges to main, deleting data, anything outward-facing —+ route those to a [human approval](/blog/human-in-the-loop-ai-agents/) step. Agents propose; a person+ disposes on the decisions that actually carry risk.+- **Scope the task.** Tell an agent exactly which files or directories a task may touch, and have it report+ the diff. A tight scope makes a wandering agent obvious immediately.+- **Verify, don't trust.** Require every "done" to come with evidence — the command that was run and its+ output — and have a second agent re-run the checks before integration. Plausible isn't the same as+ checked.++None of these slow a good agent down. They just make the failure modes shallow and recoverable, which is+the whole game when you're not watching every keystroke.++## A realistic first week++You don't need all of this on day one. A sane rollout:++1. **Day 1–2:** Run one orchestrator and one specialist on a low-stakes task. Turn on branch-only and a+ single committer first — those two rails alone prevent most early messes.+2. **Day 3–4:** Add a shared board and file-based handoffs. Introduce a standup so you get a written pulse+ of what the agents are doing.+3. **Day 5+:** Add a second specialist and isolated worktrees so they run in parallel. Add the human gate+ on merges and deploys. Now you have a small team you can leave running and trust to stop at the lines+ that matter.++Grow from there only when a bottleneck demands it. The structure scales; the chaos of "just add agents"+does not.++## FAQ++**Can a small team really benefit, or is this just for big orgs?** Small teams benefit most — you're the+ones short on hands. A handful of well-coordinated agents covers the tedious breadth (tests, docs,+research, cleanup) so the humans spend time on the decisions only they can make.++**What if an agent does something wrong?** With branch-only work and a single committer, "wrong" lives on a+branch you can throw away. That's the point of the guardrails: make mistakes cheap and reversible so you+can let agents work without hovering.++**How is this different from just running several chat sessions?** Sessions don't share memory, a board, or+a committer, so they duplicate work and collide. A [coordinated hive](/blog/run-an-office-of-ai-agents/)+gives them a shared picture and rails — that's the difference between several tools and one team.++---++Munder Difflin gives a small team exactly this playbook out of the box — an orchestrator, file-based+handoffs, shared memory, and [the guardrails that keep a hive safe](https://munderdiffl.in/#how), all+running locally on your machine.+[Download Munder Difflin](https://munderdiffl.in/#install) to put a small team of agents to work today;+it's free and open source.diff --git a/docs/blog/ai-agent-glossary/index.html b/docs/blog/ai-agent-glossary/index.htmlindex 852851c5..6b8554b7 100644--- a/docs/blog/ai-agent-glossary/index.html+++ b/docs/blog/ai-agent-glossary/index.html@@ -284,20 +284,20 @@ Munder Difflin</a> to see the glossary come to life — free and open source.</p</div></article><article class="card">- <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/what-is-aeo-for-dev-tools/">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</a></h3>- <p class="dek">Answer Engine Optimization for dev tools: how to get cited by ChatGPT, Claude, and Perplexity with the right robots.txt, JSON-LD, and writing patterns.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/what-is-aeo-for-dev-tools/" aria-label="Read: AEO for Dev Tools: Getting Cited by ChatGPT and Claude">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article>diff --git a/docs/blog/can-claude-code-agents-talk-to-each-other/index.html b/docs/blog/can-claude-code-agents-talk-to-each-other/index.htmlindex 0f74f9c6..690bec12 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@@ -304,38 +304,38 @@ other; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/what-is-aeo-for-dev-tools/">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</a></h3>- <p class="dek">Answer Engine Optimization for dev tools: how to get cited by ChatGPT, Claude, and Perplexity with the right robots.txt, JSON-LD, and writing patterns.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/what-is-aeo-for-dev-tools/" aria-label="Read: AEO for Dev Tools: Getting Cited by ChatGPT and Claude">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/ai-agent-glossary/">The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent</a></h3>- <p class="dek">Plain-English definitions of the AI coding agent terms everyone trips over — harness, orchestrator, hive, subagent, agent memory — each in one line.</p>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/ai-agent-glossary/" aria-label="Read: The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent">Read →</a>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">Read →</a></div></div></article>diff --git a/docs/blog/claude-code-git-worktrees-vs-hive/index.html b/docs/blog/claude-code-git-worktrees-vs-hive/index.htmlindex b90813cc..0870aa4b 100644--- a/docs/blog/claude-code-git-worktrees-vs-hive/index.html+++ b/docs/blog/claude-code-git-worktrees-vs-hive/index.html@@ -291,56 +291,56 @@ team; it’s free and open source.</p><h2>Related in Orchestration</h2><div class="post-grid"><article class="card">- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>- <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p>+ <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a>+ <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/how-the-god-orchestrator-works/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-05-30">May 30, 2026</time>+ <time datetime="2026-06-02">Jun 2, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/how-the-god-orchestrator-works/">Inside the GOD Orchestrator: Routing, Adjudication, Escalation</a></h3>- <p class="dek">A deep dive into the Claude Code orchestrator: how a GOD agent reads requests, routes work, adjudicates routine traffic, and escalates the critical few.</p>+ <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>+ <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/how-the-god-orchestrator-works/" aria-label="Read: Inside the GOD Orchestrator: Routing, Adjudication, Escalation">Read →</a>+ <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a></div></div></article>diff --git a/docs/blog/claude-code-orchestration-guide/index.html b/docs/blog/claude-code-orchestration-guide/index.htmlindex fcdd8199..76e578b0 100644--- a/docs/blog/claude-code-orchestration-guide/index.html+++ b/docs/blog/claude-code-orchestration-guide/index.html@@ -307,38 +307,38 @@ agents; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>- <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p>+ <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a>+ <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a></div></div></article>diff --git a/docs/blog/coordinating-ai-coding-agents/index.html b/docs/blog/coordinating-ai-coding-agents/index.htmlindex 2b3ef854..9c4f1463 100644--- a/docs/blog/coordinating-ai-coding-agents/index.html+++ b/docs/blog/coordinating-ai-coding-agents/index.html@@ -294,38 +294,38 @@ your own team of Claude Code agents.</p></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>- <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p>+ <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a>+ <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a></div></div></article>diff --git a/docs/blog/do-more-with-less-model-routing/index.html b/docs/blog/do-more-with-less-model-routing/index.htmlindex db0c741f..03ad945e 100644--- a/docs/blog/do-more-with-less-model-routing/index.html+++ b/docs/blog/do-more-with-less-model-routing/index.html@@ -293,38 +293,38 @@ agent team that does more with less — it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/what-is-aeo-for-dev-tools/">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</a></h3>- <p class="dek">Answer Engine Optimization for dev tools: how to get cited by ChatGPT, Claude, and Perplexity with the right robots.txt, JSON-LD, and writing patterns.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/what-is-aeo-for-dev-tools/" aria-label="Read: AEO for Dev Tools: Getting Cited by ChatGPT and Claude">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/ai-agent-glossary/">The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent</a></h3>- <p class="dek">Plain-English definitions of the AI coding agent terms everyone trips over — harness, orchestrator, hive, subagent, agent memory — each in one line.</p>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/ai-agent-glossary/" aria-label="Read: The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent">Read →</a>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">Read →</a></div></div></article>diff --git a/docs/blog/feed.xml b/docs/blog/feed.xmlindex babf78d9..ca983331 100644--- a/docs/blog/feed.xml+++ b/docs/blog/feed.xml@@ -103,6 +103,14 @@<updated>2026-06-04T00:00:00.000Z</updated><category term="Memory" /><summary>A code-grounded guide to how AI agents remember — the MemPalace mine loop, per-agent wings, and wake-up digest that give a Claude Code hive shared recall.</summary></entry>+ <entry>+ <title>How AI Agents Verify Their Own Work (Before Saying 'Done')</title>+ <link href="https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/" />+ <id>https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />+ <summary>The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</summary>+ </entry><entry><title>Keep Your Agent's Semantic Memory Clean: Don't Index the Config</title><link href="https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/" />@@ -111,6 +119,38 @@<updated>2026-06-04T00:00:00.000Z</updated><category term="Memory" /><summary>A semantic memory layer is only as good as what you feed it — how an agent's recall got swamped by config and logs, and the .gitignore + prune fix.</summary></entry>+ <entry>+ <title>Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</title>+ <link href="https://munderdiffl.in/blog/local-first-ai-agent-orchestration/" />+ <id>https://munderdiffl.in/blog/local-first-ai-agent-orchestration/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Orchestration" />+ <summary>How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</summary>+ </entry>+ <entry>+ <title>Building AI Dev Tools in the Open, On Purpose</title>+ <link href="https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/" />+ <id>https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />+ <summary>Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</summary>+ </entry>+ <entry>+ <title>Overnight AI Coding: What's Realistic (and What's Not)</title>+ <link href="https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/" />+ <id>https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Use Cases" />+ <summary>An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</summary>+ </entry>+ <entry>+ <title>Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</title>+ <link href="https://munderdiffl.in/blog/prompt-caching-for-ai-agents/" />+ <id>https://munderdiffl.in/blog/prompt-caching-for-ai-agents/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />+ <summary>An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</summary>+ </entry><entry><title>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</title><link href="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />@@ -119,6 +159,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>A Small-Team Playbook for AI Coding Agents</title>+ <link href="https://munderdiffl.in/blog/small-team-ai-agents-playbook/" />+ <id>https://munderdiffl.in/blog/small-team-ai-agents-playbook/</id>+ <published>2026-06-04T00:00:00.000Z</published>+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />+ <summary>How a small team adopts a hive of AI coding agents without chaos — the roles to assign, the cadence to run, and the guardrails that keep it safe.</summary>+ </entry><entry><title>AEO for Dev Tools: Getting Cited by ChatGPT and Claude</title><link href="https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/" />diff --git a/docs/blog/from-one-terminal-to-a-team/index.html b/docs/blog/from-one-terminal-to-a-team/index.htmlindex b89776e8..8332e1a0 100644--- a/docs/blog/from-one-terminal-to-a-team/index.html+++ b/docs/blog/from-one-terminal-to-a-team/index.html@@ -249,6 +249,24 @@ jump; it’s free and open source.</p><h2>Related in Use Cases</h2><div class="post-grid"><article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/how-agents-remember-semantic-memory/index.html b/docs/blog/how-agents-remember-semantic-memory/index.htmlindex e4481a5d..3409b461 100644--- a/docs/blog/how-agents-remember-semantic-memory/index.html+++ b/docs/blog/how-agents-remember-semantic-memory/index.html@@ -283,7 +283,7 @@ open source.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/keep-agent-semantic-memory-clean/"><span class="k">← Older</span><span class="t">Keep Your Agent's Semantic Memory Clean: Don't Index the Config</span></a>+ <a class="pn prev" href="/blog/how-ai-agents-verify-their-own-work/"><span class="k">← Older</span><span class="t">How AI Agents Verify Their Own Work (Before Saying 'Done')</span></a><a class="pn next" href="/blog/do-more-with-less-model-routing/"><span class="k">Newer →</span><span class="t">Do More With Less: Smart Model Routing Across Agents</span></a></div><section class="related">diff --git a/docs/blog/how-ai-agents-verify-their-own-work/index.html b/docs/blog/how-ai-agents-verify-their-own-work/index.htmlnew file mode 100644index 00000000..b5d7c618--- /dev/null+++ b/docs/blog/how-ai-agents-verify-their-own-work/index.html@@ -0,0 +1,373 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>How AI Agents Verify Their Own Work (Before Saying 'Done') — Munder Difflin Blog</title>+<meta name="description" content="The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent." />+<link rel="canonical" href="https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/" />++<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />+<meta name="theme-color" content="#F5F2E8" />++<!-- Open Graph -->+<meta property="og:site_name" content="Munder Difflin Blog" />+<meta property="og:type" content="article" />+<meta property="og:title" content="How AI Agents Verify Their Own Work (Before Saying 'Done') — Munder Difflin Blog" />+<meta property="og:description" content="The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent." />+<meta property="og:url" content="https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/" />+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />+<meta property="og:locale" content="en_US" />+<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Concepts" />+<meta property="article:tag" content="Multi-Agent" />+<meta property="article:tag" content="Claude Code" />+<meta property="article:tag" content="Reliability" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="How AI Agents Verify Their Own Work (Before Saying 'Done') — Munder Difflin Blog" />+<meta name="twitter:description" content="The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent." />+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />++<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />+<link rel="preconnect" href="https://fonts.googleapis.com" />+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />+<link rel="stylesheet" href="/blog/assets/blog.css" />++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "BlogPosting",+ "headline": "How AI Agents Verify Their Own Work (Before Saying 'Done')",+ "description": "The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.",+ "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/how-ai-agents-verify-their-own-work/" },+ "keywords": "ai agent self-verification, verify ai agent output, reproducible agent checks, autonomous coding agent reliability",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/"+}+</script>+<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "BreadcrumbList",+ "itemListElement": [+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },+ { "@type": "ListItem", "position": 3, "name": "How AI Agents Verify Their Own Work (Before Saying 'Done')", "item": "https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Why do AI coding agents report success when the work is actually broken?", "acceptedAnswer": { "@type": "Answer", "text": "Because generating a confident summary is easy and checking it is work. A model will happily write 'typecheck passes, build is green' from intent rather than evidence unless the harness forces it to actually run the commands and read the output. The fix isn't a better model — it's making the agent prove each claim with a command whose output it pastes back." } },+ { "@type": "Question", "name": "What does it mean to verify a fix 'reproducibly'?", "acceptedAnswer": { "@type": "Answer", "text": "It means the check passes in a clean environment the reviewer can reproduce — not one that happens to work because of leftover state. An agent in a fresh git worktree with no installed dependencies can't honestly say 'build is green' until it actually has them; otherwise the claim is unverifiable. Reproducible means: same inputs, same commands, same green, on another machine." } },+ { "@type": "Question", "name": "Should a second agent re-verify the first agent's work?", "acceptedAnswer": { "@type": "Answer", "text": "For anything that integrates or ships, yes. Independent re-verification catches the failure mode where an agent's self-check was subtly wrong — it re-runs the checks from scratch and confirms the diff is exactly what was claimed. It's cheap insurance against a confident but wrong 'done'." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/concepts/">Concepts</a>+ </nav>+ <h1>How AI Agents Verify Their Own Work (Before Saying 'Done')</h1>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</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">Concepts</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p>An autonomous agent's most useful skill isn't+writing code — it's <strong>not lying to you by accident</strong>. The discipline: prove every claim with+a command whose output you can read, run the check in an environment a reviewer can <strong>reproduce</strong>,+verify the <em>fix</em> rather than the <em>intent</em>, and have a second agent re-verify anything that+ships. "Done" should mean "checked," not "looks right."</p></div>+<p>The scariest output from an autonomous coding agent isn’t an error — it’s a confident “✅ done, all tests+pass” that nobody ran. An error you can see; a false green you trust, ship, and discover in production.</p>+<p>If you run <a href="/blog/claude-code-automation-while-you-sleep/">agents that work while you sleep</a>, what decides+whether you wake up to progress or a mess isn’t how smart the model is. It’s how rigorously the agent+verifies its own work before it says it’s finished. Here’s the discipline, drawn from how agents actually+operate inside a hive.</p>+<h2 id="the-core-failure-plausible-beats-checked" tabindex="-1">The core failure: plausible beats checked <a class="anchor" href="#the-core-failure-plausible-beats-checked" aria-hidden="true">#</a></h2>+<p>A language model is very good at producing a <em>plausible</em> summary. Asked whether the build passes, it can+write a fluent “build is green, typecheck clean” with zero commands run — because the sentence is likely,+not because it’s true. That’s the central reliability problem of autonomous agents: <strong>generating a claim+is cheaper than verifying it</strong>, so without pressure the agent drifts to the cheap path.</p>+<p>The fix is structural, not motivational. You don’t ask the agent to “be careful.” You make every factual+claim cost a command:</p>+<ul>+<li>“Typecheck passes” → run it, paste the tail of the output.</li>+<li>“The fix removes the noise” → show the before <em>and</em> after, not a description of the after.</li>+<li>“Only two files changed” → <code>git diff --stat</code>, not memory.</li>+</ul>+<p>A claim with no command behind it is a guess wearing a lab coat. Treat your own output as untrusted until+a tool confirms it.</p>+<h2 id="reproducible-or-it-didnt-happen" tabindex="-1">Reproducible, or it didn’t happen <a class="anchor" href="#reproducible-or-it-didnt-happen" aria-hidden="true">#</a></h2>+<p>Here’s a real trap. An agent works in an isolated <a href="/blog/claude-code-git-worktrees-vs-hive/">git worktree</a>+— a clean checkout on its own branch — edits code, and reports “typecheck and build both green.”</p>+<p>But a fresh worktree has <strong>no <code>node_modules</code></strong>. If the agent never installed or linked dependencies, the+build would have errored immediately — so a “green” report is at best unverifiable and at worst fabricated+from intent. The reviewer pulls the branch, runs the same command, gets a wall of “cannot find module,”+and now trusts nothing the agent said.</p>+<p>The discipline is <em>reproducibility</em>: a check only counts if it passes in an environment the reviewer can+recreate. In a fresh worktree, make the dependencies real <em>before</em> claiming green:</p>+<pre class="language-bash"><code class="language-bash"><span class="token function">ln</span> <span class="token parameter variable">-s</span> <span class="token punctuation">..</span>/main/node_modules ./node_modules <span class="token comment"># link the main checkout's deps</span>+<span class="token function">npm</span> run typecheck <span class="token comment"># now this is a claim you can stand behind</span>+<span class="token function">npm</span> run build <span class="token comment"># paste the result — green that reproduces is green</span></code></pre>+<p>“It works on my branch” is worthless if your branch is a state no one else can reach.</p>+<h2 id="verify-the-fix-not-the-intent" tabindex="-1">Verify the fix, not the intent <a class="anchor" href="#verify-the-fix-not-the-intent" aria-hidden="true">#</a></h2>+<p>A subtler failure than skipping the check: running a check that doesn’t prove the thing you fixed. You+patched the cause, the code compiles, so you call it done — but you never confirmed the <em>symptom</em> is gone.</p>+<p>A real example from agent memory hygiene. The task: stop a <a href="/blog/semantic-memory-for-ai-agents/">semantic memory</a>+indexer from ingesting config files that swamped recall. The fix added an ignore rule so the miner skipped+them; typecheck and build passed — intent satisfied. But re-running the indexer showed the noise <em>still+there</em>, because mining is <strong>additive</strong>: it stops filing new junk but doesn’t delete what’s already indexed.+The fix was correct and incomplete at once. Only checking the actual symptom — running the recall digest+and reading it — surfaced the gap, which needed a separate prune pass to truly clean the index.</p>+<p>The lesson generalizes: <strong>decide what “fixed” looks like as an observable, then observe it.</strong> Not “the code+changed” — “the broken behavior is gone, here’s the before and after.”</p>+<blockquote>+<p><strong>Rule of thumb:</strong> a fix isn’t verified by the change that caused it. It’s verified by the absence of the+problem it was meant to remove. Show the problem gone, with evidence.</p>+</blockquote>+<h2 id="a-second-pair-of-eyes" tabindex="-1">A second pair of eyes <a class="anchor" href="#a-second-pair-of-eyes" aria-hidden="true">#</a></h2>+<p>Self-verification catches most of it. For anything that integrates or ships, add one layer: a different+agent re-runs the checks from scratch and confirms the diff is exactly what was claimed.</p>+<p>This isn’t bureaucracy — it catches the case where an agent’s <em>own</em> verification was subtly wrong (checked+the wrong file, ran in a dirty environment, misread output). In practice it looks like an+<a href="/blog/how-the-god-orchestrator-works/">orchestrator</a> independently re-running the typecheck and confirming+“exactly these two files changed, zero stray bytes, passes here too” before folding the work in. It pairs+naturally with <a href="/blog/human-in-the-loop-ai-agents/">human-in-the-loop gates</a>: the agent verifies, a peer+re-verifies, and the human approves what’s hard to reverse. Each layer assumes the one before it can be+wrong — which is why the chain holds.</p>+<h2 id="a-self-verification-checklist" tabindex="-1">A self-verification checklist <a class="anchor" href="#a-self-verification-checklist" aria-hidden="true">#</a></h2>+<p>Before an agent writes “done,” it should answer yes to all of these:</p>+<ul>+<li><strong>Did I run it, or imagine it?</strong> Every claim has a command and visible output behind it.</li>+<li><strong>Can someone else reproduce my green?</strong> No leftover state, uninstalled deps, or dirty tree.</li>+<li><strong>Did I verify the symptom, not just the change?</strong> Before/after evidence the problem is gone.</li>+<li><strong>Is the diff exactly what I claimed?</strong> Scope respected, no surprise files, no binary cruft.</li>+<li><strong>What did I <em>not</em> check?</strong> Name the gaps — a stated limitation beats a silent one.</li>+</ul>+<p>That last point matters most. An agent that says “typecheck and build pass, but the runtime behavior needs+a real app launch I can’t do from here” is <em>more</em> trustworthy than one claiming everything is perfect.+Calibrated honesty about what wasn’t verified is itself a form of verification — it tells the human exactly+where to look. Verification is what converts raw <a href="/blog/coordinating-ai-coding-agents/">capability</a> into+<em>reliable</em> capability.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>Why do agents report success when the work is broken?</strong> Because writing a confident summary is easier+than checking one. Unless the harness forces the agent to run the command and read the output, it fills in+a plausible result. Make every claim earn a command.</p>+<p><strong>What makes a check “reproducible”?</strong> It passes in a clean environment someone else can recreate — not one+that works only because of leftover state. Same inputs, same commands, same green, on another machine.</p>+<p><strong>Does this replace human review?</strong> No — it front-loads it. Agents verify and re-verify each other to catch+the obvious failures cheaply, so scarce human attention lands on the decisions that actually carry risk.</p>+<hr>+<p>Munder Difflin runs a hive of Claude Code agents that verify their own work and+<a href="https://munderdiffl.in/#how">re-verify each other’s before anything integrates</a> — locally, with a human+gate on anything that ships.+<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">Why do AI coding agents report success when the work is actually broken?</p>+ <p class="a">Because generating a confident summary is easy and checking it is work. A model will happily write 'typecheck passes, build is green' from intent rather than evidence unless the harness forces it to actually run the commands and read the output. The fix isn't a better model — it's making the agent prove each claim with a command whose output it pastes back.</p>+ </div>++ <div class="qa">+ <p class="q">What does it mean to verify a fix 'reproducibly'?</p>+ <p class="a">It means the check passes in a clean environment the reviewer can reproduce — not one that happens to work because of leftover state. An agent in a fresh git worktree with no installed dependencies can't honestly say 'build is green' until it actually has them; otherwise the claim is unverifiable. Reproducible means: same inputs, same commands, same green, on another machine.</p>+ </div>++ <div class="qa">+ <p class="q">Should a second agent re-verify the first agent's work?</p>+ <p class="a">For anything that integrates or ships, yes. Independent re-verification catches the failure mode where an agent's self-check was subtly wrong — it re-runs the checks from scratch and confirms the diff is exactly what was claimed. It's cheap insurance against a confident but wrong 'done'.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/concepts/">Concepts</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a><a class="tag" href="/blog/tags/reliability/">Reliability</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-failure-plausible-beats-checked">The core failure: plausible beats checked</a></li><li class="lvl-2"><a href="#reproducible-or-it-didnt-happen">Reproducible, or it didn’t happen</a></li><li class="lvl-2"><a href="#verify-the-fix-not-the-intent">Verify the fix, not the intent</a></li><li class="lvl-2"><a href="#a-second-pair-of-eyes">A second pair of eyes</a></li><li class="lvl-2"><a href="#a-self-verification-checklist">A self-verification checklist</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/keep-agent-semantic-memory-clean/"><span class="k">← Older</span><span class="t">Keep Your Agent's Semantic Memory Clean: Don't Index the Config</span></a>+ <a class="pn next" href="/blog/how-agents-remember-semantic-memory/"><span class="k">Newer →</span><span class="t">How AI Agents Remember: Semantic Memory in a Hive</span></a>+ </div>+ <section class="related">+ <h2>Related in Concepts</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>+ <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/do-more-with-less-model-routing/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>+ <p class="dek">Why a hive of agents shouldn't all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/do-more-with-less-model-routing/" aria-label="Read: Do More With Less: Smart Model Routing Across Agents">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">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/how-the-god-orchestrator-works/index.html b/docs/blog/how-the-god-orchestrator-works/index.htmlindex d545b209..605c28e4 100644--- a/docs/blog/how-the-god-orchestrator-works/index.html+++ b/docs/blog/how-the-god-orchestrator-works/index.html@@ -336,38 +336,38 @@ to put one in charge of your floor; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>5 min</span>+ <span>6 min</span></div>- <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>- <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p>+ <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a>+ <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a></div></div></article>diff --git a/docs/blog/human-in-the-loop-ai-agents/index.html b/docs/blog/human-in-the-loop-ai-agents/index.htmlindex 40f6cec8..6526a686 100644--- a/docs/blog/human-in-the-loop-ai-agents/index.html+++ b/docs/blog/human-in-the-loop-ai-agents/index.html@@ -297,38 +297,38 @@ and ask only when they should; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>6 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>- <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/how-the-god-orchestrator-works/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-05-30">May 30, 2026</time>+ <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/how-the-god-orchestrator-works/">Inside the GOD Orchestrator: Routing, Adjudication, Escalation</a></h3>- <p class="dek">A deep dive into the Claude Code orchestrator: how a GOD agent reads requests, routes work, adjudicates routine traffic, and escalates the critical few.</p>+ <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/how-the-god-orchestrator-works/" aria-label="Read: Inside the GOD Orchestrator: Routing, Adjudication, Escalation">Read →</a>+ <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a></div></div></article>diff --git a/docs/blog/index.html b/docs/blog/index.htmlindex 9c2161fd..392ea83a 100644--- a/docs/blog/index.html+++ b/docs/blog/index.html@@ -85,21 +85,21 @@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">50</span></a>+ <a class="chip" aria-current="page">All<span class="ct">56</span></a>- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>@@ -329,6 +329,24 @@</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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1"><span>MEMORY</span>@@ -347,6 +365,78 @@</div></div></article>+<article class="card">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/prompt-caching-for-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/prompt-caching-for-ai-agents/">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</a></h3>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/prompt-caching-for-ai-agents/" aria-label="Read: Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span>@@ -365,6 +455,24 @@</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>+ </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/small-team-ai-agents-playbook/">A Small-Team Playbook for AI Coding Agents</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/small-team-ai-agents-playbook/" aria-label="Read: A Small-Team Playbook for AI Coding Agents">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/keep-agent-semantic-memory-clean/index.html b/docs/blog/keep-agent-semantic-memory-clean/index.htmlindex 35a574a4..c2319314 100644--- a/docs/blog/keep-agent-semantic-memory-clean/index.html+++ b/docs/blog/keep-agent-semantic-memory-clean/index.html@@ -282,8 +282,8 @@ sticks; it’s free and open source.</p></div><footer class="post-foot wrap"><div class="prevnext">- <a class="pn prev" href="/blog/scheduling-autonomous-agent-missions/"><span class="k">← Older</span><span class="t">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</span></a>- <a class="pn next" href="/blog/how-agents-remember-semantic-memory/"><span class="k">Newer →</span><span class="t">How AI Agents Remember: Semantic Memory in a Hive</span></a>+ <a class="pn prev" href="/blog/local-first-ai-agent-orchestration/"><span class="k">← Older</span><span class="t">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</span></a>+ <a class="pn next" href="/blog/how-ai-agents-verify-their-own-work/"><span class="k">Newer →</span><span class="t">How AI Agents Verify Their Own Work (Before Saying 'Done')</span></a></div><section class="related"><h2>Related in Memory</h2>diff --git a/docs/blog/local-first-ai-agent-orchestration/index.html b/docs/blog/local-first-ai-agent-orchestration/index.htmlnew file mode 100644index 00000000..2db24bab--- /dev/null+++ b/docs/blog/local-first-ai-agent-orchestration/index.html@@ -0,0 +1,385 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud — Munder Difflin Blog</title>+<meta name="description" content="How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine." />+<link rel="canonical" href="https://munderdiffl.in/blog/local-first-ai-agent-orchestration/" />++<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="Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud — Munder Difflin Blog" />+<meta property="og:description" content="How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine." />+<meta property="og:url" content="https://munderdiffl.in/blog/local-first-ai-agent-orchestration/" />+<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="Orchestration" />+<meta property="article:tag" content="Local-First" />+<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="Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud — Munder Difflin Blog" />+<meta name="twitter:description" content="How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine." />+<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": "Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud",+ "description": "How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.",+ "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/local-first-ai-agent-orchestration/" },+ "keywords": "local-first ai agent orchestration, orchestrate ai agents locally, no-server agent coordination, local multi-agent architecture",+ "articleSection": "Orchestration",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/local-first-ai-agent-orchestration/"+}+</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": "Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud", "item": "https://munderdiffl.in/blog/local-first-ai-agent-orchestration/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is local-first AI agent orchestration?", "acceptedAnswer": { "@type": "Answer", "text": "It's coordinating multiple AI agents — routing work between them, scheduling tasks, storing memory — entirely on your own machine instead of a vendor's cloud. The agents still call the model API, but the control plane (the loop, the message router, the scheduler, the audit log) runs as local processes and reads and writes local files." } },+ { "@type": "Question", "name": "Do you need a server or message broker to coordinate AI agents?", "acceptedAnswer": { "@type": "Answer", "text": "No. A hive can coordinate through plain files: each agent has an inbox and outbox folder, and a small router process drains outboxes into the right inboxes on a timer. There's no Redis, no queue service, no daemon to keep alive — delivery is an atomic file rename, so it's safe under concurrency without locks." } },+ { "@type": "Question", "name": "What are the limits of orchestrating agents on one machine?", "acceptedAnswer": { "@type": "Answer", "text": "Two real ones. The orchestration only runs while your machine is on — timers and the router live in a local process, so closing the app pauses the schedule. And concurrency is bounded by your CPU and RAM rather than an elastic cloud. In exchange you get zero infrastructure, a full local audit trail, and complete ownership of your data." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/orchestration/">Orchestration</a>+ </nav>+ <h1>Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</h1>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="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">Orchestration</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Local-first orchestration</strong>+means the whole control plane for a team of agents — the loop that keeps them working, the+<strong>message router</strong>, the <strong>scheduler</strong>, and the <strong>audit log</strong> —+runs as processes on <em>your</em> machine and coordinates through <em>local files</em>, not a cloud+service. Agents are local child processes; they talk through inbox/outbox folders drained by an+in-process router; tasks fire on local timers; git is the audit trail. No broker, no queue service, no+control-plane server. This is the <em>how</em>; for the <em>why</em>, see <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters</a>.</p></div>+<p>It’s one thing to argue that keeping your agents <a href="/blog/why-local-first-matters-for-ai-agents/">on your own+machine</a> is better for control, privacy, and cost. It’s+another to explain how a team of agents actually <em>coordinates</em> without a cloud control plane in the+middle. If there’s no orchestration server, what routes the work? This post is the mechanics —+grounded in how Munder Difflin’s hive is built — of running real multi-agent orchestration with nothing+but local processes and files.</p>+<h2 id="where-the-orchestration-loop-actually-runs" tabindex="-1">Where the orchestration loop actually runs <a class="anchor" href="#where-the-orchestration-loop-actually-runs" aria-hidden="true">#</a></h2>+<p>Start with the obvious question: what is “the orchestrator”? In a cloud platform it’s a service you+never see. Locally, it’s just a process on your machine — in Munder Difflin’s case, the desktop app’s+main process. It boots the message router, arms the scheduler, and manages the agents. There’s no+remote brain; the coordination logic is code running next to your editor.</p>+<p>The agents themselves are equally concrete. Each one is a <strong>local child process</strong> — the harness spawns+the <code>claude</code> CLI through <a href="/blog/node-pty-electron-real-terminals/">node-pty</a>, the same way a terminal+would, and talks to it over a pseudo-terminal. An “agent” isn’t an abstraction in someone’s datacenter;+it’s a real OS process you could see in your activity monitor. The model call goes out to the API; the+agent that makes it lives on your box.</p>+<h2 id="coordination-without-a-broker" tabindex="-1">Coordination without a broker <a class="anchor" href="#coordination-without-a-broker" aria-hidden="true">#</a></h2>+<p>The interesting part is how those local processes talk to each other. The instinct from distributed+systems is to reach for a message broker — Redis, RabbitMQ, a cloud queue. A local-first hive does+something far simpler: <strong>files</strong>.</p>+<p>Every agent gets a workspace with an <code>inbox/</code> and an <code>outbox/</code> folder. To send a message, an agent+writes one JSON file into its own outbox. A small <strong>router</strong>, running on a timer inside the main+process, scans every outbox on each tick and delivers what it finds — moving the message into the+recipient’s inbox with an atomic write. (In the code, that’s a <code>routerTimer</code> driving a <code>deliver()</code>+step that writes each message into the target’s inbox folder; a <code>broadcast</code> simply fans the same+message out to every agent’s inbox.)</p>+<p>That one design decision buys a lot, and we unpack it fully in <a href="/blog/atomic-file-mailboxes-for-agents/">atomic file mailboxes for+agents</a>:</p>+<ul>+<li><strong>No infrastructure.</strong> The “message bus” is a directory and the rename syscall. Nothing to install,+nothing to keep alive.</li>+<li><strong>Conflict-free concurrency.</strong> Each file has exactly one writer and delivery is an atomic rename, so+busy agents never corrupt each other’s mail — no locks required.</li>+<li><strong>Durable and replayable.</strong> Messages are files. A crash loses nothing already written, and you can+read the whole exchange back later.</li>+</ul>+<p>It’s the backbone of <a href="/blog/coordinating-ai-coding-agents/">how a hive coordinates its agents</a>, and it+never leaves your disk.</p>+<h2 id="scheduling-on-your-own-clock" tabindex="-1">Scheduling on your own clock <a class="anchor" href="#scheduling-on-your-own-clock" aria-hidden="true">#</a></h2>+<p>Recurring work doesn’t need a cloud cron either. The scheduler arms ordinary in-process timers — a+<code>setTimeout</code> into a steady <code>setInterval</code> — and when one fires it just drops a <code>request</code> message into an+agent’s inbox, exactly like any other message. Each mission remembers when it last fired, so restarts+resume the cadence instead of resetting it. The full mechanism is in <a href="/blog/scheduling-autonomous-agent-missions/">scheduling autonomous agent+missions</a>. The point for orchestration: your hive’s sense+of time is a timer in a process on your laptop, not a job in someone’s scheduler.</p>+<h2 id="state-that-never-leaves-the-box" tabindex="-1">State that never leaves the box <a class="anchor" href="#state-that-never-leaves-the-box" aria-hidden="true">#</a></h2>+<p>Coordination also needs memory, and here too everything is local:</p>+<ul>+<li><strong>Config</strong> lives in a plain JSON file on disk — which agents exist, which missions are armed, your+preferences.</li>+<li><strong>Per-agent memory</strong> is a markdown file each agent reads at the start of a task and appends to as it+learns.</li>+<li><strong>The audit log is git.</strong> A <a href="/blog/single-committer-git-pattern/">single committer</a> — the+orchestrator process — records the message and file changes, so “who did what, in what order” is+answerable from your own repo history, not a vendor’s dashboard.</li>+<li><strong>Semantic memory</strong> runs locally too: a <a href="/blog/semantic-memory-for-ai-agents/">searchable knowledge store</a>+the whole team can query, indexed on your machine.</li>+</ul>+<p>Nothing in that list is a network call. The team’s shared brain is a folder you own.</p>+<h2 id="the-loop-is-local-too" tabindex="-1">The loop is local, too <a class="anchor" href="#the-loop-is-local-too" aria-hidden="true">#</a></h2>+<p>What keeps an agent <em>going</em> without you clicking “continue”? A local hook. When an agent finishes a+turn, a Stop hook checks its inbox; if fresh messages are waiting, it tells the agent to keep working,+and when the queue is empty it lets the agent rest. That’s the <a href="/blog/claude-code-automation-while-you-sleep/">autonomous+loop</a> — and it’s wired through the same local files, run+by <a href="/blog/how-the-god-orchestrator-works/">the orchestrator</a> on your machine, with no remote scheduler+deciding when your agents wake up.</p>+<h2 id="what-it-costs-and-what-you-keep" tabindex="-1">What it costs — and what you keep <a class="anchor" href="#what-it-costs-and-what-you-keep" aria-hidden="true">#</a></h2>+<p>Local-first orchestration isn’t free of trade-offs, and it’s worth being honest about them:</p>+<ul>+<li><strong>It runs while your machine does.</strong> The router and the timers are in a local process, so closing the+app pauses delivery and the schedule. Overdue missions catch up on the next launch, but there’s no+always-on cloud firing at 3 a.m. with the lid shut.</li>+<li><strong>Concurrency is bounded by your hardware.</strong> You scale with your own CPU and RAM, not an elastic+fleet. For a team of agents working one codebase, that’s usually plenty — but it’s a ceiling, not a+dial you pay to raise.</li>+</ul>+<p>In return you get the things a control-plane server quietly takes away: <strong>zero infrastructure</strong> to run+or secure, a <strong>complete audit trail</strong> in your own git history, and <strong>full ownership</strong> of your code,+messages, and memory. For agents that touch your whole project, that trade is the whole point — and+it’s the practical side of <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters</a>.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>What is local-first AI agent orchestration?</strong> Coordinating multiple agents — routing work,+scheduling tasks, storing memory — entirely on your own machine. The agents call the model API, but the+control plane (loop, router, scheduler, audit log) is local code reading and writing local files.</p>+<p><strong>Do I need a server or broker to coordinate agents?</strong> No. Agents coordinate through inbox/outbox+folders that a small router drains on a timer, delivering messages with atomic file renames. No Redis,+no queue service, no daemon.</p>+<p><strong>What are the limits?</strong> Orchestration only runs while your machine is on, and concurrency is bounded by+your hardware. In exchange you get no infrastructure, a full local audit trail, and complete data+ownership.</p>+<hr>+<p>Munder Difflin is local-first orchestration you can watch: a hive of Claude Code agents coordinating+through file mailboxes, local timers, and a git audit log — <a href="https://munderdiffl.in/#how">all run by a GOD+orchestrator</a> on your own machine. <a href="https://munderdiffl.in/#install">Download Munder+Difflin</a> to run a coordinated team of agents with no cloud in the+loop; 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 is local-first AI agent orchestration?</p>+ <p class="a">It's coordinating multiple AI agents — routing work between them, scheduling tasks, storing memory — entirely on your own machine instead of a vendor's cloud. The agents still call the model API, but the control plane (the loop, the message router, the scheduler, the audit log) runs as local processes and reads and writes local files.</p>+ </div>++ <div class="qa">+ <p class="q">Do you need a server or message broker to coordinate AI agents?</p>+ <p class="a">No. A hive can coordinate through plain files: each agent has an inbox and outbox folder, and a small router process drains outboxes into the right inboxes on a timer. There's no Redis, no queue service, no daemon to keep alive — delivery is an atomic file rename, so it's safe under concurrency without locks.</p>+ </div>++ <div class="qa">+ <p class="q">What are the limits of orchestrating agents on one machine?</p>+ <p class="a">Two real ones. The orchestration only runs while your machine is on — timers and the router live in a local process, so closing the app pauses the schedule. And concurrency is bounded by your CPU and RAM rather than an elastic cloud. In exchange you get zero infrastructure, a full local audit trail, and complete ownership of your data.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/local-first/">Local-First</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-the-orchestration-loop-actually-runs">Where the orchestration loop actually runs</a></li><li class="lvl-2"><a href="#coordination-without-a-broker">Coordination without a broker</a></li><li class="lvl-2"><a href="#scheduling-on-your-own-clock">Scheduling on your own clock</a></li><li class="lvl-2"><a href="#state-that-never-leaves-the-box">State that never leaves the box</a></li><li class="lvl-2"><a href="#the-loop-is-local-too">The loop is local, too</a></li><li class="lvl-2"><a href="#what-it-costs-and-what-you-keep">What it costs — and what you keep</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/open-source-ai-tools-on-purpose/"><span class="k">← Older</span><span class="t">Building AI Dev Tools in the Open, On Purpose</span></a>+ <a class="pn next" href="/blog/keep-agent-semantic-memory-clean/"><span class="k">Newer →</span><span class="t">Keep Your Agent's Semantic Memory Clean: Don't Index the Config</span></a>+ </div>+ <section class="related">+ <h2>Related in Orchestration</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>+ <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/scheduling-autonomous-agent-missions/">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</a></h3>+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/scheduling-autonomous-agent-missions/" aria-label="Read: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions">Read →</a>+ </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>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-02">Jun 2, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>+ <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">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/munder-difflin-faq/index.html b/docs/blog/munder-difflin-faq/index.htmlindex 49f74fd4..2464df75 100644--- a/docs/blog/munder-difflin-faq/index.html+++ b/docs/blog/munder-difflin-faq/index.html@@ -302,20 +302,20 @@ free, open source, and local-first.</p></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/what-is-aeo-for-dev-tools/">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</a></h3>- <p class="dek">Answer Engine Optimization for dev tools: how to get cited by ChatGPT, Claude, and Perplexity with the right robots.txt, JSON-LD, and writing patterns.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/what-is-aeo-for-dev-tools/" aria-label="Read: AEO for Dev Tools: Getting Cited by ChatGPT and Claude">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article>diff --git a/docs/blog/open-source-ai-tools-on-purpose/index.html b/docs/blog/open-source-ai-tools-on-purpose/index.htmlnew file mode 100644index 00000000..6084fafc--- /dev/null+++ b/docs/blog/open-source-ai-tools-on-purpose/index.html@@ -0,0 +1,366 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Building AI Dev Tools in the Open, On Purpose — Munder Difflin Blog</title>+<meta name="description" content="Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it." />+<link rel="canonical" href="https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/" />++<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 AI Dev Tools in the Open, On Purpose — Munder Difflin Blog" />+<meta property="og:description" content="Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it." />+<meta property="og:url" content="https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/" />+<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="Open Source" />+<meta property="article:tag" content="Local-First" />+<meta property="article:tag" content="Trust" />+<meta property="article:tag" content="Multi-Agent" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Building AI Dev Tools in the Open, On Purpose — Munder Difflin Blog" />+<meta name="twitter:description" content="Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it." />+<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 AI Dev Tools in the Open, On Purpose",+ "description": "Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.",+ "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/open-source-ai-tools-on-purpose/" },+ "keywords": "open source ai agents, open source ai tools, mit license, building in public, local-first ai",+ "articleSection": "Concepts",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/"+}+</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 AI Dev Tools in the Open, On Purpose", "item": "https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Why does it matter whether an AI agent tool is open source?", "acceptedAnswer": { "@type": "Answer", "text": "Because agents act autonomously on your behalf — they read your code, call tools with your keys, and keep memory of your work. A closed, autonomous tool asks you to trust all of that on faith. An open one lets you read exactly what it does, audit it, and fix or fork it if you disagree. For software that operates this independently, inspectability isn't a nice-to-have; it's the basis of trust." } },+ { "@type": "Question", "name": "What does MIT-licensed actually give me as a user?", "acceptedAnswer": { "@type": "Answer", "text": "The MIT license is permissive: you can read the full source, run it for any purpose, modify it, and fork it, with essentially no strings beyond keeping the copyright notice. Practically that means no lock-in — if the project changed direction or disappeared, your copy keeps working and you can carry it forward yourself." } },+ { "@type": "Question", "name": "Isn't open source just a marketing label these days?", "acceptedAnswer": { "@type": "Answer", "text": "It can be, when 'open' means a crippled core with the useful parts behind a cloud subscription. The honest version is open source plus local-first: the whole thing runs on your machine, your data and memory stay local, and the code that orchestrates your agents is the code you can read. That combination is what makes 'open' mean something for a dev tool." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/concepts/">Concepts</a>+ </nav>+ <h1>Building AI Dev Tools in the Open, On Purpose</h1>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</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">Concepts</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p>AI agents read your code, call tools with your+keys, and remember your work — so an agent tool asks for an unusual amount of trust. The answer isn't to+trust harder; it's to make the tool <strong>inspectable</strong>. Munder Difflin is+<strong>MIT-licensed and local-first on purpose</strong>: the orchestrator, the agents, and their memory+all run on your machine, and the code that drives them is code you can read, audit, and fork. For+software this autonomous, open source isn't ideology — it's how you replace blind trust with+verification.</p></div>+<p>There’s a lot of AI agent tooling being built right now, and a striking amount of it is closed: a cloud+service you send your code to, a black box that acts on your repo, a “core” that’s open while the parts+that matter sit behind a subscription. <a href="https://munderdiffl.in/#opensource">Munder Difflin</a> went the+other way — MIT-licensed, source-available, local-first — and not as an afterthought. It’s a deliberate+choice about what a tool like this <em>should</em> be. Here’s the case for building agent tooling in the open,+on purpose.</p>+<h2 id="agents-raise-the-trust-bar" tabindex="-1">Agents raise the trust bar <a class="anchor" href="#agents-raise-the-trust-bar" aria-hidden="true">#</a></h2>+<p>A linter or a formatter is a utility: it does one bounded thing and you can eyeball the result. An+<strong>agent</strong> is different in kind. It runs semi-autonomously, decides its own next steps, reads and writes+your files, calls tools using your credentials, and — increasingly — keeps a persistent+<a href="/blog/markdown-first-agent-memory/">memory</a> of your project across sessions. A <em>hive</em> of them does all+that in parallel.</p>+<p>That’s a lot of latitude to hand to software. And the more autonomous the software, the worse a black+box feels: with a closed agent you’re not trusting a single output, you’re trusting every decision it+will make on your behalf, forever, without being able to look. The reasonable response isn’t to trust+harder. It’s to demand that the tool be <strong>inspectable</strong> — that you can read what the orchestrator does+with your code before you let it loose on it.</p>+<p>Open source is what makes that possible. It turns “trust us” into “check for yourself.”</p>+<h2 id="what-open-on-purpose-actually-buys-you" tabindex="-1">What “open, on purpose” actually buys you <a class="anchor" href="#what-open-on-purpose-actually-buys-you" aria-hidden="true">#</a></h2>+<p>Being <a href="https://munderdiffl.in/#opensource">MIT-licensed</a> and built in the open isn’t a badge; it changes+what you can do as a user:</p>+<ul>+<li><strong>Auditability.</strong> You can read exactly how work gets routed, what an agent is allowed to touch, and+where your data goes. No guessing about a remote service’s behavior.</li>+<li><strong>No lock-in.</strong> Permissive licensing means your copy keeps working regardless of what happens to the+project. You’re never one pricing change or shutdown away from losing your workflow.</li>+<li><strong>Forkability.</strong> Disagree with a decision? Change it. Need a behavior the maintainers won’t add? Fork+it. The tool bends to your needs instead of the reverse.</li>+<li><strong>Longevity.</strong> Open code outlives the company or the moment. The work you build on top of it is safe+in a way that a closed SaaS can’t promise.</li>+</ul>+<h2 id="open-and-local-first-the-combination-is-the-point" tabindex="-1">Open <em>and</em> local-first — the combination is the point <a class="anchor" href="#open-and-local-first-the-combination-is-the-point" aria-hidden="true">#</a></h2>+<p>“Open source” alone can still be hollow if the useful half lives in someone else’s cloud. The version+that actually means something pairs open code with <strong>local-first</strong> execution: the orchestrator, the+agents, and their memory all run on <em>your</em> machine, and your code and notes never have to leave it.</p>+<p>That pairing is deliberate in Munder Difflin, and the two halves reinforce each other. Local-first gives+you <a href="/blog/why-local-first-matters-for-ai-agents/">control and privacy</a>; open source lets you <em>verify</em>+that the local-first promise is real rather than taking it on faith. Closed-and-local is unverifiable;+open-and-cloud still ships your data away. Open-and-local is the only quadrant where you can both keep+your data and confirm what the tool is doing with it.</p>+<h2 id="built-in-public-including-this-post" tabindex="-1">Built in public — including this post <a class="anchor" href="#built-in-public-including-this-post" aria-hidden="true">#</a></h2>+<p>Building in the open also means the work itself is visible: the commits, the architecture decisions, the+<a href="/blog/why-we-built-munder-difflin/">reasons behind them</a>. There’s a fitting proof of it in your hands+right now — this blog is written and maintained by the hive of agents the tool runs, working in their+own branches and committing source for review. The system documenting itself in public is about as+on-the-nose a demonstration of “built in the open” as you’ll find.</p>+<p>It also lowers the bar to contribute. When the code and the thinking are both public, a user who hits a+rough edge can read the relevant file, understand it, and propose a fix — instead of filing a ticket into+a void and hoping.</p>+<h2 id="the-honest-tradeoffs" tabindex="-1">The honest tradeoffs <a class="anchor" href="#the-honest-tradeoffs" aria-hidden="true">#</a></h2>+<p>Open source isn’t free of cost, and pretending otherwise would be exactly the kind of marketing this post+is arguing against. Building in the open means no proprietary moat, support that leans on community and+docs rather than a guaranteed SLA, and the ongoing effort of keeping a public project healthy. Those are+real.</p>+<p>But weigh them against the alternative for <em>this</em> category of software: a closed, autonomous agent that+touches everything and explains nothing. For a dev tool that operates with this much independence, the+trust and control you get from open-and-local outweigh the convenience of a black box. That’s the bet —+made on purpose.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>Why does it matter whether an AI agent tool is open source?</strong> Because agents act autonomously on your+behalf — reading your code, calling tools with your keys, holding memory of your work. A closed tool asks+you to trust all of that on faith; an open one lets you read what it does, audit it, and fork it if you+disagree. For software this independent, inspectability is the basis of trust.</p>+<p><strong>What does MIT-licensed actually give me?</strong> It’s permissive: read the source, run it for any purpose,+modify it, fork it — essentially no strings beyond keeping the copyright notice. In practice that means+no lock-in. If the project changed course or vanished, your copy keeps working and you can carry it+forward.</p>+<p><strong>Isn’t “open source” just a label sometimes?</strong> It can be, when “open” means a hollow core with the+useful parts behind a cloud subscription. The honest version is open source <em>plus</em> local-first: the whole+thing runs on your machine, your data stays local, and the orchestration code is the code you can read.</p>+<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>+<p>The more an agent can do on your behalf, the more it matters that you can see what it’s doing. Open+source plus local-first is how a tool earns that trust — not by asking for it, but by making itself+checkable. Munder Difflin is MIT and built in the open <a href="https://munderdiffl.in/#opensource">on+purpose</a>, because that’s the only honest way to ship software this+autonomous. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> and read every line you’re running+— 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 does it matter whether an AI agent tool is open source?</p>+ <p class="a">Because agents act autonomously on your behalf — they read your code, call tools with your keys, and keep memory of your work. A closed, autonomous tool asks you to trust all of that on faith. An open one lets you read exactly what it does, audit it, and fix or fork it if you disagree. For software that operates this independently, inspectability isn't a nice-to-have; it's the basis of trust.</p>+ </div>++ <div class="qa">+ <p class="q">What does MIT-licensed actually give me as a user?</p>+ <p class="a">The MIT license is permissive: you can read the full source, run it for any purpose, modify it, and fork it, with essentially no strings beyond keeping the copyright notice. Practically that means no lock-in — if the project changed direction or disappeared, your copy keeps working and you can carry it forward yourself.</p>+ </div>++ <div class="qa">+ <p class="q">Isn't open source just a marketing label these days?</p>+ <p class="a">It can be, when 'open' means a crippled core with the useful parts behind a cloud subscription. The honest version is open source plus local-first: the whole thing runs on your machine, your data and memory stay local, and the code that orchestrates your agents is the code you can read. That combination is what makes 'open' mean something for a dev tool.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/open-source/">Open Source</a><a class="tag" href="/blog/tags/local-first/">Local-First</a><a class="tag" href="/blog/tags/trust/">Trust</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="#agents-raise-the-trust-bar">Agents raise the trust bar</a></li><li class="lvl-2"><a href="#what-open-on-purpose-actually-buys-you">What “open, on purpose” actually buys you</a></li><li class="lvl-2"><a href="#open-and-local-first-the-combination-is-the-point">Open and local-first — the combination is the point</a></li><li class="lvl-2"><a href="#built-in-public-including-this-post">Built in public — including this post</a></li><li class="lvl-2"><a href="#the-honest-tradeoffs">The honest tradeoffs</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/overnight-ai-coding-realistic-expectations/"><span class="k">← Older</span><span class="t">Overnight AI Coding: What's Realistic (and What's Not)</span></a>+ <a class="pn next" href="/blog/local-first-ai-agent-orchestration/"><span class="k">Newer →</span><span class="t">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</span></a>+ </div>+ <section class="related">+ <h2>Related in Concepts</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>6 min</span>+ </div>+ <h3><a href="/blog/can-claude-code-agents-talk-to-each-other/">Can Claude Code Agents Talk to Each Other?</a></h3>+ <p class="dek">Can Claude Code agents talk to each other? By default they report to their launcher — but a small coordination layer lets them message peer-to-peer.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-label="Read: Can Claude Code Agents Talk to Each Other?">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/do-more-with-less-model-routing/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>+ <p class="dek">Why a hive of agents shouldn't all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/do-more-with-less-model-routing/" aria-label="Read: Do More With Less: Smart Model Routing Across Agents">Read →</a>+ </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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">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/overnight-ai-coding-realistic-expectations/index.html b/docs/blog/overnight-ai-coding-realistic-expectations/index.htmlnew file mode 100644index 00000000..26cf5fee--- /dev/null+++ b/docs/blog/overnight-ai-coding-realistic-expectations/index.html@@ -0,0 +1,389 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>Overnight AI Coding: What's Realistic (and What's Not) — Munder Difflin Blog</title>+<meta name="description" content="An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning." />+<link rel="canonical" href="https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/" />++<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="Overnight AI Coding: What's Realistic (and What's Not) — Munder Difflin Blog" />+<meta property="og:description" content="An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning." />+<meta property="og:url" content="https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/" />+<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="Use Cases" />+<meta property="article:tag" content="Autonomous" />+<meta property="article:tag" content="Human-in-the-Loop" />+<meta property="article:tag" content="Multi-Agent" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Overnight AI Coding: What's Realistic (and What's Not) — Munder Difflin Blog" />+<meta name="twitter:description" content="An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning." />+<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": "Overnight AI Coding: What's Realistic (and What's Not)",+ "description": "An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.",+ "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/overnight-ai-coding-realistic-expectations/" },+ "keywords": "overnight ai coding, autonomous coding agents, ai coding limits, can ai code overnight",+ "articleSection": "Use Cases",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/"+}+</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": "Overnight AI Coding: What's Realistic (and What's Not)", "item": "https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "Can AI coding agents really work overnight?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, for well-scoped, verifiable work — tests, migrations, refactors, doc sweeps — agents can make real progress unattended. They struggle with ambiguous goals, decisions that need taste, and anything they can't check themselves." } },+ { "@type": "Question", "name": "Is it safe to let coding agents run while you sleep?", "acceptedAnswer": { "@type": "Answer", "text": "It's safe when you set guardrails: branch-only changes (never straight to main), human approval for spend and destructive actions, and an audit log you can read in the morning. Without those, unattended agents can do unattended damage." } },+ { "@type": "Question", "name": "What's the biggest mistake with overnight AI coding?", "acceptedAnswer": { "@type": "Answer", "text": "Giving a vague goal with no way for the agent to verify success. Agents that can run tests and check their own output make progress; agents told to 'improve the app' wander." } },+ { "@type": "Question", "name": "Will I wake up to finished features?", "acceptedAnswer": { "@type": "Answer", "text": "Sometimes — but expect to wake up to progress that needs review, not merged production code. The realistic win is a reviewable branch and a clear log, not a hands-off release." } }++ ]+}+</script>+++</head>+<body>+<a class="skip-link" href="#main">Skip to content</a>+<nav id="nav">+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">+ <span class="brand-mark">MD</span>+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>+ </a>+ <span class="spacer"></span>+ <div class="links">+ <a href="/blog/">Latest</a>+ <a href="/blog/topics/">Topics</a>+ <a href="/blog/about/">About</a>+ <a href="https://munderdiffl.in">↗ Product</a>+ </div>+ <div class="nav-actions">+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>+ </div>+</nav>++<main id="main">++<article>+ <header class="post-head wrap">+ <nav class="crumbs" aria-label="Breadcrumb">+ <a href="/blog/">Blog</a>+ <span>/</span>+ <a href="/blog/topics/use-cases/">Use Cases</a>+ </nav>+ <h1>Overnight AI Coding: What's Realistic (and What's Not)</h1>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="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">Use Cases</span>+ </div>+ </header>++ <div class="post-wrap wrap">+ <div class="prose">+ <div class="callout tldr"><span class="ic">TL;DR</span><p>Overnight AI coding is <strong>real</strong>,+but the honest version isn't "wake up to shipped features." It's: agents make genuine progress on+<strong>well-scoped, verifiable</strong> work while you sleep, behind guardrails — branch-only changes,+human approval for the dangerous stuff, and an audit log you read with coffee. Set the scope and the+guardrails right and it's a force multiplier. Skip them and you wake up to a mess. Here's what actually+works, what doesn't, and how to set it up so morning-you is happy.</p></div>+<p>The pitch writes itself: close the laptop, let a hive of agents code through the night, wake up to+finished work. It’s a good pitch — and like most good pitches, the truth is more interesting than the+slogan. Agents <em>can</em> do real work overnight. They also fail in specific, predictable ways. This is the+realistic version, so you can get the upside without the 3 a.m. surprises. If you want the optimistic+companion, read <a href="/blog/claude-code-automation-while-you-sleep/">letting agents build while you sleep</a> —+this post is the counterweight that keeps it honest.</p>+<h2 id="what-overnight-agents-actually-do-well" tabindex="-1">What overnight agents actually do well <a class="anchor" href="#what-overnight-agents-actually-do-well" aria-hidden="true">#</a></h2>+<p>The work that survives unattended has one thing in common: <strong>the agent can tell whether it succeeded.</strong>+When success is checkable, an agent can iterate toward it without you. That covers a lot:</p>+<ul>+<li><strong>Test-guarded changes.</strong> Writing tests, fixing failing ones, raising coverage — the test suite is+the oracle, so the agent knows when it’s done.</li>+<li><strong>Mechanical migrations.</strong> Renames, dependency bumps, codemods, framework upgrades across many files+— repetitive, verifiable, and exactly the kind of tedium you’d rather not do by hand.</li>+<li><strong>Refactors with a safety net.</strong> Extracting modules, deleting dead code, tightening types — anything+where “still compiles, tests still pass” is a real signal.</li>+<li><strong>Documentation and cleanup.</strong> Doc sweeps, changelog drafting, comment passes, fixing lint — low-risk,+high-toil, easy to review in the morning.</li>+</ul>+<p>Give a team of agents a stack of these with clear acceptance criteria and they’ll genuinely chip+through it overnight. That’s the realistic win, and it’s a good one.</p>+<h2 id="where-it-breaks" tabindex="-1">Where it breaks <a class="anchor" href="#where-it-breaks" aria-hidden="true">#</a></h2>+<p>The failure modes are just as predictable. Overnight agents struggle when:</p>+<ul>+<li><strong>The goal is ambiguous.</strong> “Improve the dashboard” has no finish line, so the agent wanders or+gilds. “Make the dashboard’s first paint under 1s, verified by the perf test” has one.</li>+<li><strong>The work needs taste.</strong> Product judgment, API design, naming that future humans will live with —+these need a person. An agent will <em>pick something</em>, but unattended is the wrong time to discover you+disagree.</li>+<li><strong>Verification is impossible.</strong> If the agent can’t check its own output — no tests, no types, no+reproducible run — it’s flying blind, and you’re reviewing blind in the morning.</li>+<li><strong>It hits a real decision.</strong> Spending money, deleting data, a destructive migration, a scope change+nobody anticipated. The right move here isn’t “guess confidently” — it’s “stop and ask.”</li>+</ul>+<p>Notice the pattern: the failures aren’t about raw capability. They’re about <strong>scope and judgment</strong>. The+fix isn’t a smarter model; it’s a better setup.</p>+<h2 id="the-guardrails-that-make-overnight-work-safe" tabindex="-1">The guardrails that make overnight work safe <a class="anchor" href="#the-guardrails-that-make-overnight-work-safe" aria-hidden="true">#</a></h2>+<p>Unattended doesn’t have to mean ungoverned. The difference between “wake up to progress” and “wake up+to a mess” is a handful of guardrails — and they’re the same ones a good+<a href="/#what">multi-agent harness</a> builds in:</p>+<ul>+<li><strong>Branch-only, never straight to main.</strong> Overnight agents commit to their own branches/worktrees. The+worst case is a branch you delete, not a broken <code>main</code>. Merging stays a deliberate, human-gated step.</li>+<li><strong>Human-in-the-loop for the dangerous stuff.</strong> The system runs autonomously on routine work but+<em>pauses for approval</em> on the things that matter — spend, destructive operations, scope changes. Done+right, this doesn’t slow you down; it just stops the few actions you’d regret. (More on designing+that: <a href="/blog/human-in-the-loop-ai-agents/">human-in-the-loop AI agents</a>.)</li>+<li><strong>An orchestrator that escalates instead of guessing.</strong> When an agent gets blocked or two agents+conflict, a coordinator should resolve the routine cases and <em>escalate</em> the genuine decisions to a+queue you read in the morning — not paper over them with a confident wrong answer.</li>+<li><strong>An audit log you can actually read.</strong> The single most valuable overnight artifact isn’t the diff —+it’s a chronological record of what each agent did and why, so morning review takes minutes, not+hours.</li>+<li><strong>Durable memory for continuity.</strong> Agents that record what they learned (and recall it) don’t loop on+the same dead end all night or re-litigate a decision they already made.</li>+</ul>+<p>None of these are exotic. They’re the boring infrastructure that turns “agents running unsupervised”+into “agents running <em>supervised by design</em>.”</p>+<h2 id="a-realistic-overnight-setup" tabindex="-1">A realistic overnight setup <a class="anchor" href="#a-realistic-overnight-setup" aria-hidden="true">#</a></h2>+<p>If you want to try it tonight, here’s the honest checklist:</p>+<ol>+<li><strong>Queue verifiable tasks, not vibes.</strong> Each task gets a one-line goal <em>and</em> a way to check it+(“tests green,” “build passes,” “endpoint returns 200”). If you can’t state the check, it’s not an+overnight task — it’s a morning conversation.</li>+<li><strong>Scope small.</strong> Several narrow tasks beat one sprawling one. Small tasks fail cheaply and review+fast.</li>+<li><strong>Isolate the blast radius.</strong> Branches or worktrees per agent, never the shared main checkout.</li>+<li><strong>Set the escalation rules.</strong> Decide up front what the agents may do autonomously and what must wait+for you. Default the ambiguous cases to “ask.”</li>+<li><strong>Leave breadcrumbs for morning-you.</strong> Make sure there’s a log and a short status per task. You’re+optimizing your <em>review time</em>, not just the agents’ run time.</li>+</ol>+<h2 id="what-still-needs-you-in-the-morning" tabindex="-1">What still needs you in the morning <a class="anchor" href="#what-still-needs-you-in-the-morning" aria-hidden="true">#</a></h2>+<p>This is the part the slogans skip. Overnight agents change <em>when</em> the work happens, not <em>whether you’re+accountable for it</em>. You still:</p>+<ul>+<li><strong>Review the diffs.</strong> “Tests pass” is necessary, not sufficient — read the change.</li>+<li><strong>Make the taste calls</strong> the agents correctly deferred.</li>+<li><strong>Decide what merges.</strong> The realistic deliverable is a reviewable branch plus a clear log, not an+auto-merged release.</li>+</ul>+<p>That’s not a limitation to apologize for — it’s the right division of labor. Agents are spectacular at+toil and iteration; you’re irreplaceable at judgment and accountability. Overnight coding works best+when the setup respects that line instead of pretending it doesn’t exist.</p>+<h2 id="the-honest-bottom-line" tabindex="-1">The honest bottom line <a class="anchor" href="#the-honest-bottom-line" aria-hidden="true">#</a></h2>+<p><strong>Can AI code overnight? Yes — for well-scoped, verifiable work, behind guardrails, with you reviewing+in the morning.</strong> Treat it as a tireless junior team that needs clear tickets and a review gate, and+you’ll get a real multiplier. Treat it as a magic “ship while I sleep” button and you’ll get a cleanup+job. The technology is ready for the first framing today; the second is still a slogan.</p>+<p>If watching that team work (and reading its log) sounds useful, that’s exactly what+<a href="/blog/run-an-office-of-ai-agents/">running an office of AI agents</a> is about.</p>+<hr>+<p>Munder Difflin is a local, open-source <a href="/#why">multi-agent harness</a> built for exactly this: agents that+work on isolated branches, escalate the decisions that matter, and leave a readable trail.+<a href="/#install">Download Munder Difflin</a> to run your own overnight team — free and MIT-licensed.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">Can AI coding agents really work overnight?</p>+ <p class="a">Yes, for well-scoped, verifiable work — tests, migrations, refactors, doc sweeps — agents can make real progress unattended. They struggle with ambiguous goals, decisions that need taste, and anything they can't check themselves.</p>+ </div>++ <div class="qa">+ <p class="q">Is it safe to let coding agents run while you sleep?</p>+ <p class="a">It's safe when you set guardrails: branch-only changes (never straight to main), human approval for spend and destructive actions, and an audit log you can read in the morning. Without those, unattended agents can do unattended damage.</p>+ </div>++ <div class="qa">+ <p class="q">What's the biggest mistake with overnight AI coding?</p>+ <p class="a">Giving a vague goal with no way for the agent to verify success. Agents that can run tests and check their own output make progress; agents told to 'improve the app' wander.</p>+ </div>++ <div class="qa">+ <p class="q">Will I wake up to finished features?</p>+ <p class="a">Sometimes — but expect to wake up to progress that needs review, not merged production code. The realistic win is a reviewable branch and a clear log, not a hands-off release.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/use-cases/">Use Cases</a><a class="tag" href="/blog/tags/autonomous/">Autonomous</a><a class="tag" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop</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="#what-overnight-agents-actually-do-well">What overnight agents actually do well</a></li><li class="lvl-2"><a href="#where-it-breaks">Where it breaks</a></li><li class="lvl-2"><a href="#the-guardrails-that-make-overnight-work-safe">The guardrails that make overnight work safe</a></li><li class="lvl-2"><a href="#a-realistic-overnight-setup">A realistic overnight setup</a></li><li class="lvl-2"><a href="#what-still-needs-you-in-the-morning">What still needs you in the morning</a></li><li class="lvl-2"><a href="#the-honest-bottom-line">The honest bottom line</a></li>+ </ol>+ </aside>++ </div>++ <footer class="post-foot wrap"><div class="prevnext">+ <a class="pn prev" href="/blog/prompt-caching-for-ai-agents/"><span class="k">← Older</span><span class="t">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</span></a>+ <a class="pn next" href="/blog/open-source-ai-tools-on-purpose/"><span class="k">Newer →</span><span class="t">Building AI Dev Tools in the Open, On Purpose</span></a>+ </div>+ <section class="related">+ <h2>Related in Use Cases</h2>+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-02">Jun 2, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>3 min</span>+ </div>+ <h3><a href="/blog/from-one-terminal-to-a-team/">From One Terminal to a Team: Scaling Your Claude Code Workflow</a></h3>+ <p class="dek">The workflow shift from a single Claude Code session to a coordinated team of agents — what changes, where it breaks, and the concrete before-and-after.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/from-one-terminal-to-a-team/" aria-label="Read: From One Terminal to a Team: Scaling Your Claude Code Workflow">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-use-cases" href="/blog/run-an-office-of-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-02">Jun 2, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>3 min</span>+ </div>+ <h3><a href="/blog/run-an-office-of-ai-agents/">Run an Office of AI Agents While You Sleep</a></h3>+ <p class="dek">What it takes to run a self-coordinating office of AI coding agents that keeps shipping after you log off — and the guardrails that keep it sane.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/run-an-office-of-ai-agents/" aria-label="Read: Run an Office of AI Agents While You Sleep">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-use-cases" href="/blog/why-local-first-matters-for-ai-agents/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-02">Jun 2, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>3 min</span>+ </div>+ <h3><a href="/blog/why-local-first-matters-for-ai-agents/">Why Local-First Matters for Your AI Agents</a></h3>+ <p class="dek">The control, privacy, and cost case for keeping your AI agents and their memory on your own machine — and what cloud orchestration quietly costs.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/why-local-first-matters-for-ai-agents/" aria-label="Read: Why Local-First Matters for Your AI Agents">Read →</a>+ </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/prompt-caching-for-ai-agents/index.html b/docs/blog/prompt-caching-for-ai-agents/index.htmlnew file mode 100644index 00000000..bade88d9--- /dev/null+++ b/docs/blog/prompt-caching-for-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>Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice — Munder Difflin Blog</title>+<meta name="description" content="An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it." />+<link rel="canonical" href="https://munderdiffl.in/blog/prompt-caching-for-ai-agents/" />++<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />+<meta name="theme-color" content="#F5F2E8" />++<!-- Open Graph -->+<meta property="og:site_name" content="Munder Difflin Blog" />+<meta property="og:type" content="article" />+<meta property="og:title" content="Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice — Munder Difflin Blog" />+<meta property="og:description" content="An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it." />+<meta property="og:url" content="https://munderdiffl.in/blog/prompt-caching-for-ai-agents/" />+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />+<meta property="og:locale" content="en_US" />+<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />+<meta property="article:author" content="Chaitanya Giri" />+<meta property="article:tag" content="Prompt Caching" />+<meta property="article:tag" content="Cost" />+<meta property="article:tag" content="Performance" />+<meta property="article:tag" content="Multi-Agent" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice — Munder Difflin Blog" />+<meta name="twitter:description" content="An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it." />+<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": "Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice",+ "description": "An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.",+ "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/prompt-caching-for-ai-agents/" },+ "keywords": "prompt caching for ai agents, prompt caching, llm prompt caching, agent cost optimization, kv cache",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/prompt-caching-for-ai-agents/"+}+</script>+<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "BreadcrumbList",+ "itemListElement": [+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },+ { "@type": "ListItem", "position": 3, "name": "Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice", "item": "https://munderdiffl.in/blog/prompt-caching-for-ai-agents/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "What is prompt caching?", "acceptedAnswer": { "@type": "Answer", "text": "Prompt caching lets an LLM provider store the processed form of a stable prefix of your prompt — typically the system instructions, tool definitions, and any large fixed context — so that subsequent requests reusing that exact prefix skip the work of reprocessing it. You pay full price to write the cache once, then a small fraction of the input price on every later request that hits it, and the response starts faster." } },+ { "@type": "Question", "name": "Why does prompt caching matter so much for agents?", "acceptedAnswer": { "@type": "Answer", "text": "An agent is a loop: it sends the same system prompt, the same tool list, and often the same large context on every single turn, with only the newest messages changing. Without caching you re-pay for that entire stable prefix dozens of times in one session. With caching you pay for it once and read it cheaply thereafter, which for a long agent run is usually the single biggest cost reduction available — and it cuts latency too." } },+ { "@type": "Question", "name": "How do I structure a prompt so it caches well?", "acceptedAnswer": { "@type": "Answer", "text": "Put the stable content first and the volatile content last. Caches match on an exact prefix, so the system prompt, tool definitions, and fixed context go at the front, and the changing turn-by-turn messages go at the end. Any change near the front invalidates everything after it, so never edit or reorder the prefix mid-session — append, don't rewrite." } },+ { "@type": "Question", "name": "What are the limits of prompt caching?", "acceptedAnswer": { "@type": "Answer", "text": "Caches expire after a short time-to-live (often around five minutes by default), so an agent that goes idle loses its cache and re-pays the write. Caching only helps input tokens, not output, and it doesn't change answer quality — it's purely a cost and latency optimization. And because matching is exact-prefix, a single changed token near the front busts the cache." } }++ ]+}+</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>Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</h1>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</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>An agent is a loop that re-sends the same+system prompt, tools, and context on <em>every</em> turn — and naively you pay full price for that+prefix every time. <strong>Prompt caching</strong> makes you pay for the stable prefix once (a small+write premium) and a fraction of the price on every later turn that reuses it. The design rules:+<strong>stable content first, volatile content last</strong>; never rewrite the prefix mid-session+(append, don't edit); and keep turns flowing so the cache doesn't expire. For a long-running agent it's+usually the single biggest lever on both <strong>cost and latency</strong>.</p></div>+<p>Last time we looked at <a href="/blog/do-more-with-less-model-routing/">routing the right task to the right model</a>+as the first big cost lever for a hive of agents. Here’s the second, and it’s one people leave on the+table constantly: <strong>prompt caching</strong>. The model-routing argument is about <em>which</em> model you call;+prompt caching is about <em>not re-paying for the same tokens</em> every time you call it. Both matter; this+one is almost free once you understand the shape of an agent’s prompt.</p>+<h2 id="an-agent-re-sends-almost-the-same-prompt-every-turn" tabindex="-1">An agent re-sends almost the same prompt every turn <a class="anchor" href="#an-agent-re-sends-almost-the-same-prompt-every-turn" aria-hidden="true">#</a></h2>+<p>Step back and look at what an agent actually sends to the model on each turn of its loop:</p>+<ul>+<li>a <strong>system prompt</strong> — its role, rules, and instructions (stable for the whole session),</li>+<li>a set of <strong>tool definitions</strong> — often long, and identical every turn,</li>+<li>some <strong>fixed context</strong> — a codebase summary, project docs, a style guide (stable),</li>+<li>and then the <strong>conversation so far</strong> plus the <strong>newest message or tool result</strong> (this is the only+part that actually changes).</li>+</ul>+<p>The first three are the same on turn 1 and turn 40. Yet without caching, every turn re-sends and the+model re-processes that entire prefix from scratch — and you pay input-token price for all of it, every+single time. On a long agent run with a big system prompt and a fat tool list, the <em>stable</em> prefix can+dwarf the changing part. You’re paying for the same tokens dozens of times.</p>+<p>That’s the waste prompt caching removes.</p>+<h2 id="what-caching-actually-does" tabindex="-1">What caching actually does <a class="anchor" href="#what-caching-actually-does" aria-hidden="true">#</a></h2>+<p>Every major provider now offers some form of it (Anthropic, OpenAI, and Google all do). The mechanics+vary, but the shape is the same:</p>+<ol>+<li>The provider stores the <strong>processed form</strong> of a prefix of your prompt.</li>+<li>The <strong>first</strong> request that establishes the cache pays a small <strong>write premium</strong> over normal input+price (Anthropic, for example, charges around 1.25× to write).</li>+<li><strong>Every later</strong> request whose prompt begins with that exact prefix pays only a <strong>fraction</strong> of the+input price for the cached part — on the order of <strong>a tenth</strong> — and the response also starts faster,+because the expensive prefix didn’t have to be reprocessed.</li>+</ol>+<p>So the trade is: pay a little extra once, then pay almost nothing for that prefix on every subsequent+turn. For a one-shot call that never repeats, caching isn’t worth the write premium. For an <em>agent</em> —+which repeats the same prefix constantly — it’s close to a no-brainer. The break-even is usually just+two or three reuses, and agents reuse far more than that.</p>+<h2 id="the-one-rule-stable-first-volatile-last" tabindex="-1">The one rule: stable first, volatile last <a class="anchor" href="#the-one-rule-stable-first-volatile-last" aria-hidden="true">#</a></h2>+<p>Caches match on an <strong>exact prefix</strong>. The provider walks your prompt from the start and reuses the cache+up to the first byte that differs. Everything after that point is reprocessed and re-priced. That single+fact dictates the whole design:</p>+<blockquote>+<p>Put everything stable at the <strong>front</strong> of the prompt, and everything that changes turn-to-turn at the+<strong>back</strong>.</p>+</blockquote>+<p>Concretely, order your prompt as: <strong>system prompt → tool definitions → fixed context → conversation+history → newest message</strong>. That way the longest possible run of bytes at the front is identical every+turn, so the cache covers the maximum amount, and only the short, genuinely-new tail gets reprocessed.</p>+<p>The corollary is a discipline that trips people up: <strong>never edit or reorder the prefix mid-session.</strong> If+you insert a note into the system prompt on turn 20, or shuffle your tool list, or rewrite the fixed+context, you change a byte near the front and <strong>invalidate the cache for everything after it</strong> — you’re+back to paying full price. The cache-friendly move is always to <strong>append</strong> new information at the end,+never to rewrite the beginning.</p>+<p>This is exactly where caching and <a href="/blog/semantic-memory-for-ai-agents/">context engineering</a> have to+agree with each other. Curating the window is good — but if your curation <em>rewrites the front</em> of the+context on every turn, you’ve quietly destroyed your cache. Cache-aware context engineering means: keep+the stable prefix truly stable, and do your adding at the tail.</p>+<h2 id="watch-the-clock-caches-expire" tabindex="-1">Watch the clock: caches expire <a class="anchor" href="#watch-the-clock-caches-expire" aria-hidden="true">#</a></h2>+<p>The second gotcha is <strong>time-to-live</strong>. Cached prefixes don’t live forever; a common default is around+<strong>five minutes</strong> of inactivity before the cache is dropped (some providers offer a longer, pricier TTL).+For an agent in a tight loop, this is invisible — turns come fast enough that the cache stays warm. But+an agent that <strong>goes idle</strong> — waiting on a human approval, blocked on a slow tool, parked between tasks —+can let its cache lapse and pay the write premium all over again when it resumes.</p>+<p>The practical implications:</p>+<ul>+<li>Keep active agents <strong>looping</strong> rather than sleeping mid-task when you can.</li>+<li>For work with unavoidable long pauses, consider a provider’s <strong>extended-TTL</strong> option, or accept the+re-write cost as the price of the pause.</li>+<li>Be aware that the cost math shifts the moment an agent stalls — which is one more reason+<a href="/blog/human-in-the-loop-ai-agents/">human-in-the-loop checkpoints</a> should be rare and high-signal,+not sprinkled everywhere.</li>+</ul>+<h2 id="the-multi-agent-angle" tabindex="-1">The multi-agent angle <a class="anchor" href="#the-multi-agent-angle" aria-hidden="true">#</a></h2>+<p>In a single agent, caching is a per-session win. In a <a href="/blog/coordinating-ai-coding-agents/">hive</a> it+compounds, because many agents share structure. If your agents are built from the <strong>same system-prompt+template and the same tool definitions</strong>, each one’s prefix is independently cacheable — and if you keep+that shared scaffold <strong>byte-identical</strong> across agents (same ordering, same formatting), you make every+agent’s prompt as cache-friendly as it can be.</p>+<p>Two concrete habits pay off:</p>+<ul>+<li><strong>Standardize the scaffold.</strong> A shared, fixed prefix format across roles means every agent benefits+from the same caching behavior, and you reason about cost once instead of per-agent.</li>+<li><strong>Give sub-agents a stable brief.</strong> When an orchestrator spins up a short-lived sub-agent, a+consistent, front-loaded brief lets even brief agents cache their setup — useful when you fan out many+similar sub-agents at once.</li>+</ul>+<p>The general principle, same as everywhere else in agent design: <strong>shared, stable structure is cheaper+than bespoke, churning structure</strong> — here it’s literally cheaper, in tokens.</p>+<h2 id="a-quick-checklist" tabindex="-1">A quick checklist <a class="anchor" href="#a-quick-checklist" aria-hidden="true">#</a></h2>+<p>When an agent’s bill looks too high for what it’s doing, before anything else:</p>+<ol>+<li><strong>Is caching even on?</strong> Some APIs cache automatically above a token threshold; others require you to+mark the cacheable prefix explicitly. Know which yours is.</li>+<li><strong>Is the prompt ordered stable-first?</strong> If volatile content is near the front, the cache covers+almost nothing. Reorder.</li>+<li><strong>Are you rewriting the prefix mid-session?</strong> Find the edit and turn it into an append.</li>+<li><strong>Are agents stalling long enough to lose the cache?</strong> If so, either tighten the loop or accept the+re-write.</li>+<li><strong>Is the prefix long enough to be worth it?</strong> Tiny prompts that barely repeat don’t recover the write+premium — caching is for the big, oft-repeated scaffolds, which is most agents.</li>+</ol>+<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>+<p>Prompt caching is the rare optimization that costs almost nothing to adopt and pays back immediately:+you don’t change <em>what</em> your agent does or <em>how well</em> it does it — you just stop paying repeatedly for+the tokens it was always going to send. Pair it with <a href="/blog/do-more-with-less-model-routing/">smart model+routing</a> and you’ve pulled the two biggest cost levers an agent+team has: the right model for the task, and full price for the stable prefix exactly once.</p>+<p>Munder Difflin is built to run <a href="/#how">a hive</a> efficiently — lean models by default, stable shared scaffolds, and+work that keeps flowing. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run an agent team+that doesn’t waste your tokens; 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 is prompt caching?</p>+ <p class="a">Prompt caching lets an LLM provider store the processed form of a stable prefix of your prompt — typically the system instructions, tool definitions, and any large fixed context — so that subsequent requests reusing that exact prefix skip the work of reprocessing it. You pay full price to write the cache once, then a small fraction of the input price on every later request that hits it, and the response starts faster.</p>+ </div>++ <div class="qa">+ <p class="q">Why does prompt caching matter so much for agents?</p>+ <p class="a">An agent is a loop: it sends the same system prompt, the same tool list, and often the same large context on every single turn, with only the newest messages changing. Without caching you re-pay for that entire stable prefix dozens of times in one session. With caching you pay for it once and read it cheaply thereafter, which for a long agent run is usually the single biggest cost reduction available — and it cuts latency too.</p>+ </div>++ <div class="qa">+ <p class="q">How do I structure a prompt so it caches well?</p>+ <p class="a">Put the stable content first and the volatile content last. Caches match on an exact prefix, so the system prompt, tool definitions, and fixed context go at the front, and the changing turn-by-turn messages go at the end. Any change near the front invalidates everything after it, so never edit or reorder the prefix mid-session — append, don't rewrite.</p>+ </div>++ <div class="qa">+ <p class="q">What are the limits of prompt caching?</p>+ <p class="a">Caches expire after a short time-to-live (often around five minutes by default), so an agent that goes idle loses its cache and re-pays the write. Caching only helps input tokens, not output, and it doesn't change answer quality — it's purely a cost and latency optimization. And because matching is exact-prefix, a single changed token near the front busts the cache.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/prompt-caching/">Prompt Caching</a><a class="tag" href="/blog/tags/cost/">Cost</a><a class="tag" href="/blog/tags/performance/">Performance</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="#an-agent-re-sends-almost-the-same-prompt-every-turn">An agent re-sends almost the same prompt every turn</a></li><li class="lvl-2"><a href="#what-caching-actually-does">What caching actually does</a></li><li class="lvl-2"><a href="#the-one-rule-stable-first-volatile-last">The one rule: stable first, volatile last</a></li><li class="lvl-2"><a href="#watch-the-clock-caches-expire">Watch the clock: caches expire</a></li><li class="lvl-2"><a href="#the-multi-agent-angle">The multi-agent angle</a></li><li class="lvl-2"><a href="#a-quick-checklist">A quick checklist</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/scheduling-autonomous-agent-missions/"><span class="k">← Older</span><span class="t">Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</span></a>+ <a class="pn next" href="/blog/overnight-ai-coding-realistic-expectations/"><span class="k">Newer →</span><span class="t">Overnight AI Coding: What's Realistic (and What's Not)</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/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>+<article class="card">+ <a class="thumb t-guides" href="/blog/context-engineering-for-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>+ </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>+ <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>+ </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/run-an-office-of-ai-agents/index.html b/docs/blog/run-an-office-of-ai-agents/index.htmlindex f7382003..8582106f 100644--- a/docs/blog/run-an-office-of-ai-agents/index.html+++ b/docs/blog/run-an-office-of-ai-agents/index.html@@ -206,6 +206,24 @@ open source.</p><h2>Related in Use Cases</h2><div class="post-grid"><article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/scheduling-autonomous-agent-missions/index.html b/docs/blog/scheduling-autonomous-agent-missions/index.htmlindex 408a5db3..217c160a 100644--- a/docs/blog/scheduling-autonomous-agent-missions/index.html+++ b/docs/blog/scheduling-autonomous-agent-missions/index.html@@ -290,8 +290,8 @@ 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/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/keep-agent-semantic-memory-clean/"><span class="k">Newer →</span><span class="t">Keep Your Agent's Semantic Memory Clean: Don't Index the Config</span></a>+ <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/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"><h2>Related in Orchestration</h2>@@ -315,38 +315,38 @@ mission and watch the floor wake itself up; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <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/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>- <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a></div></div></article><article class="card">- <a class="thumb t-orchestration" href="/blog/how-the-god-orchestrator-works/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-orchestration" href="/blog/human-in-the-loop-ai-agents/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span></a><div class="body"><div class="meta">- <time datetime="2026-05-30">May 30, 2026</time>+ <time datetime="2026-06-02">Jun 2, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/how-the-god-orchestrator-works/">Inside the GOD Orchestrator: Routing, Adjudication, Escalation</a></h3>- <p class="dek">A deep dive into the Claude Code orchestrator: how a GOD agent reads requests, routes work, adjudicates routine traffic, and escalates the critical few.</p>+ <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down</a></h3>+ <p class="dek">Design human-in-the-loop AI agents that stay autonomous: an approvals queue that escalates only spend, destructive ops, and scope changes.</p><div class="foot"><span class="tag kind">Orchestration</span>- <a class="more" href="/blog/how-the-god-orchestrator-works/" aria-label="Read: Inside the GOD Orchestrator: Routing, Adjudication, Escalation">Read →</a>+ <a class="more" href="/blog/human-in-the-loop-ai-agents/" aria-label="Read: Human-in-the-Loop AI Agents: Approvals That Don't Slow You Down">Read →</a></div></div></article>diff --git a/docs/blog/small-team-ai-agents-playbook/index.html b/docs/blog/small-team-ai-agents-playbook/index.htmlnew file mode 100644index 00000000..d5fa74c0--- /dev/null+++ b/docs/blog/small-team-ai-agents-playbook/index.html@@ -0,0 +1,372 @@+<!doctype html>+<html lang="en">+<head>+<meta charset="UTF-8" />+<meta name="viewport" content="width=device-width, initial-scale=1.0" />+<title>A Small-Team Playbook for AI Coding Agents — Munder Difflin Blog</title>+<meta name="description" content="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." />+<link rel="canonical" href="https://munderdiffl.in/blog/small-team-ai-agents-playbook/" />++<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="A Small-Team Playbook for AI Coding Agents — Munder Difflin Blog" />+<meta property="og:description" content="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." />+<meta property="og:url" content="https://munderdiffl.in/blog/small-team-ai-agents-playbook/" />+<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="Multi-Agent" />+<meta property="article:tag" content="Claude Code" />+<meta property="article:tag" content="Workflow" />+++<!-- Twitter -->+<meta name="twitter:card" content="summary_large_image" />+<meta name="twitter:title" content="A Small-Team Playbook for AI Coding Agents — Munder Difflin Blog" />+<meta name="twitter:description" content="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." />+<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": "A Small-Team Playbook for AI Coding Agents",+ "description": "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.",+ "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/small-team-ai-agents-playbook/" },+ "keywords": "ai coding agents for small teams, multi-agent playbook, adopting ai agents, small team ai workflow",+ "articleSection": "Guides",+ "inLanguage": "en-US",+ "url": "https://munderdiffl.in/blog/small-team-ai-agents-playbook/"+}+</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": "A Small-Team Playbook for AI Coding Agents", "item": "https://munderdiffl.in/blog/small-team-ai-agents-playbook/" }+ ]+}+</script>++<script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "FAQPage",+ "mainEntity": [+ { "@type": "Question", "name": "How many AI agents should a small team start with?", "acceptedAnswer": { "@type": "Answer", "text": "Start with one orchestrator and two or three specialists, not ten. A small set is easy to supervise, and you learn the coordination patterns — handoffs, reviews, guardrails — at a scale where mistakes are cheap. Add agents only when a specific bottleneck is begging for one, and let the orchestrator route work to them." } },+ { "@type": "Question", "name": "What's the biggest mistake teams make adopting agents?", "acceptedAnswer": { "@type": "Answer", "text": "Skipping guardrails. Teams wire up agents that can commit, push, and merge freely, then spend their time cleaning up. The fix is to make the safe path the default: branch-only work, a single committer, human approval on anything hard to reverse, and isolated worktrees so agents can't step on each other." } },+ { "@type": "Question", "name": "Do agents replace code review?", "acceptedAnswer": { "@type": "Answer", "text": "No — they add a layer before it. Agents verify their own work and re-verify each other's, which catches the obvious failures early, but a human still approves anything that ships. Think of it as a funnel: cheap automated checks first, scarce human attention last, on the decisions that matter." } }++ ]+}+</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>A Small-Team Playbook for AI Coding Agents</h1>+ <p class="dek">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.</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>Adopting AI coding agents as a small team isn't+about having more agents — it's about <strong>roles, cadence, and guardrails</strong>. Start with one+orchestrator plus a few specialists. Run a predictable cadence with file-based handoffs and a shared+board. Make the safe path the default: branch-only work, a single committer, human gates on anything hard+to reverse, and isolated worktrees. Get those three things right and a handful of agents behaves like a+small, reliable team instead of a swarm you're constantly chasing.</p></div>+<p>The instinct when you first run <a href="/blog/how-to-run-multiple-claude-code-agents/">multiple coding agents</a> is+to launch a dozen and watch them go. It feels productive for about an hour, until two of them edit the+same file, a third pushes a half-finished branch, and you’re refereeing instead of building. The teams+that succeed with agents don’t have more agents — they have <em>structure</em>. This is a practical playbook for+that structure: who does what, how the work flows, and which rails keep it from going off the road.</p>+<h2 id="roles-one-orchestrator-a-few-specialists" tabindex="-1">Roles: one orchestrator, a few specialists <a class="anchor" href="#roles-one-orchestrator-a-few-specialists" aria-hidden="true">#</a></h2>+<p>Treat your agents like a small team with a lead, not a pile of interchangeable workers.</p>+<p>Start with <strong>one orchestrator</strong> — the agent that holds the plan, breaks work into tasks, assigns them, and+decides what’s ready to integrate. Everything routes through it, so there’s a single place that knows the+state of the world. (This is the role the <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> plays+in a hive — the human’s proxy on the floor.)</p>+<p>Around it, run <strong>two or three specialists</strong>: maybe one for a feature area, one for review and verification,+one for docs or research. The point isn’t rigid job titles — it’s that each agent has a <em>lane</em>, so when a+task lands you know who it goes to and the agents aren’t all reaching for the same files.</p>+<p>Resist scaling the headcount early. A small set is supervisable; you can read every handoff and catch+problems while they’re cheap. Add an agent only when a real bottleneck asks for one, and let the+orchestrator <a href="/blog/coordinating-ai-coding-agents/">coordinate the work</a> rather than having agents+free-lance.</p>+<h2 id="cadence-predictable-handoffs-beat-constant-chatter" tabindex="-1">Cadence: predictable handoffs beat constant chatter <a class="anchor" href="#cadence-predictable-handoffs-beat-constant-chatter" aria-hidden="true">#</a></h2>+<p>Agents coordinate best the same way a remote team does — asynchronously, in writing, on a rhythm.</p>+<p><strong>Use file-based handoffs.</strong> Instead of agents interrupting each other, have them drop messages into each+other’s inbox as plain files, picked up on the next cycle. <a href="/blog/atomic-file-mailboxes-for-agents/">Atomic file mailboxes</a>+make this dead simple and debuggable: every request and reply is a file you can read, replay, or audit.+There’s no shared mutable channel to corrupt.</p>+<p><strong>Keep a shared board.</strong> One markdown file the orchestrator owns, holding the current plan and decisions,+gives every agent the same picture without a meeting. It’s the team’s working memory between cycles.</p>+<p><strong>Run a standup on an interval.</strong> A periodic check-in — every hour, every morning, whatever fits — where+agents report what they did, what’s next, and whether they’re still on track, keeps drift from compounding+silently. It’s also where you catch two agents about to collide and re-route before they do.</p>+<p>Pair this with durable <a href="/blog/markdown-first-agent-memory/">markdown memory</a> so the team stops re-learning+the same facts every session. The cadence is what turns a set of independent agents into something that+accumulates progress instead of restarting cold.</p>+<h2 id="guardrails-make-the-safe-path-the-default" tabindex="-1">Guardrails: make the safe path the default <a class="anchor" href="#guardrails-make-the-safe-path-the-default" aria-hidden="true">#</a></h2>+<p>This is where most agent adoptions live or die. Capable agents with no rails will eventually do something+expensive. The trick is to make the <em>safe</em> action the path of least resistance.</p>+<ul>+<li><strong>Branch-only by default.</strong> Agents work on their own branches and never push or merge on their own. The+orchestrator (and a human) decide what lands. A bad change stays contained on a branch instead of in main.</li>+<li><strong>One committer.</strong> Let exactly one process own commits to the shared repo so concurrent agents never+corrupt each other’s history. The <a href="/blog/single-committer-git-pattern/">single-committer pattern</a> removes+a whole class of race conditions.</li>+<li><strong>Isolated worktrees.</strong> Give each agent its own <a href="/blog/claude-code-git-worktrees-vs-hive/">git worktree</a>+so parallel work physically can’t touch the same files. Collisions become impossible instead of merely+unlikely.</li>+<li><strong>Human gates on the hard-to-reverse.</strong> Deploys, merges to main, deleting data, anything outward-facing —+route those to a <a href="/blog/human-in-the-loop-ai-agents/">human approval</a> step. Agents propose; a person+disposes on the decisions that actually carry risk.</li>+<li><strong>Scope the task.</strong> Tell an agent exactly which files or directories a task may touch, and have it report+the diff. A tight scope makes a wandering agent obvious immediately.</li>+<li><strong>Verify, don’t trust.</strong> Require every “done” to come with evidence — the command that was run and its+output — and have a second agent re-run the checks before integration. Plausible isn’t the same as+checked.</li>+</ul>+<p>None of these slow a good agent down. They just make the failure modes shallow and recoverable, which is+the whole game when you’re not watching every keystroke.</p>+<h2 id="a-realistic-first-week" tabindex="-1">A realistic first week <a class="anchor" href="#a-realistic-first-week" aria-hidden="true">#</a></h2>+<p>You don’t need all of this on day one. A sane rollout:</p>+<ol>+<li><strong>Day 1–2:</strong> Run one orchestrator and one specialist on a low-stakes task. Turn on branch-only and a+single committer first — those two rails alone prevent most early messes.</li>+<li><strong>Day 3–4:</strong> Add a shared board and file-based handoffs. Introduce a standup so you get a written pulse+of what the agents are doing.</li>+<li><strong>Day 5+:</strong> Add a second specialist and isolated worktrees so they run in parallel. Add the human gate+on merges and deploys. Now you have a small team you can leave running and trust to stop at the lines+that matter.</li>+</ol>+<p>Grow from there only when a bottleneck demands it. The structure scales; the chaos of “just add agents”+does not.</p>+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>+<p><strong>Can a small team really benefit, or is this just for big orgs?</strong> Small teams benefit most — you’re the+ones short on hands. A handful of well-coordinated agents covers the tedious breadth (tests, docs,+research, cleanup) so the humans spend time on the decisions only they can make.</p>+<p><strong>What if an agent does something wrong?</strong> With branch-only work and a single committer, “wrong” lives on a+branch you can throw away. That’s the point of the guardrails: make mistakes cheap and reversible so you+can let agents work without hovering.</p>+<p><strong>How is this different from just running several chat sessions?</strong> Sessions don’t share memory, a board, or+a committer, so they duplicate work and collide. A <a href="/blog/run-an-office-of-ai-agents/">coordinated hive</a>+gives them a shared picture and rails — that’s the difference between several tools and one team.</p>+<hr>+<p>Munder Difflin gives a small team exactly this playbook out of the box — an orchestrator, file-based+handoffs, shared memory, and <a href="https://munderdiffl.in/#how">the guardrails that keep a hive safe</a>, all+running locally on your machine.+<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to put a small team of agents to work today;+it’s free and open source.</p>++++ <section class="faq" aria-label="Frequently asked questions">+ <h2 id="faq">FAQ</h2>++ <div class="qa">+ <p class="q">How many AI agents should a small team start with?</p>+ <p class="a">Start with one orchestrator and two or three specialists, not ten. A small set is easy to supervise, and you learn the coordination patterns — handoffs, reviews, guardrails — at a scale where mistakes are cheap. Add agents only when a specific bottleneck is begging for one, and let the orchestrator route work to them.</p>+ </div>++ <div class="qa">+ <p class="q">What's the biggest mistake teams make adopting agents?</p>+ <p class="a">Skipping guardrails. Teams wire up agents that can commit, push, and merge freely, then spend their time cleaning up. The fix is to make the safe path the default: branch-only work, a single committer, human approval on anything hard to reverse, and isolated worktrees so agents can't step on each other.</p>+ </div>++ <div class="qa">+ <p class="q">Do agents replace code review?</p>+ <p class="a">No — they add a layer before it. Agents verify their own work and re-verify each other's, which catches the obvious failures early, but a human still approves anything that ships. Think of it as a funnel: cheap automated checks first, scarce human attention last, on the decisions that matter.</p>+ </div>++ </section>++++ <hr />+ <div class="share">+ <span class="lbl">Tags</span>+ <a class="tag" href="/blog/tags/guides/">Guides</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a><a class="tag" href="/blog/tags/workflow/">Workflow</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="#roles-one-orchestrator-a-few-specialists">Roles: one orchestrator, a few specialists</a></li><li class="lvl-2"><a href="#cadence-predictable-handoffs-beat-constant-chatter">Cadence: predictable handoffs beat constant chatter</a></li><li class="lvl-2"><a href="#guardrails-make-the-safe-path-the-default">Guardrails: make the safe path the default</a></li><li class="lvl-2"><a href="#a-realistic-first-week">A realistic first week</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/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/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>+<article class="card">+ <a class="thumb t-guides" href="/blog/context-engineering-for-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>+ </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>+ <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>+ </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/tags/autonomous/index.html b/docs/blog/tags/autonomous/index.htmlindex b1e46998..2472cf7d 100644--- a/docs/blog/tags/autonomous/index.html+++ b/docs/blog/tags/autonomous/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Autonomous</h1>- <p class="lead">2 posts tagged <strong>Autonomous</strong>.</p>+ <p class="lead">3 posts tagged <strong>Autonomous</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -80,6 +80,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span>diff --git a/docs/blog/tags/claude-code/index.html b/docs/blog/tags/claude-code/index.htmlindex 7ba09234..35dd06a4 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">29 posts tagged <strong>Claude Code</strong>.</p>+ <p class="lead">31 posts tagged <strong>Claude Code</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -224,6 +224,24 @@</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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1"><span>MEMORY</span>@@ -242,6 +260,24 @@</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>+ </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/small-team-ai-agents-playbook/">A Small-Team Playbook for AI Coding Agents</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/small-team-ai-agents-playbook/" aria-label="Read: A Small-Team Playbook for AI Coding Agents">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/concepts/index.html b/docs/blog/tags/concepts/index.htmlindex df3a76c3..6bd9bed9 100644--- a/docs/blog/tags/concepts/index.html+++ b/docs/blog/tags/concepts/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Concepts</h1>- <p class="lead">6 posts tagged <strong>Concepts</strong>.</p>+ <p class="lead">7 posts tagged <strong>Concepts</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -80,6 +80,24 @@</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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">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/tags/cost/index.html b/docs/blog/tags/cost/index.htmlindex 45c98e7f..53af02a4 100644--- a/docs/blog/tags/cost/index.html+++ b/docs/blog/tags/cost/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Cost</h1>- <p class="lead">1 post tagged <strong>Cost</strong>.</p>+ <p class="lead">2 posts tagged <strong>Cost</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -80,6 +80,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/prompt-caching-for-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/prompt-caching-for-ai-agents/">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</a></h3>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/prompt-caching-for-ai-agents/" aria-label="Read: Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice">Read →</a>+ </div>+ </div>+</article></div></section>diff --git a/docs/blog/tags/guides/index.html b/docs/blog/tags/guides/index.htmlindex 3fb5799b..71cc2dcd 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">8 posts tagged <strong>Guides</strong>.</p>+ <p class="lead">9 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/small-team-ai-agents-playbook/" 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/small-team-ai-agents-playbook/">A Small-Team Playbook for AI Coding Agents</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/small-team-ai-agents-playbook/" aria-label="Read: A Small-Team Playbook for AI Coding Agents">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/human-in-the-loop/index.html b/docs/blog/tags/human-in-the-loop/index.htmlindex b9bfcd3b..27166848 100644--- a/docs/blog/tags/human-in-the-loop/index.html+++ b/docs/blog/tags/human-in-the-loop/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Human-in-the-Loop</h1>- <p class="lead">1 post tagged <strong>Human-in-the-Loop</strong>.</p>+ <p class="lead">2 posts tagged <strong>Human-in-the-Loop</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">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/internals/index.html b/docs/blog/tags/internals/index.htmlindex a3732fa6..8c23b579 100644--- a/docs/blog/tags/internals/index.html+++ b/docs/blog/tags/internals/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Internals</h1>- <p class="lead">11 posts tagged <strong>Internals</strong>.</p>+ <p class="lead">12 posts tagged <strong>Internals</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -80,6 +80,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-internals" href="/blog/building-a-terminal-ui-xterm-node-pty/" aria-hidden="true" tabindex="-1"><span>INTERNALS</span>diff --git a/docs/blog/tags/local-first/index.html b/docs/blog/tags/local-first/index.htmlindex 9fc6b218..fa40a296 100644--- a/docs/blog/tags/local-first/index.html+++ b/docs/blog/tags/local-first/index.html@@ -58,11 +58,47 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Local-First</h1>- <p class="lead">1 post tagged <strong>Local-First</strong>.</p>+ <p class="lead">3 posts tagged <strong>Local-First</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/why-local-first-matters-for-ai-agents/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/tags/multi-agent/index.html b/docs/blog/tags/multi-agent/index.htmlindex 7b9d57bb..62ed8690 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">35 posts tagged <strong>Multi-Agent</strong>.</p>+ <p class="lead">41 posts tagged <strong>Multi-Agent</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -224,6 +224,24 @@</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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1"><span>MEMORY</span>@@ -242,6 +260,96 @@</div></div></article>+<article class="card">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-guides" href="/blog/prompt-caching-for-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/prompt-caching-for-ai-agents/">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</a></h3>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/prompt-caching-for-ai-agents/" aria-label="Read: Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice">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>+ </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/small-team-ai-agents-playbook/">A Small-Team Playbook for AI Coding Agents</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/small-team-ai-agents-playbook/" aria-label="Read: A Small-Team Playbook for AI Coding Agents">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/tags/open-source/index.html b/docs/blog/tags/open-source/index.htmlindex e356cf2b..422ea851 100644--- a/docs/blog/tags/open-source/index.html+++ b/docs/blog/tags/open-source/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Open Source</h1>- <p class="lead">1 post tagged <strong>Open Source</strong>.</p>+ <p class="lead">2 posts tagged <strong>Open Source</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">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/tags/orchestration/index.html b/docs/blog/tags/orchestration/index.htmlindex 719a7823..3d350e8a 100644--- a/docs/blog/tags/orchestration/index.html+++ b/docs/blog/tags/orchestration/index.html@@ -58,7 +58,7 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Orchestration</h1>- <p class="lead">10 posts tagged <strong>Orchestration</strong>.</p>+ <p class="lead">11 posts tagged <strong>Orchestration</strong>.</p></header><section class="wrap"><div class="post-grid">@@ -116,6 +116,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span>diff --git a/docs/blog/tags/performance/index.html b/docs/blog/tags/performance/index.htmlindex 5696f1c3..951d8330 100644--- a/docs/blog/tags/performance/index.html+++ b/docs/blog/tags/performance/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Performance</h1>- <p class="lead">1 post tagged <strong>Performance</strong>.</p>+ <p class="lead">2 posts tagged <strong>Performance</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/prompt-caching-for-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/prompt-caching-for-ai-agents/">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</a></h3>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/prompt-caching-for-ai-agents/" aria-label="Read: Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-internals" href="/blog/rendering-many-live-terminals-performance/" aria-hidden="true" tabindex="-1"><span>INTERNALS</span></a>diff --git a/docs/blog/tags/prompt-caching/index.html b/docs/blog/tags/prompt-caching/index.htmlnew file mode 100644index 00000000..65a08917--- /dev/null+++ b/docs/blog/tags/prompt-caching/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>Prompt Caching — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Prompt Caching." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/prompt-caching/" />++<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="Prompt Caching — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Prompt Caching." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/prompt-caching/" />+<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="Prompt Caching — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Prompt Caching." />+<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>#Prompt Caching</h1>+ <p class="lead">1 post tagged <strong>Prompt Caching</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-guides" href="/blog/prompt-caching-for-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/prompt-caching-for-ai-agents/">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</a></h3>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/prompt-caching-for-ai-agents/" aria-label="Read: Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice">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.htmlnew file mode 100644index 00000000..31dfeaa0--- /dev/null+++ b/docs/blog/tags/reliability/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>Reliability — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Reliability." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/reliability/" />++<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="Reliability — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Reliability." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/reliability/" />+<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="Reliability — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged Reliability." />+<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>#Reliability</h1>+ <p class="lead">1 post tagged <strong>Reliability</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">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/trust/index.html b/docs/blog/tags/trust/index.htmlnew file mode 100644index 00000000..2b60058e--- /dev/null+++ b/docs/blog/tags/trust/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>Trust — Munder Difflin Blog</title>+<meta name="description" content="Munder Difflin blog posts tagged Trust." />+<link rel="canonical" href="https://munderdiffl.in/blog/tags/trust/" />++<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="Trust — Munder Difflin Blog" />+<meta property="og:description" content="Munder Difflin blog posts tagged Trust." />+<meta property="og:url" content="https://munderdiffl.in/blog/tags/trust/" />+<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="Trust — Munder Difflin Blog" />+<meta name="twitter:description" content="Munder Difflin blog posts tagged 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" />++</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>#Trust</h1>+ <p class="lead">1 post tagged <strong>Trust</strong>.</p>+</header>+<section class="wrap">+ <div class="post-grid">+ <article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">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/use-cases/index.html b/docs/blog/tags/use-cases/index.htmlindex 567ce092..c0b10152 100644--- a/docs/blog/tags/use-cases/index.html+++ b/docs/blog/tags/use-cases/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Use Cases</h1>- <p class="lead">3 posts tagged <strong>Use Cases</strong>.</p>+ <p class="lead">4 posts tagged <strong>Use Cases</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/tags/workflow/index.html b/docs/blog/tags/workflow/index.htmlindex feecc920..f36bec1d 100644--- a/docs/blog/tags/workflow/index.html+++ b/docs/blog/tags/workflow/index.html@@ -58,11 +58,29 @@<header class="page-head wrap"><p class="eyebrow">Tag</p><h1>#Workflow</h1>- <p class="lead">2 posts tagged <strong>Workflow</strong>.</p>+ <p class="lead">3 posts tagged <strong>Workflow</strong>.</p></header><section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-guides" href="/blog/small-team-ai-agents-playbook/" 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/small-team-ai-agents-playbook/">A Small-Team Playbook for AI Coding Agents</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/small-team-ai-agents-playbook/" aria-label="Read: A Small-Team Playbook for AI Coding Agents">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/topics/comparisons/index.html b/docs/blog/topics/comparisons/index.htmlindex 52c73534..dfedc4cd 100644--- a/docs/blog/topics/comparisons/index.html+++ b/docs/blog/topics/comparisons/index.html@@ -68,19 +68,19 @@<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">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/" aria-current="page">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/" aria-current="page">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.htmlindex 6857d068..be890ace 100644--- a/docs/blog/topics/concepts/index.html+++ b/docs/blog/topics/concepts/index.html@@ -63,24 +63,24 @@</nav><p class="eyebrow">Topic</p><h1>concepts</h1>- <p class="lead">7 posts in this cluster.</p>+ <p class="lead">9 posts in this cluster.</p><div class="filters" role="navigation" aria-label="Topics"><a class="chip" href="/blog/">All</a>- <a class="chip" href="/blog/topics/guides/">guides<span class="ct">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>@@ -125,6 +125,42 @@</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>+ <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/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a>+ </div>+ </div>+</article>+<article class="card">+ <a class="thumb t-concepts" href="/blog/open-source-ai-tools-on-purpose/" aria-hidden="true" tabindex="-1">+ <span>CONCEPTS</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/open-source-ai-tools-on-purpose/">Building AI Dev Tools in the Open, On Purpose</a></h3>+ <p class="dek">Agents touch your code, keys, and memory. That's why agent tooling should be open source and local-first — so you can verify it, not just trust it.</p>+ <div class="foot">+ <span class="tag kind">Concepts</span>+ <a class="more" href="/blog/open-source-ai-tools-on-purpose/" aria-label="Read: Building AI Dev Tools in the Open, On Purpose">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/topics/guides/index.html b/docs/blog/topics/guides/index.htmlindex 4b66e64a..981f2e79 100644--- a/docs/blog/topics/guides/index.html+++ b/docs/blog/topics/guides/index.html@@ -63,24 +63,24 @@</nav><p class="eyebrow">Topic</p><h1>guides</h1>- <p class="lead">10 posts in this cluster.</p>+ <p class="lead">12 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">10</span></a>+ <a class="chip" href="/blog/topics/guides/" aria-current="page">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>@@ -161,6 +161,42 @@</div></div></article>+<article class="card">+ <a class="thumb t-guides" href="/blog/prompt-caching-for-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/prompt-caching-for-ai-agents/">Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice</a></h3>+ <p class="dek">An agent re-sends the same prompt, tools, and context every turn. Prompt caching makes you pay for that prefix once — here's how to design for it.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/prompt-caching-for-ai-agents/" aria-label="Read: Prompt Caching for AI Agents: Stop Paying for the Same Tokens Twice">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>+ </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/small-team-ai-agents-playbook/">A Small-Team Playbook for AI Coding Agents</a></h3>+ <p class="dek">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.</p>+ <div class="foot">+ <span class="tag kind">Guides</span>+ <a class="more" href="/blog/small-team-ai-agents-playbook/" aria-label="Read: A Small-Team Playbook for AI Coding Agents">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 06a80087..1d90fd6a 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">10 posts.</p>+ <p class="dek">12 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -84,20 +84,20 @@</div></a>- <a class="card" href="/blog/topics/comparisons/" style="text-decoration:none">- <span class="thumb t-comparisons" aria-hidden="true">COMPARISONS</span>+ <a class="card" href="/blog/topics/concepts/" style="text-decoration:none">+ <span class="thumb t-concepts" aria-hidden="true">CONCEPTS</span><div class="body">- <h3 style="color:var(--ink)">comparisons</h3>- <p class="dek">8 posts.</p>+ <h3 style="color:var(--ink)">concepts</h3>+ <p class="dek">9 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>- <a class="card" href="/blog/topics/concepts/" style="text-decoration:none">- <span class="thumb t-concepts" aria-hidden="true">CONCEPTS</span>+ <a class="card" href="/blog/topics/comparisons/" style="text-decoration:none">+ <span class="thumb t-comparisons" aria-hidden="true">COMPARISONS</span><div class="body">- <h3 style="color:var(--ink)">concepts</h3>- <p class="dek">7 posts.</p>+ <h3 style="color:var(--ink)">comparisons</h3>+ <p class="dek">8 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -106,7 +106,7 @@<span class="thumb t-orchestration" aria-hidden="true">ORCHESTRATION</span><div class="body"><h3 style="color:var(--ink)">orchestration</h3>- <p class="dek">6 posts.</p>+ <p class="dek">7 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -124,7 +124,7 @@<span class="thumb t-use-cases" aria-hidden="true">USE-CASES</span><div class="body"><h3 style="color:var(--ink)">use-cases</h3>- <p class="dek">3 posts.</p>+ <p class="dek">4 posts.</p><div class="foot"><span class="more">View topic →</span></div></div></a>@@ -144,42 +144,48 @@<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">35</span></a>+ <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">41</span></a>- <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">29</span></a>+ <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">31</span></a>- <a class="chip" href="/blog/tags/internals/">Internals<span class="ct">11</span></a>+ <a class="chip" href="/blog/tags/internals/">Internals<span class="ct">12</span></a>- <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">10</span></a>+ <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">11</span></a>- <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">8</span></a>+ <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">9</span></a><a class="chip" href="/blog/tags/comparisons/">Comparisons<span class="ct">8</span></a><a class="chip" href="/blog/tags/tools/">Tools<span class="ct">8</span></a>+ <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">7</span></a>+<a class="chip" href="/blog/tags/getting-started/">Getting Started<span class="ct">7</span></a><a class="chip" href="/blog/tags/memory/">Memory<span class="ct">7</span></a>- <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">6</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">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/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/use-cases/">Use Cases<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/workflow/">Workflow<span class="ct">2</span></a>+ <a class="chip" href="/blog/tags/autonomous/">Autonomous<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/human-in-the-loop/">Human-in-the-Loop<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/git/">Git<span class="ct">2</span></a>@@ -188,9 +194,13 @@<a class="chip" href="/blog/tags/visualization/">Visualization<span class="ct">2</span></a>+ <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">2</span></a>+<a class="chip" href="/blog/tags/xtermjs/">xterm.js<span class="ct">2</span></a>- <a class="chip" href="/blog/tags/autonomous/">Autonomous<span class="ct">2</span></a>+ <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/subagents/">Subagents<span class="ct">1</span></a>@@ -204,20 +214,14 @@<a class="chip" href="/blog/tags/glossary/">Glossary<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop<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>- <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/privacy/">Privacy<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/game-dev/">Game Dev<span class="ct">1</span></a><a class="chip" href="/blog/tags/hooks/">Hooks<span class="ct">1</span></a>@@ -228,8 +232,6 @@<a class="chip" href="/blog/tags/node-pty/">node-pty<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/performance/">Performance<span class="ct">1</span></a>-<a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">1</span></a><a class="chip" href="/blog/tags/context-engineering/">Context Engineering<span class="ct">1</span></a>@@ -238,7 +240,11 @@<a class="chip" href="/blog/tags/model-routing/">Model Routing<span class="ct">1</span></a>- <a class="chip" href="/blog/tags/cost/">Cost<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/hive/">Hive<span class="ct">1</span></a>diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.htmlindex cf997bab..971d2b21 100644--- a/docs/blog/topics/internals/index.html+++ b/docs/blog/topics/internals/index.html@@ -68,19 +68,19 @@<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">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.htmlindex d66de363..0c7a7c9a 100644--- a/docs/blog/topics/memory/index.html+++ b/docs/blog/topics/memory/index.html@@ -68,19 +68,19 @@<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">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/" aria-current="page">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.htmlindex 2ff83417..7eb8870a 100644--- a/docs/blog/topics/orchestration/index.html+++ b/docs/blog/topics/orchestration/index.html@@ -63,24 +63,24 @@</nav><p class="eyebrow">Topic</p><h1>orchestration</h1>- <p class="lead">6 posts in this cluster.</p>+ <p class="lead">7 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">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/" aria-current="page">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/" aria-current="page">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>@@ -107,6 +107,24 @@</div></div></article>+<article class="card">+ <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1">+ <span>ORCHESTRATION</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>+ <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>+ <div class="foot">+ <span class="tag kind">Orchestration</span>+ <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>+ </div>+ </div>+</article><article class="card"><a class="thumb t-orchestration" href="/blog/scheduling-autonomous-agent-missions/" aria-hidden="true" tabindex="-1"><span>ORCHESTRATION</span>diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.htmlindex 4f078320..f897cd8b 100644--- a/docs/blog/topics/story/index.html+++ b/docs/blog/topics/story/index.html@@ -68,19 +68,19 @@<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">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">1</span></a>diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.htmlindex 23513399..f9d4249f 100644--- a/docs/blog/topics/use-cases/index.html+++ b/docs/blog/topics/use-cases/index.html@@ -63,24 +63,24 @@</nav><p class="eyebrow">Topic</p><h1>use-cases</h1>- <p class="lead">3 posts in this cluster.</p>+ <p class="lead">4 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">10</span></a>+ <a class="chip" href="/blog/topics/guides/">guides<span class="ct">12</span></a><a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</span></a>- <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">9</span></a>- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>+ <a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">8</span></a>- <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">7</span></a><a class="chip" href="/blog/topics/memory/">memory<span class="ct">5</span></a>- <a class="chip" href="/blog/topics/use-cases/" aria-current="page">use-cases<span class="ct">3</span></a>+ <a class="chip" href="/blog/topics/use-cases/" aria-current="page">use-cases<span class="ct">4</span></a><a class="chip" href="/blog/topics/story/">story<span class="ct">1</span></a>@@ -90,6 +90,24 @@<section class="wrap"><div class="post-grid"><article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/blog/what-are-claude-code-agents/index.html b/docs/blog/what-are-claude-code-agents/index.htmlindex cc933065..795766ea 100644--- a/docs/blog/what-are-claude-code-agents/index.html+++ b/docs/blog/what-are-claude-code-agents/index.html@@ -283,20 +283,20 @@ into an office; it’s free and open source.</p></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/what-is-aeo-for-dev-tools/">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</a></h3>- <p class="dek">Answer Engine Optimization for dev tools: how to get cited by ChatGPT, Claude, and Perplexity with the right robots.txt, JSON-LD, and writing patterns.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/what-is-aeo-for-dev-tools/" aria-label="Read: AEO for Dev Tools: Getting Cited by ChatGPT and Claude">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article>diff --git a/docs/blog/what-is-a-multi-agent-harness/index.html b/docs/blog/what-is-a-multi-agent-harness/index.htmlindex 2f39b639..282fca18 100644--- a/docs/blog/what-is-a-multi-agent-harness/index.html+++ b/docs/blog/what-is-a-multi-agent-harness/index.html@@ -270,20 +270,20 @@ want to watch a coordinated team of agents work an office floor,</div></article><article class="card">- <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta"><time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>7 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/what-is-aeo-for-dev-tools/">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</a></h3>- <p class="dek">Answer Engine Optimization for dev tools: how to get cited by ChatGPT, Claude, and Perplexity with the right robots.txt, JSON-LD, and writing patterns.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/what-is-aeo-for-dev-tools/" aria-label="Read: AEO for Dev Tools: Getting Cited by ChatGPT and Claude">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article>diff --git a/docs/blog/what-is-aeo-for-dev-tools/index.html b/docs/blog/what-is-aeo-for-dev-tools/index.htmlindex 8a618438..54009e0a 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/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 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 Concepts</h2>@@ -403,20 +403,20 @@ harness actually is</a>. Free and MIT-licensed.</p></div></article><article class="card">- <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">+ <a class="thumb t-concepts" href="/blog/how-ai-agents-verify-their-own-work/" aria-hidden="true" tabindex="-1"><span>CONCEPTS</span></a><div class="body"><div class="meta">- <time datetime="2026-06-02">Jun 2, 2026</time>+ <time datetime="2026-06-04">Jun 4, 2026</time><span class="dot" aria-hidden="true"></span>- <span>3 min</span>+ <span>5 min</span></div>- <h3><a href="/blog/ai-agent-glossary/">The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent</a></h3>- <p class="dek">Plain-English definitions of the AI coding agent terms everyone trips over — harness, orchestrator, hive, subagent, agent memory — each in one line.</p>+ <h3><a href="/blog/how-ai-agents-verify-their-own-work/">How AI Agents Verify Their Own Work (Before Saying 'Done')</a></h3>+ <p class="dek">The discipline that makes an autonomous coding agent trustworthy: prove every claim, reproduce the green, and check the fix — not just the intent.</p><div class="foot"><span class="tag kind">Concepts</span>- <a class="more" href="/blog/ai-agent-glossary/" aria-label="Read: The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent">Read →</a>+ <a class="more" href="/blog/how-ai-agents-verify-their-own-work/" aria-label="Read: How AI Agents Verify Their Own Work (Before Saying 'Done')">Read →</a></div></div></article>diff --git a/docs/blog/why-local-first-matters-for-ai-agents/index.html b/docs/blog/why-local-first-matters-for-ai-agents/index.htmlindex 2303796f..b0669866 100644--- a/docs/blog/why-local-first-matters-for-ai-agents/index.html+++ b/docs/blog/why-local-first-matters-for-ai-agents/index.html@@ -234,6 +234,24 @@ machine, on macOS, Windows, and Linux. <a href="/#install">Download Munder Diffl<h2>Related in Use Cases</h2><div class="post-grid"><article class="card">+ <a class="thumb t-use-cases" href="/blog/overnight-ai-coding-realistic-expectations/" aria-hidden="true" tabindex="-1">+ <span>USE CASES</span>+ </a>+ <div class="body">+ <div class="meta">+ <time datetime="2026-06-04">Jun 4, 2026</time>+ <span class="dot" aria-hidden="true"></span>+ <span>5 min</span>+ </div>+ <h3><a href="/blog/overnight-ai-coding-realistic-expectations/">Overnight AI Coding: What's Realistic (and What's Not)</a></h3>+ <p class="dek">An honest look at letting AI coding agents run overnight — what works today, where guardrails matter, and what still needs a human in the morning.</p>+ <div class="foot">+ <span class="tag kind">Use Cases</span>+ <a class="more" href="/blog/overnight-ai-coding-realistic-expectations/" aria-label="Read: Overnight AI Coding: What's Realistic (and What's Not)">Read →</a>+ </div>+ </div>+</article>+<article class="card"><a class="thumb t-use-cases" href="/blog/from-one-terminal-to-a-team/" aria-hidden="true" tabindex="-1"><span>USE CASES</span></a>diff --git a/docs/sitemap.xml b/docs/sitemap.xmlindex 1f372afc..7eb4379e 100644--- a/docs/sitemap.xml+++ b/docs/sitemap.xml@@ -89,18 +89,54 @@<changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/how-ai-agents-verify-their-own-work/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/</loc><lastmod>2026-06-04</lastmod><changefreq>monthly</changefreq><priority>0.8</priority></url>+ <url>+ <loc>https://munderdiffl.in/blog/local-first-ai-agent-orchestration/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/open-source-ai-tools-on-purpose/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/overnight-ai-coding-realistic-expectations/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url>+ <url>+ <loc>https://munderdiffl.in/blog/prompt-caching-for-ai-agents/</loc>+ <lastmod>2026-06-04</lastmod>+ <changefreq>monthly</changefreq>+ <priority>0.8</priority>+ </url><url><loc>https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/</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/what-is-aeo-for-dev-tools/</loc><lastmod>2026-06-04</lastmod>@@ -319,8 +355,8 @@</url><url><loc>https://munderdiffl.in/blog/topics/guides/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url><url><loc>https://munderdiffl.in/blog/topics/internals/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>- <url><loc>https://munderdiffl.in/blog/topics/comparisons/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url><url><loc>https://munderdiffl.in/blog/topics/concepts/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>+ <url><loc>https://munderdiffl.in/blog/topics/comparisons/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url><url><loc>https://munderdiffl.in/blog/topics/orchestration/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url><url><loc>https://munderdiffl.in/blog/topics/memory/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url><url><loc>https://munderdiffl.in/blog/topics/use-cases/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>@@ -332,47 +368,50 @@<url><loc>https://munderdiffl.in/blog/tags/guides/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/comparisons/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/tools/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>+ <url><loc>https://munderdiffl.in/blog/tags/concepts/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/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/concepts/</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/observability/</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/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/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/workflow/</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/god/</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/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/autonomous/</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/cost/</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/human-in-the-loop/</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/local-first/</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>- <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/game-dev/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/hooks/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><url><loc>https://munderdiffl.in/blog/tags/mcp/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url><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/performance/</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/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/cost/</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/hive/</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>