Skip to content

an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions

blog: standup h1 — 8 educational posts (42 → 50)

Chaitanya Girif2194b193abc
diff --git a/blog/src/posts/can-claude-code-agents-talk-to-each-other.md b/blog/src/posts/can-claude-code-agents-talk-to-each-other.md
new file mode 100644
index 00000000..aa84c857
--- /dev/null
+++ b/blog/src/posts/can-claude-code-agents-talk-to-each-other.md
@@ -0,0 +1,150 @@
+---
+title: "Can Claude Code Agents Talk to Each Other?"
+description: "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."
+date: 2026-06-04
+category: concepts
+categoryLabel: Concepts
+type: Non-technical
+primaryKeyword: "can claude code agents talk to each other"
+secondaryKeywords: ["inter-agent messaging", "ai agent communication", "claude code agents"]
+tags: ["Concepts", "Multi-Agent", "Claude Code", "Getting Started"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Can Claude Code agents talk to each other?"
+ a: "Not by default. A Claude Code agent can spawn subagents, but those subagents only report their result back to the agent that launched them — there is no built-in peer-to-peer channel. To get true agent-to-agent communication you add a thin coordination layer, usually a file-based message system that a router delivers between agents."
+ - q: "How do two AI agents send messages without a server?"
+ a: "Each agent writes a message as a single file into its own outbox, and a coordinating process moves that file into the recipient's inbox. No broker, no socket — just files and atomic renames. It is durable, auditable, and conflict-free because every file has exactly one writer."
+ - q: "What stops two agents from messaging back and forth forever?"
+ a: "Two things. First, only certain message types expect a reply — a request, query, or proposal — while an inform or done is terminal and must not be answered. Second, every message carries a hop count, so a thread that bounces too many times is capped before it can loop."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Can Claude Code agents talk to
+each other?</strong> Not out of the box — a Claude Code agent can spawn <strong>subagents</strong>,
+but they only report back to whoever launched them. There is no built-in peer-to-peer channel. Add a
+thin <strong>coordination layer</strong> — file-based mailboxes plus a router that delivers messages —
+and agents can message each other directly, escalate to a human, and stay <strong>auditable</strong>.
+That is exactly how a multi-agent harness turns several lone sessions into one team.</p></div>
+
+It's a fair question, and the honest answer has two halves. By default, no — Claude Code agents don't
+talk to each other. But the gap is small, and once you close it a team of agents can coordinate as
+naturally as coworkers passing notes. Here's the plain-English version of what's missing and how to
+add it.
+
+## The default: subagents report up, not across
+
+A [Claude Code agent](/blog/what-are-claude-code-agents/) is a running session with a goal and tools.
+It can spawn **subagents** — short-lived helpers that fan out a piece of work in parallel. That sounds
+like agents talking to each other, but it isn't quite. A subagent only does one thing when it
+finishes: it hands its result back to the agent that launched it. The flow is strictly **parent to
+child and back again**, like a manager delegating a task and reading the report.
+
+What that flow can't do is let two *peer* agents — two top-level sessions you started independently —
+discover each other and trade messages. Agent A has no address for Agent B. There's no shared inbox,
+no bus, no "send this to whoever owns the auth module." Each session lives in its own world.
+
+For a single task that's fine. The moment you want several agents working a project together — a
+researcher feeding a builder, a reviewer flagging a fix, an orchestrator handing out assignments —
+you need them to actually communicate. So you add a layer.
+
+## The coordination layer: mailboxes and a router
+
+The most reliable way to let agents talk turns out to be almost boringly simple: **files**. Each agent
+gets a folder with an `inbox/` and an `outbox/`. To send a message, an agent drops a single JSON file
+into its own outbox. A coordinating process — call it the router — scans every outbox on a tick, and
+moves each message into the right recipient's inbox. The recipient reads it at the start of its next
+turn and moves it to a `done/` folder so it's never processed twice.
+
+That's the whole mechanism. No Redis, no RabbitMQ, no daemon to babysit. The "infrastructure" is a
+directory and the `rename` syscall. We unpack the design in
+[atomic file mailboxes for agents](/blog/atomic-file-mailboxes-for-agents/), but the headline
+properties are what make it hold up:
+
+- **Durable.** Messages are files. If a process crashes mid-run, nothing already written is lost — the
+ router picks up where it left off.
+- **Auditable.** Every message and every delivery is a file the coordinator commits to git, so you can
+ read back exactly who said what, in order. (That works because a
+ [single committer owns the repository](/blog/single-committer-git-pattern/).)
+- **Conflict-free.** Each file has exactly one writer, and delivery is an atomic rename. Agents can be
+ busy at the same time without locks or races.
+
+The one rule that keeps it clean: **never write into another agent's folder.** You only ever write to
+your own outbox; the router does the routing. Single-writer-per-file is what makes the whole thing
+safe under concurrency.
+
+## What's actually in a message
+
+A message isn't just free text — it carries a little structure so the receiving agent knows what's
+expected of it. In practice each message names:
+
+- **who it's for** — another agent, the orchestrator, everyone (`broadcast`), or a human,
+- **a speech act** — is this a `request`, a `query`, a `proposal`, an `inform`, an `agreement`, a
+ `refusal`, or a `done`?
+- **a subject and body** — the actual content, and
+- **a thread id** — so a back-and-forth stays grouped as one conversation.
+
+The speech act is the quiet hero. It encodes intent, and intent is what prevents chatter from spiralling.
+Only a `request`, a `query`, or a `proposal` expects a reply. An `inform` or a `done` is **terminal** —
+you do not answer it. That single convention is what stops two polite agents from "thanks!" / "you're
+welcome!"-ing each other into an infinite loop. As a backstop, every message also carries a **hop
+count**, so even a misbehaving thread is capped before it can run away.
+
+## Talking to the orchestrator — and to you
+
+Peer-to-peer isn't the only direction that matters. Two special addresses round out the system.
+
+The first is the **orchestrator** (in our hive, the GOD agent). Anything ambiguous, cross-cutting, or
+needing sign-off goes to it rather than getting hashed out between peers. It hands out assignments,
+owns the shared plan, and is the one process allowed to commit — which is exactly why coordination
+stays coherent instead of fragmenting into side conversations. We cover that role in
+[how the GOD orchestrator works](/blog/how-the-god-orchestrator-works/).
+
+The second is **you**. A message addressed to a human doesn't land in an agent's inbox at all — the
+router diverts it to an approvals queue for a person to answer, and the answer comes back as a normal
+message. That's how an agent reaches a human for the genuinely critical calls without anyone having to
+watch a terminal, the same loop we describe in
+[keeping a human in the loop](/blog/human-in-the-loop-ai-agents/).
+
+## Memory is a slower kind of talking
+
+There's one more channel that's easy to miss: **shared memory.** Messages are how agents coordinate in
+the moment; memory is how they coordinate across time. When each agent writes durable facts to a notes
+file and those notes are mined into a [searchable semantic memory](/blog/semantic-memory-for-ai-agents/)
+the whole team can query, an agent can effectively "hear" what a teammate learned an hour ago without a
+message ever being sent. Fast lane: the mailbox. Slow lane: the shared memory. A good team uses both.
+
+## So — can they talk?
+
+Yes, with a caveat worth repeating: not on their own. A single Claude Code agent and its subagents form
+a manager-and-helpers tree, not a conversation. But the missing piece is small — mailboxes, a router,
+a handful of speech-act rules, and a hop cap — and once it's in place, independent agents coordinate
+like a real team: requesting work, reporting `done`, escalating to an orchestrator, and pinging a human
+only when it truly matters. That shift, from isolated sessions to a coordinated crew, is the entire
+point of [the best way to coordinate AI coding agents](/blog/coordinating-ai-coding-agents/).
+
+## FAQ
+
+**Can Claude Code agents talk to each other out of the box?** No. An agent can spawn subagents, but
+they only return their result to the agent that launched them. There's no native peer-to-peer channel
+between two independent sessions — you add a coordination layer to get one.
+
+**Do I need a message broker like Redis or RabbitMQ?** No. The most robust approach is file-based:
+each agent writes messages to its own outbox, and a router moves them to recipients' inboxes via atomic
+renames. It's durable and auditable with zero extra infrastructure.
+
+**How do agents avoid talking in circles?** Speech acts and hop counts. Only requests, queries, and
+proposals expect a reply; informs and dones are terminal. And every message carries a hop count, so a
+thread is capped before it can loop forever.
+
+**How does an agent reach a human?** It sends a message addressed to a human (or flagged as needing a
+human). The router diverts it to an approvals queue instead of an inbox, a person answers, and the
+reply comes back to the agent as a normal message.
+
+---
+
+Munder Difflin runs exactly this system: a hive of Claude Code agents that message each other through
+atomic file mailboxes, escalate to [a GOD orchestrator](https://munderdiffl.in/#how), and ping you only
+for the calls that matter — every envelope visible on a live office floor.
+[Download Munder Difflin](https://munderdiffl.in/#install) to watch your agents actually talk to each
+other; it's free and open source.
diff --git a/blog/src/posts/context-engineering-for-ai-agents.md b/blog/src/posts/context-engineering-for-ai-agents.md
new file mode 100644
index 00000000..e281ed01
--- /dev/null
+++ b/blog/src/posts/context-engineering-for-ai-agents.md
@@ -0,0 +1,170 @@
+---
+title: "Context Engineering for AI Agents: Budgeting the Window"
+description: "Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean."
+date: 2026-06-04
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "context engineering"
+secondaryKeywords: ["context engineering for ai agents", "context window management", "agent context window", "context rot"]
+tags: ["Context Engineering", "Memory", "Multi-Agent", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is context engineering?"
+ a: "Context engineering is the discipline of deciding exactly what tokens occupy a model's finite context window at each step — instructions, tools, retrieved memory, and history — so the model has what it needs and nothing it doesn't. It's the system-level successor to prompt engineering: prompt engineering tunes the wording of one message, context engineering curates the whole window over a long-running, multi-turn agent."
+ - q: "How is context engineering different from prompt engineering?"
+ a: "Prompt engineering optimizes a single static prompt. Context engineering manages a dynamic, growing window across many turns and often many agents — what to load, what to retrieve just-in-time, what to summarize, and what to keep out of the window entirely. For agents that run for hours and call dozens of tools, the prompt is the smallest part of the problem."
+ - q: "What is context rot?"
+ a: "Context rot is the degradation in answer quality as a context window fills up. More tokens isn't strictly better: irrelevant history, stale tool output, and contradictory notes distract the model and crowd out what matters. A large window is a budget to spend carefully, not a bucket to fill."
+ - q: "Why does context engineering matter more in a multi-agent system?"
+ a: "Because every agent has its own finite window and they must coordinate. If you pour all shared state into every agent's context, you pay for it in tokens, latency, and confusion. The fix is to give each agent a small, role-scoped window and keep the shared state — mailboxes, logs, the plan — in files the agent reads on demand."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Context engineering</strong> is
+deciding what occupies a model's finite window at each step — and what stays out. It's the system-level
+successor to prompt engineering. The window is a <strong>budget</strong>, not a bucket: past a point,
+more tokens make answers <em>worse</em>. The four moves that matter for a hive of agents are
+<strong>isolation</strong> (a small window per agent), <strong>retrieval</strong> (pull the few
+relevant notes, not all of them), <strong>externalized state</strong> (keep mailboxes, logs, and the
+plan in files, not in context), and <strong>compaction</strong> (summarize the long tail). Get those
+right and a fleet of agents stays sharp for hours.</p></div>
+
+For a long time the craft of working with language models was *prompt engineering* — finding the
+wording that coaxed the best answer out of a single request. That framing made sense when the unit of
+work was one prompt and one completion. It stops making sense the moment you have an agent that runs for
+an hour, calls thirty tools, reads files, and coordinates with five other agents. At that scale the
+exact phrasing of any one message is a rounding error. What decides whether the agent succeeds is the
+**entire set of tokens in its context window at the moment it has to act** — and that set is something
+you design. That design discipline is **context engineering**.
+
+## The window is a budget, not a bucket
+
+Every model has a finite context window, and that window is the agent's entire working memory. Newer
+models advertise enormous windows — hundreds of thousands of tokens, sometimes a million — and the
+intuitive conclusion is "great, I'll just put everything in." That intuition is wrong, and it's the
+single most expensive mistake in agent design.
+
+Quality does not increase monotonically with tokens. Past a certain fill level, answers get *worse* —
+a phenomenon now widely called **context rot**. Irrelevant history distracts the model; stale tool
+output gets mistaken for current state; two notes that contradict each other pull the model in two
+directions. The window is a budget you spend, and every token you add has a cost in attention even
+when it's free in dollars. The job of context engineering is to spend that budget on the
+**smallest set of high-signal tokens** that lets the model take the right next step.
+
+It helps to name the ways a window goes bad. The 2025 taxonomy that stuck:
+
+- **Poisoning** — a wrong fact (often a hallucination) lands in context and gets referenced as truth on
+ every subsequent turn.
+- **Distraction** — so much history accumulates that the model leans on it instead of reasoning about
+ the task in front of it.
+- **Confusion** — irrelevant-but-present content (a tool the agent will never call, a doc for another
+ feature) nudges the model off course.
+- **Clash** — two parts of the window disagree, and the model has no way to know which to trust.
+
+Notice that three of the four get *worse* as you add tokens. That's the whole argument for treating
+context as something to curate, not accumulate.
+
+## Multi-agent makes it sharper
+
+In a single-agent setup you can sometimes get away with a messy window. In a hive you can't. Every
+agent has its own window, and they have to coordinate. The naive design — one giant shared context that
+every agent sees — fails on all three axes at once: it's expensive (you pay for the shared blob in every
+agent's token bill), it's slow (bigger windows cost latency), and it's confusing (each agent wades
+through five other agents' chatter to find its own task).
+
+The whole architecture of [a multi-agent harness](https://munderdiffl.in/#what) is, viewed one way, an
+answer to a context-engineering question: *how do we let many agents share state without sharing
+windows?* The answer is to keep the shared state **out** of the window and let each agent pull in only
+the slice it needs.
+
+## Four moves that keep the window lean
+
+### 1. Isolation — one small window per agent
+
+The first and biggest lever is to give each agent its **own** context, scoped to its **own** role.
+A planner doesn't need the executor's tool output; a reviewer doesn't need the full chat history of the
+agent it's reviewing. When an orchestrator hands a sub-task to a specialist, it hands over a *brief* —
+the goal and the few facts that matter — not a transcript.
+
+This is why "spin up a sub-agent for the search" so often beats "stuff the search results into my own
+context." The sub-agent burns its window on the messy intermediate work and returns a clean conclusion;
+the parent's window stays small and high-signal. Isolation is context engineering's version of
+encapsulation. (For where this helps and where it doesn't, see
+[Claude Code subagents vs a multi-agent harness](/blog/claude-code-subagents-vs-multi-agent-harness/).)
+
+### 2. Retrieval — recall the relevant few, not the relevant many
+
+An agent that has worked for weeks has learned far more than fits in a window. The wrong fix is to load
+its whole history "just in case." The right fix is **retrieval**: store everything durably outside the
+window, and at each step pull in only the handful of notes that bear on the task.
+
+This is exactly what [semantic memory for AI agents](/blog/semantic-memory-for-ai-agents/) provides. The
+agent's knowledge lives in [markdown files](/blog/markdown-first-agent-memory/); a semantic index sits on
+top; a query like *"how do we build the web bundle?"* returns the two or three relevant notes by
+meaning, even if they never used those words. The window cost stays flat as the knowledge base grows —
+that's the property you're buying. Recall-everything scales the window with history; retrieval keeps it
+constant.
+
+### 3. Externalized state — files the agent reads, not tokens it carries
+
+The most underrated context-engineering move is to keep coordination state in **files** rather than in
+the window. A hive's shared plan, its message mailboxes, and its event log are all state the agents need
+*access* to — but not state they need *resident* in context at all times.
+
+In a [file-based coordination model](/blog/atomic-file-mailboxes-for-agents/), an agent reads its inbox
+at the start of a task, acts, and writes a reply to its outbox — the messages live on disk, not in a
+shared prompt. The [append-only event log](/blog/append-only-event-log-agents/) records every action for
+debugging and replay, but no agent carries the log in its window; it's read on demand when something
+needs investigating. The shared board is the plan of record, edited by one writer, read by anyone who
+needs it. The window holds a *pointer* to the state, and the agent dereferences it just-in-time. This is
+the agent equivalent of not loading the entire database into RAM.
+
+The same principle applies to tools and docs: load a tool's full schema or a library's documentation
+**when the agent decides to use it**, not preemptively for every tool it might theoretically call.
+Just-in-time beats just-in-case.
+
+### 4. Compaction — summarize the long tail
+
+Even a well-scoped agent eventually fills its window if it runs long enough. The escape valve is
+**compaction**: when the history grows past a threshold, summarize the old turns into a compact recap and
+continue from there. Done well, the agent keeps its conclusions, its open decisions, and its current
+state, while shedding the verbose middle — the tool calls and dead ends that got it there.
+
+Our hive's hourly **standup** is compaction as a team ritual: each agent reports what it did and what's
+next in a few lines, and that digest — not the raw hour of work — is what propagates. The transcript
+stays on disk for anyone who needs to replay it; the *summary* is what travels. Whether it's a single
+agent compacting its own session or a team compacting into a standup, the move is the same: trade fidelity
+you no longer need for window you do.
+
+## A practical checklist
+
+When an agent underperforms, resist the urge to rewrite its prompt first. Audit its window instead:
+
+1. **What's resident that shouldn't be?** Stale tool output, another agent's chatter, a doc for a
+ feature this agent doesn't touch — evict it.
+2. **What's missing that should be there?** The one decision from three hours ago that changes the
+ answer. Make sure retrieval surfaces it.
+3. **Is anything contradicting anything?** Two notes that clash; an outdated fact next to its correction.
+ Resolve or remove.
+4. **Could this be a sub-agent?** If the task involves messy intermediate work, isolate it and return a
+ clean result.
+5. **Is shared state in the window or in files?** Move coordination state to disk and read it on demand.
+6. **Is it time to compact?** If history dominates the window, summarize and continue.
+
+Most "the model got dumber" complaints are context problems wearing a model costume. The fix is rarely a
+better sentence; it's a cleaner window.
+
+## Why this is the durable skill
+
+Models will keep getting bigger windows, and every jump tempts people to stop curating. Don't. A bigger
+window raises the ceiling on what you *can* hold; it does nothing to change the fact that signal beats
+volume. The teams that get the most out of agents — single or swarm — are the ones who treat the context
+window as the scarce, high-value resource it is and engineer what goes into it deliberately.
+
+Munder Difflin is built around exactly these moves: [isolated per-agent windows](https://munderdiffl.in/#what),
+[semantic memory](https://munderdiffl.in/#how) that recalls the relevant few, file-based mailboxes and an
+event log that keep shared state out of context, and standups that compact the long tail.
+[Download Munder Difflin](https://munderdiffl.in/#install) to run a hive that stays sharp for hours —
+it's free and open source.
diff --git a/blog/src/posts/do-more-with-less-model-routing.md b/blog/src/posts/do-more-with-less-model-routing.md
new file mode 100644
index 00000000..a80d0aec
--- /dev/null
+++ b/blog/src/posts/do-more-with-less-model-routing.md
@@ -0,0 +1,126 @@
+---
+title: "Do More With Less: Smart Model Routing Across Agents"
+description: "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."
+date: 2026-06-04
+category: concepts
+categoryLabel: Concepts
+type: Non-technical
+primaryKeyword: "ai model routing"
+secondaryKeywords: ["model routing", "llm cost optimization", "sonnet vs opus", "ai agent cost"]
+tags: ["Model Routing", "Cost", "Orchestration", "Multi-Agent"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is AI model routing?"
+ a: "Model routing is the practice of sending each task to the model that fits it, rather than running everything on one model. A cheap, fast model handles routine work — formatting, classification, simple edits — and a heavier, more capable model is reserved for the hard reasoning. In a multi-agent system the router is usually the orchestrator, deciding per task which model an agent should use."
+ - q: "Does using a smaller model hurt quality?"
+ a: "Only if you use it for the wrong tasks. Most of what an agent does on any given hour is routine — and a smaller model does routine work just as well for a fraction of the cost and latency. Quality drops when you under-power genuinely hard reasoning, not when you right-size the easy stuff. The skill is matching task difficulty to model capability."
+ - q: "How much can model routing actually save?"
+ a: "It depends on your task mix, but the economics are stark: the gap between a small and a large model is often 10–20x per token. If most of your agents' work is routine and you route only the hard fraction to the big model, you can cut spend by more than half while keeping — sometimes improving — quality, because cheaper calls also run faster."
+ - q: "Who decides which model to use in a multi-agent hive?"
+ a: "The orchestrator. It sees the task before it's assigned, so it's the natural place to pick the model: default everyone to a lean model, and escalate to a heavier one only for tasks flagged as hard, ambiguous, or high-stakes. Individual agents can also request an escalation when they detect they're out of their depth."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>Running every agent on the biggest model is
+the most common way to waste money on a hive. Most agent work is <strong>routine</strong> — and a
+small, fast model does routine work just as well for a fraction of the cost. <strong>Model routing</strong>
+means defaulting to the lean model and <strong>escalating to a heavyweight only when the task is
+genuinely hard</strong>. The orchestrator is the natural router because it sees the task before it's
+assigned. Done right, you cut spend by more than half <em>and</em> get faster answers — doing more with
+less.</p></div>
+
+There's a reflex when you wire up a team of AI agents: give all of them the best model you can afford,
+because more capability is always better, right? It feels safe. It's also the fastest way to turn a
+useful hive into an expensive one. The truth that experienced operators learn quickly is that **most of
+what agents do all day doesn't need a frontier model at all** — and paying frontier prices for routine
+work is pure waste. The fix is **model routing**: matching the task to the model instead of flattening
+everything onto one.
+
+## The work isn't uniform — so why is the model?
+
+Watch a hive for an hour and you'll see a huge range of task difficulty. An agent reformatting a file,
+classifying a message, renaming variables, or summarizing a short log is doing **routine** work — the
+kind a small model handles perfectly. Another agent untangling a subtle race condition, designing an
+architecture, or reasoning through an ambiguous spec is doing **hard** work that genuinely rewards a
+bigger model.
+
+If you run both on the same heavyweight model, you're overpaying for the first kind every single time.
+The distribution matters: in most real workloads the routine tasks vastly outnumber the hard ones. So
+the single biggest cost lever isn't a discount — it's **not using the expensive model for the 80% of
+work that doesn't need it**.
+
+## The economics, plainly
+
+The price gap between model tiers is not small. A lean model and a frontier model can differ by
+**10–20x per token**, and the cheaper one usually answers **faster** too. Put those together and the
+arithmetic is hard to ignore:
+
+- Run **everything** on the big model → you pay the premium on every task, routine or not.
+- Run **everything** on the small model → you save money but botch the genuinely hard tasks, and a wrong
+ answer on a hard task is far more expensive than the tokens you saved.
+- **Route** → default to the lean model, escalate the hard fraction → you pay the premium only where it
+ buys you something.
+
+The third option typically cuts total spend by more than half while *keeping* quality, because you only
+spend big where capability actually changes the outcome. "Do more with less" isn't a slogan here; it's
+just what falls out of matching price to need.
+
+## The orchestrator is the natural router
+
+In a single-agent setup, routing is a manual choice you make per session. In a hive, you can do better,
+because there's already a component that sees every task before it's handed out: the
+[orchestrator](/blog/how-the-god-orchestrator-works/). It's the natural place to decide which model each
+task deserves.
+
+A simple, durable policy:
+
+1. **Default lean.** Every agent starts on the small, fast model. Most tasks never need more.
+2. **Escalate on signal.** When the orchestrator (or the agent itself) detects that a task is hard,
+ ambiguous, high-stakes, or has already failed once on the lean model, it bumps that task to the
+ heavyweight.
+3. **De-escalate after.** A hard task often has easy sub-steps. Once the reasoning is done, routine
+ follow-up work drops back to the lean model.
+
+Notice this mirrors how a good human team works: you don't put your most senior engineer on every ticket;
+you route the gnarly ones to them and let the rest flow to whoever's available. A lean orchestrator
+[coordinating specialists](/blog/coordinating-ai-coding-agents/) and escalating only when needed is the
+same idea applied to models.
+
+## Reading the signals
+
+Routing well means knowing *when* a task deserves the expensive model. You don't need a perfect predictor —
+a few cheap heuristics catch most of it:
+
+- **Stakes.** Anything touching spend, destructive operations, or shipped output earns a heavier model
+ and usually [a human check too](/blog/human-in-the-loop-ai-agents/).
+- **Ambiguity.** A vague or open-ended request (design, root-cause, "figure out why") rewards reasoning
+ power; a precise mechanical request doesn't.
+- **Failure.** If the lean model tried and got it wrong, escalate instead of retrying at the same tier —
+ retrying a too-small model is just paying twice for the same miss.
+- **Length and dependency.** Tasks that chain many steps or hold a lot of state benefit from the stronger
+ model's coherence over long runs.
+
+Everything that trips none of these — the bulk of the day — stays lean.
+
+## You can't route what you can't see
+
+The honest caveat: routing decisions are only as good as your visibility into cost. If you don't know
+which agents and tasks are burning the most tokens, you're guessing. The teams that get the most out of
+routing are the ones that **measure first** — per-agent and per-task token spend, attributed and trended
+over time — and then tune the escalation policy against real data instead of vibes. Measurement turns
+routing from a hunch into a control you can actually steer. (It's the same instinct as
+[keeping the work local and observable](/blog/why-local-first-matters-for-ai-agents/): you can't manage
+what you can't watch.)
+
+## The bottom line
+
+A hive that runs everything on the biggest model isn't being careful — it's being wasteful, and slowly.
+The better posture is **lean by default, heavy on purpose**: route the routine majority to a small fast
+model, reserve the frontier model for the hard minority, and measure enough to know which is which. You
+end up spending less, answering faster, and — because you're no longer drowning genuinely hard tasks in
+the same undifferentiated pool — often getting *better* results where it counts.
+
+Munder Difflin is built for exactly this posture: a lean [orchestrator](/#how) that routes work across a hive and
+escalates only when a task earns it. [Download Munder Difflin](https://munderdiffl.in/#install) to run an
+agent team that does more with less — it's free and open source.
diff --git a/blog/src/posts/how-agents-remember-semantic-memory.md b/blog/src/posts/how-agents-remember-semantic-memory.md
new file mode 100644
index 00000000..85ecce0b
--- /dev/null
+++ b/blog/src/posts/how-agents-remember-semantic-memory.md
@@ -0,0 +1,153 @@
+---
+title: "How AI Agents Remember: Semantic Memory in a Hive"
+description: "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."
+date: 2026-06-04
+category: memory
+categoryLabel: Memory
+type: Technical
+primaryKeyword: "how ai agents remember"
+secondaryKeywords: ["semantic memory mempalace", "ai agent memory", "claude code memory"]
+tags: ["Memory", "MemPalace", "Multi-Agent", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "How do AI agents remember between sessions?"
+ a: "They write durable facts to a plain-markdown memory file, and the harness mines that file into a shared semantic index — so any agent can recall it by meaning in a later session, even after its context window is wiped."
+ - q: "What is MemPalace?"
+ a: "MemPalace is the CLI-driven semantic memory layer Munder Difflin uses: one shared palace on disk, a wing per agent, mined from each agent's memory.md and queried with `mempalace search` and `mempalace wake-up`."
+ - q: "Do agents manage the search index themselves?"
+ a: "No. The harness re-mines each changed memory.md every few minutes; agents just write notes and later run `mempalace search` or `wake-up` to recall — there's no database to administer and no MCP server to stand up."
+ - q: "What happens if MemPalace isn't installed?"
+ a: "Nothing breaks. The semantic layer degrades to a no-op and agents fall back to reading their markdown memory directly — the fast path is an upgrade, not a dependency."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>An agent's working memory — its context
+window — is wiped at the end of every session. So agents "remember" in two moves: they write durable
+facts to a plain-markdown file, and the harness <strong>mines</strong> that file into a shared
+semantic index. Later, any agent recalls by <strong>meaning</strong> with <code>mempalace search</code>
+or boots with a <code>wake-up</code> digest. This is the hands-on version, grounded in the real code in
+<code>src/main/memory.ts</code> — the mine loop, the per-agent wings, and the gotchas we hit
+making it not hang.</p></div>
+
+If you've read [what semantic memory is and why markdown-first beats a heavy database](/blog/semantic-memory-for-ai-agents/),
+this is the companion that shows the machinery actually working. No new theory — just the moving parts,
+the exact commands, and the small decisions that make shared recall reliable in
+[a coordinated hive of Claude Code agents](/blog/coordinating-ai-coding-agents/).
+
+## The shape: one palace, many wings
+
+The whole thing lives in one file — `src/main/memory.ts`, a `MemoryManager` running in the Electron
+main process. It's deliberately **CLI-only** (no MCP server): the harness keeps a single shared
+*palace* on disk under the harness home, and points every agent's `MEMPALACE_PALACE_PATH` at it. When
+an agent is spawned, that env var (plus `MEMPALACE_EMBEDDING_MODEL`) is merged into its environment, so
+the agent's own `mempalace` CLI hits the shared store automatically.
+
+Inside the palace, each agent gets its own **wing** — addressed by its agent id (`--wing <id>`). This
+buys two properties at once:
+
+- **Private authorship.** Each agent only ever writes its own `memory.md`, which keeps the
+ [single-writer rule](/blog/single-committer-git-pattern/) intact — no two agents clobber the same file.
+- **Shared recall.** A query can scope to one wing *or* sweep the whole palace. So the researcher's
+ notes are recallable by the coder later, with nobody copy-pasting context.
+
+That second property is the entire reason a hive beats a lone agent on memory: knowledge accumulates in
+one place and everyone draws from it.
+
+## Mining: how a note becomes searchable
+
+Agents don't touch the index by hand. A background **mine loop** does it for them. From the real code,
+`MINE_INTERVAL_MS` is `180_000` — so every **three minutes** the manager walks
+`hive/agents/*`, looks at each `memory.md`, and mines the ones that changed:
+
+```bash
+mempalace mine <agentDir> --wing <id> --agent <id>
+```
+
+The "ones that changed" part matters. The loop keeps a `lastMined` map of each agent's `memory.md`
+modification time and **skips files whose mtime is unchanged** — so it doesn't reload the embedding
+model to re-index notes that haven't moved. Write a durable fact to your markdown, and a few minutes
+later it's searchable by the whole team, with zero extra steps on your part. (This is also why
+`PROTOCOL.md` tells agents *"your memory.md is mined automatically — you don't run mine yourself."*)
+
+Two robustness details worth copying if you build something similar:
+
+- **Re-mining is safe.** MemPalace dedups, so mining the same notes again is idempotent. If a mine
+ exits non-zero, the loop simply drops that agent from `lastMined` so the next tick retries it.
+- **stdin is closed.** The child is spawned with stdin ignored, because the CLI can prompt — and a
+ spawned process waiting on a prompt nobody answers hangs forever.
+
+### Why we don't run `mempalace init`
+
+This is the kind of detail you only learn by hitting it. The obvious bootstrap is `mempalace init`,
+but it ends in an interactive `Mine now? [Y/n]` prompt that `--yes` doesn't cover — so a spawned child
+would hang on it indefinitely. The fix in `memory.ts` is to **skip init entirely** and let the first
+`mempalace mine` lazily create the palace (downloading the local embedding model once, on first run).
+One less moving part, and no hang.
+
+## Recall: `search` and `wake-up`
+
+With notes mined, an agent recalls in two ways — both plain CLI calls it runs itself:
+
+```bash
+mempalace search "how do we build the web bundle?" --results 5
+mempalace search "build quirks" --wing dwight-abc123 # scope to one agent's wing
+mempalace wake-up # session-start digest
+```
+
+- **`search`** returns the most relevant notes *by meaning* — so "how do we build the web bundle?"
+ finds a note about electron-vite even with no shared keywords. You can widen with `--results N` or
+ narrow with `--wing <id>`.
+- **`wake-up`** returns a short digest (a few hundred tokens) structured into an identity layer and an
+ "essential story" of what matters across the team. It's meant to be read at the *start* of a task, so
+ an agent boots with the hive's relevant knowledge already in hand instead of cold. `PROTOCOL.md`
+ bakes this into the routine: run `wake-up` at the start of a task, `search` when you need to recall
+ something specific.
+
+Both calls run with a generous timeout and an empty stdin (again: never wait on a prompt). The reason
+recall feels instant is that the expensive work — turning notes into vectors — already happened during
+mining; at recall time you embed one short query and compare against pre-computed vectors.
+
+## Graceful degradation is the safety net
+
+The manager exposes a `status()` with four honest booleans — `available` (is the `mempalace` CLI on
+PATH?), `enabled` (user setting), `active`, and `initialized`. It resolves the binary across the
+shell PATH plus the usual `~/.local/bin`, Homebrew, and `/usr/local/bin` spots. And critically: **if
+the CLI isn't installed, the whole layer is a silent no-op.** Agents fall back to reading their
+markdown `memory.md` directly. The semantic index is a recall *accelerator* sitting on top of the
+markdown — never a single point of failure that takes the memory down with it.
+
+The embedding model is configurable (`minilm` by default for snappy local recall, `embeddinggemma`
+when you want a heavier multilingual model). Everything runs locally — the palace, the model, the
+mining — so memory stays [local-first](/blog/why-local-first-matters-for-ai-agents/) and private.
+
+## Why this matters for a hive (not just one agent)
+
+A single agent with memory is useful. A *hive* with shared memory compounds:
+
+- Your briefs get shorter every week, because the team stops needing context re-explained.
+- Agents stop contradicting each other, because they recall the same shared decisions.
+- A brand-new agent is useful immediately — it wakes up into the team's accumulated knowledge instead
+ of a blank slate.
+
+That shared, durable recall is also what lets the [GOD orchestrator](/blog/how-the-god-orchestrator-works/)
+route well: it can recall what's been tried and who knows what, instead of asking you every time.
+
+## FAQ
+
+**Where does the palace actually live?** Under the harness home, in a `palace/` directory. Every
+agent's `MEMPALACE_PALACE_PATH` points there, so it's genuinely one shared store, not a copy per agent.
+
+**How often is memory refreshed?** Every three minutes the harness re-mines any `memory.md` that
+changed since last time. Unchanged files are skipped, so it's cheap.
+
+**Do I have to write notes a certain way?** Small, atomic, factual notes recall sharply; rambling ones
+recall fuzzily. Good memory hygiene is the one thing that's on you — see
+[why we built agent memory markdown-first](/blog/markdown-first-agent-memory/).
+
+---
+
+Munder Difflin gives every Claude Code agent plain-markdown memory plus a shared semantic palace the
+whole [hive can recall from](/#how) — local, fast, and graceful when the index isn't there.
+[Download Munder Difflin](/#install) to give your agents memory that actually sticks; it's free and
+open source.
diff --git a/blog/src/posts/keep-agent-semantic-memory-clean.md b/blog/src/posts/keep-agent-semantic-memory-clean.md
new file mode 100644
index 00000000..527bdf9f
--- /dev/null
+++ b/blog/src/posts/keep-agent-semantic-memory-clean.md
@@ -0,0 +1,157 @@
+---
+title: "Keep Your Agent's Semantic Memory Clean: Don't Index the Config"
+description: "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."
+date: 2026-06-04
+category: memory
+categoryLabel: Memory
+type: Technical
+primaryKeyword: "agent semantic memory hygiene"
+secondaryKeywords: ["semantic memory noise", "gitignore semantic index", "agent memory pruning"]
+tags: ["Memory", "MemPalace", "Multi-Agent", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Why would an agent's semantic memory return config files instead of real notes?"
+ a: "Because the indexer mines a directory, and the directory holds more than your notes. If your agent's folder also contains a settings file, a cursor file, and an inbox of message JSON, a naive 'index everything' pass files all of it. A large config blob produces many embeddings, so it dominates the wake-up digest and crowds out the handful of notes you actually wrote."
+ - q: "How do I stop a miner from indexing config and message files?"
+ a: "Most file-based miners honor .gitignore. Drop a .gitignore in each indexed directory listing the non-memory files (settings, cursor, inbox/, outbox/) and the miner skips them on the next pass. No flag, no fork — you're using a mechanism the tool already respects."
+ - q: "Does adding .gitignore remove what was already indexed?"
+ a: "No. Mining is usually additive — it files new content but doesn't delete drawers for files it no longer scans. To clear what's already in the index you need a prune/sync pass that removes entries whose source is now gitignored, deleted, or moved. The .gitignore prevents future noise; the prune cleans up the past."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>A semantic memory layer indexes whatever
+files you point it at — and an agent's folder holds more than its notes. When a large
+<strong>settings file</strong> and a folder of <strong>message JSON</strong> got mined alongside the
+real <code>memory.md</code>, the wake-up digest filled with config blobs and became unreadable. The fix
+is two moves: drop a <strong>.gitignore</strong> in each indexed directory so the miner skips the
+non-memory files, then run a <strong>prune pass</strong> to evict what was already filed. Recall is only
+as good as the corpus you feed it.</p></div>
+
+[Semantic memory](/blog/semantic-memory-for-ai-agents/) is supposed to make an agent recall the right
+note by *meaning* — you ask "how do we build the web bundle?" and it surfaces the note about
+electron-vite even though you never typed that word. It works beautifully when the index contains your
+notes. It falls apart quietly when the index contains everything *else* too.
+
+This is a short post about a real bug I hit in a running hive, why it happened, and the small fix that
+made the memory layer useful again. The lesson generalizes to any agent that mines a directory into a
+vector store.
+
+## The symptom: a wake-up digest full of config
+
+Each agent in the hive keeps a markdown memory and writes durable facts to it as it works. A background
+loop mines every agent's folder into a shared semantic store every few minutes, so the whole team can
+recall by meaning. At session start an agent runs a `wake-up` command that returns the most salient
+memories in ~600–900 tokens — its "what do I already know" digest.
+
+One morning the digest looked like this:
+
+```text
+## L1 — ESSENTIAL STORY
+[general]
+ - { "hooks": { "Stop": [ { "hooks": [ { "type": "command",
+ "command": "node \"/.../cth-hook.cjs\"" ... (settings.json)
+ - ] } ], "PostToolUse": [ { "matcher": "*", ... (settings.json)
+ - # Memory — Kelly _Append durable facts, decisions, and context below._ (memory.md)
+ - { "hooks": { "Stop": [ ... (settings.json)
+```
+
+The "essential story" was almost entirely a hooks configuration file, repeated across agents, with the
+occasional real note wedged between the blobs. The most important context an agent could load was
+being spent on JSON it would never need to recall.
+
+## The cause: the index ate the whole directory
+
+The miner does what most file-based indexers do — it walks the target directory and files every file it
+finds. But an agent's folder isn't just `memory.md`. It also holds:
+
+- `settings.json` — the Claude Code hooks config. A large, deeply-nested JSON blob.
+- `cursor.json` — bookkeeping for which messages have been processed.
+- `inbox/` and `outbox/` — raw inter-agent message JSON, unstructured and high-volume.
+
+Two things made this especially toxic to recall. First, **size becomes weight**: a big config file
+chunks into many embeddings, so it occupies far more of the index than a terse three-line note — and a
+digest that ranks by salience surfaces it first. Second, **machine files aren't memories**: a hooks
+config or a message envelope has no durable knowledge in it, so every drawer it fills is pure noise. The
+signal — the few sentences an agent actually wrote down — drowned.
+
+This is the semantic-memory version of a classic [context-engineering](/blog/context-engineering-for-ai-agents/)
+mistake: the failure isn't the model or the embeddings, it's that we fed the layer the wrong corpus.
+
+## The fix, part one: tell the miner what not to read
+
+The miner already honored `.gitignore` — it just had nothing to honor, because the agent folders had no
+`.gitignore`. So the fix is to write one. In each indexed directory:
+
+```gitignore
+settings.json
+cursor.json
+inbox/
+outbox/
+```
+
+On the next pass the miner skips those paths and files only the real memory. No new flag, no fork of the
+tool, no `--exclude` plumbing through three layers of code — we used a convention the indexer already
+respected. Two places write this file: the indexer ensures it exists right before each mine, and the
+agent bootstrap drops it in at *birth*, next to the freshly-created `memory.md`, so a new agent is clean
+from its first cycle. The write is append-only and idempotent — it adds only the missing lines and never
+rewrites a file that's already correct, so it's safe to call every cycle.
+
+There's a small design principle hiding here: **the directory you index should describe what belongs in
+it.** A `.gitignore` is a readable, version-controlled declaration of "these files are operational, not
+knowledge." That's better than burying an exclude list inside the miner, where the next person has to go
+read source code to find out why their config isn't showing up in recall.
+
+## The fix, part two: prune what's already filed
+
+Adding a `.gitignore` stops *future* noise. It does nothing about the thousands of config drawers
+already sitting in the index, because mining is **additive** — it files new content and updates changed
+content, but it doesn't delete drawers for files it simply stopped scanning. Re-mining the cleaned
+folder won't help; the old entries aren't tied to anything the new pass touches.
+
+You need a separate prune. A good memory CLI ships one — a `sync` that walks the index and removes any
+drawer whose source file is now gitignored, deleted, or moved:
+
+```bash
+# preview first — see what would be removed
+mempalace sync ./hive/agents --dry-run
+
+# then commit the deletions
+mempalace sync ./hive/agents --apply
+```
+
+In the live hive this evicted ~800 noise drawers (the gitignored config and message JSON, plus a few
+whose source files had already been archived) and kept ~600 real-memory drawers. The global wake-up went
+from a wall of `settings.json` to actual notes — agent roles, working directories, a design hand-off, a
+release decision — and the digest got *smaller* (754 → 603 tokens) while carrying far more signal.
+
+> **Mental model:** `.gitignore` is the filter on the way *in*; `sync --apply` is the cleanup on the way
+> *out*. You need both. The first keeps the corpus clean going forward; the second repairs the damage
+> already done. Doing only the first leaves you waiting for the noise to age out on its own — and it
+> won't.
+
+## Why this matters beyond one tool
+
+If you're building or running any agent with a [long-term memory layer](/blog/give-claude-code-long-term-memory/),
+the takeaway is corpus discipline:
+
+- **Index notes, not machinery.** Config, cursors, locks, and message logs are operational state, not
+ knowledge. Keep them out of the recall corpus on purpose.
+- **Make exclusions declarative.** A `.gitignore` (or equivalent manifest) at the indexed root is
+ legible and diffable; an exclude list hidden in code is neither.
+- **Separate "stop indexing" from "remove what's indexed."** Additive miners don't garbage-collect.
+ Budget for a periodic prune, or your index slowly fills with the ghosts of files you've moved on from.
+- **Watch the digest, not just the search.** A keyword search can still find a good note buried under
+ noise; a fixed-size wake-up digest can't — it's the canary that tells you the corpus has drifted.
+
+Good [memory hygiene](/blog/markdown-first-agent-memory/) is the difference between a memory layer that
+sharpens an agent and one that buries it. Small, atomic, factual notes in; operational files out; a
+prune pass to keep it honest.
+
+---
+
+Munder Difflin gives every Claude Code agent markdown memory plus
+[a shared semantic palace the whole hive can recall from](https://munderdiffl.in/#how) — local, fast,
+and clean by default.
+[Download Munder Difflin](https://munderdiffl.in/#install) to give your agents memory that actually
+sticks; it's free and open source.
diff --git a/blog/src/posts/scheduling-autonomous-agent-missions.md b/blog/src/posts/scheduling-autonomous-agent-missions.md
new file mode 100644
index 00000000..11c4d5d5
--- /dev/null
+++ b/blog/src/posts/scheduling-autonomous-agent-missions.md
@@ -0,0 +1,168 @@
+---
+title: "Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions"
+description: "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."
+date: 2026-06-04
+category: orchestration
+categoryLabel: Orchestration
+type: Technical
+primaryKeyword: "scheduled agent missions"
+secondaryKeywords: ["recurring autonomous tasks", "schedule ai agents", "cron for ai agents"]
+tags: ["Orchestration", "Automation", "Autonomous", "Hive"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is a scheduled mission in a multi-agent harness?"
+ a: "A scheduled mission is a recurring instruction the harness fires on a fixed interval. Each tick it sends a request message to a target agent — a specific one or the whole hive — so work happens on a cadence without anyone typing a prompt. Think cron, but the job is an agent task."
+ - q: "How is a scheduled mission different from an autonomous loop?"
+ a: "An autonomous loop keeps one agent going until its queue is empty. A scheduled mission refills that queue on a timer. The loop is the engine; the schedule is the alarm clock. Together they let a hive pick up fresh, recurring work on its own and then run each piece to completion."
+ - q: "Do scheduled missions run when the app is closed?"
+ a: "No. The timers live in the desktop app's process, so missions only fire while it's open — this is local-first, not a cloud cron. But each mission remembers when it last fired, so on the next launch an overdue mission fires right away and the cadence resumes instead of resetting."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>A <strong>scheduled mission</strong> is a
+recurring instruction the harness fires on an interval: each tick it drops a <code>request</code> into
+a target agent's queue, so a hive does standups, audits, or nightly reports <strong>without you typing
+a prompt</strong>. It pairs with the <a href="/blog/claude-code-automation-while-you-sleep/">autonomous
+loop</a> — the loop keeps an agent working until its queue is empty, the schedule refills the queue on
+a cadence. Missions remember when they last fired, so restarts resume the rhythm instead of resetting
+it.</p></div>
+
+There's a difference between an agent that works *when you ask* and a hive that works *on a schedule*.
+The first still needs you at the keyboard. The second wakes itself up — runs a standup every hour,
+audits the build every night, summarizes new issues every morning — and only pulls you in when
+something actually needs a human. Munder Difflin ships this as **scheduled missions**, and this guide
+walks through how they work, grounded in the real code, plus the patterns that keep them useful instead
+of noisy.
+
+## What a mission actually is
+
+A mission is a small, persisted record. In `src/main/config.ts` it's a `ScheduledMission`:
+
+```ts
+interface ScheduledMission {
+ id: string;
+ label: string; // shows up as the message subject
+ intervalMs: number; // the cadence
+ to: string; // target: an agent id, or 'broadcast'
+ body: string; // the instruction the agent receives
+ enabled: boolean;
+ lastFiredAt?: number; // scheduler-owned; when it last ran
+}
+```
+
+Missions live in the harness config under a `missions[]` array, so they survive restarts. That's the
+whole data model — no DAG, no external job store. A mission is "send *this* instruction to *this*
+target, every *this often*."
+
+## How the scheduler fires
+
+The engine is `syncMissions()` in `src/main/index.ts`. It runs on boot (right after the message router
+starts) and again after any change to your missions. Each run it does two things: clear every existing
+timer, then arm a fresh timer for each enabled mission. Clearing first is what makes editing one
+mission safe — nothing gets double-armed.
+
+When a mission's timer fires, the `fire()` callback does exactly two things:
+
+```ts
+if (hive.enabled()) {
+ hive.send({ to: m.to, act: 'request', subject: m.label, body: m.body }, 'scheduler');
+}
+// then stamp lastFiredAt = Date.now() back into config
+```
+
+That's the heart of it. A mission tick is just a `request` message, sent **from `scheduler`**, that
+lands in the target agent's inbox like any other message. The agent reads it at the start of its next
+turn and acts. There's nothing special about a scheduled task once it's in the queue — which is exactly
+why it composes so cleanly with the rest of the hive.
+
+This very post is proof. It exists because an **"Hourly Standup" mission** fired: a request, from
+`scheduler`, broadcast to every agent, asking each to report status and pick up work. No one typed that
+prompt this hour. The schedule did.
+
+## Why `lastFiredAt` matters
+
+The one piece of cleverness worth understanding is `lastFiredAt`. A naive scheduler would restart every
+interval from zero whenever the app reboots or you edit an unrelated mission — so an hourly job could
+drift, double-fire, or never fire if you kept tweaking things. Instead, the harness computes how much
+time is actually left:
+
+```ts
+const remaining = Math.max(0, m.intervalMs - (Date.now() - (m.lastFiredAt ?? 0)));
+setTimeout(() => { fire(); setInterval(fire, m.intervalMs); }, remaining);
+```
+
+It waits only the time *remaining* until the next due fire, then settles into a steady interval. If a
+mission is overdue (you closed the app over lunch), `remaining` is `0` and it fires right away on the
+next launch. The cadence resumes; it doesn't reset. And because the renderer can never overwrite the
+scheduler's `lastFiredAt` — `missions:save` merges by id and keeps the newer value — editing a
+mission's text in the UI won't accidentally rewind its clock.
+
+On shutdown, `clearMissionTimers()` tears down every pending `setTimeout` and `setInterval`, so a tick
+can never fire into half-torn-down services during quit. The result is a scheduler that's boring in the
+best way: it survives restarts, edits, and quits without surprising you.
+
+## Good patterns
+
+A scheduler that fires the same instruction forever rewards a particular style of mission.
+
+- **Write idempotent bodies.** Because a mission runs again and again, its instruction should be safe to
+ repeat. "Post a standup," "audit the latest build," "summarize new issues since the last run" are
+ great. "Create the project" is not — it'd duplicate every tick. Phrase the body as a recurring verb,
+ not a one-time setup.
+- **Match cadence to how fast reality changes.** `intervalMs` is your rhythm. An hourly standup, a
+ nightly report, a weekly retro — pick the interval from the underlying state, not from a vague sense
+ that "more often is better."
+- **Target a coordinator for fan-out work.** Sending a "gather status and assign tasks" mission to
+ [the orchestrator](https://munderdiffl.in/#how) lets one coordinator decide and delegate, instead of
+ blasting an identical instruction at every agent. The orchestrator is built for exactly this routing.
+- **Pause with `enabled`, don't delete.** Flip `enabled: false` to stop a mission while keeping its
+ history and `lastFiredAt`. You can switch it back on later and the cadence picks up cleanly.
+
+## Pitfalls to avoid
+
+- **Flooding the hive.** The scheduler will fire as often as you tell it to — restraint is on you. A
+ one-minute mission to `broadcast` will bury every agent's inbox and burn tokens fast. If agents can't
+ finish before the next tick, the interval is too short.
+- **Non-idempotent instructions.** A body that assumes it's running for the first time will create
+ duplicates on every fire. Always read a mission body as "what should happen *each time*."
+- **Expecting an interrupt.** A mission is a queued `request`, not a signal that stops what an agent is
+ doing. If the target is mid-task, the mission waits its turn — usually fine, but know it isn't
+ instant.
+- **Forgetting it's local-first.** Timers live in the app's process, so missions only fire while the
+ desktop app is open. That's a deliberate trade for a tool you run on your own machine — and
+ `lastFiredAt` softens it by firing overdue missions on the next launch. If you need firing while the
+ laptop is shut, that's a cloud cron's job, not this one.
+
+## Where it fits
+
+Scheduled missions are the alarm clock; the [autonomous
+loop](/blog/claude-code-automation-while-you-sleep/) is the engine that keeps an agent running until
+its queue is empty; the [message router](/blog/coordinating-ai-coding-agents/) is the nervous system
+that delivers each tick. Put them together and a hive becomes genuinely self-driving on the recurring
+work: it wakes up on schedule, routes the task through [the orchestrator](/blog/how-the-god-orchestrator-works/),
+runs it to completion, and escalates to you only when a decision is genuinely yours to make.
+
+## FAQ
+
+**What is a scheduled mission?** A recurring instruction the harness fires on a fixed interval. Each
+tick it sends a `request` message to a target agent (or the whole hive via `broadcast`), so work
+happens on a cadence with no prompt from you.
+
+**How is it different from an autonomous loop?** The loop keeps a single agent working until its queue
+is empty; the schedule refills that queue on a timer. The loop is the engine, the mission is the alarm
+clock — they're complementary, not competing.
+
+**Do missions fire when the app is closed?** No — the timers run inside the desktop app's process, so
+it's local-first, not a cloud cron. But each mission records `lastFiredAt`, so an overdue mission fires
+immediately on the next launch and the cadence resumes instead of resetting.
+
+**How do I stop a mission without losing it?** Set `enabled: false`. It stays in your config with its
+history intact, and you can re-enable it later without rewinding the clock.
+
+---
+
+Munder Difflin runs exactly this: a local hive of Claude Code agents that picks up recurring work on a
+schedule, routes it through [a GOD orchestrator](https://munderdiffl.in/#how), and pings you only for
+the calls that matter. [Download Munder Difflin](https://munderdiffl.in/#install) to set your first
+mission and watch the floor wake itself up; it's free and open source.
diff --git a/blog/src/posts/what-is-aeo-for-dev-tools.md b/blog/src/posts/what-is-aeo-for-dev-tools.md
new file mode 100644
index 00000000..86c5dacc
--- /dev/null
+++ b/blog/src/posts/what-is-aeo-for-dev-tools.md
@@ -0,0 +1,207 @@
+---
+title: "AEO for Dev Tools: Getting Cited by ChatGPT and Claude"
+description: "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."
+date: 2026-06-04
+category: concepts
+categoryLabel: Concepts
+type: Non-technical
+primaryKeyword: "answer engine optimization"
+secondaryKeywords: ["aeo", "generative engine optimization", "ai search"]
+tags: ["Concepts", "AEO", "SEO", "DevRel"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is Answer Engine Optimization (AEO)?"
+ a: "AEO is optimizing your content so AI answer engines like ChatGPT, Claude, and Perplexity cite it when they answer a user's question — the AI-era successor to ranking in Google's blue links."
+ - q: "How is AEO different from SEO?"
+ a: "SEO optimizes a page to rank so a human clicks it; AEO optimizes content to be the source an AI quotes in its synthesized answer, often with no click at all."
+ - q: "How do I get my dev tool cited by ChatGPT and Claude?"
+ a: "Answer the question in the first sentence, mark it up with FAQPage and SoftwareApplication JSON-LD, let AI crawlers like GPTBot and ClaudeBot into your robots.txt, and be the clearest canonical source on your topic."
+ - q: "Should I block AI crawlers in robots.txt?"
+ a: "If you want citations, no — blocking GPTBot, ClaudeBot, or Google-Extended removes you from the answers; only block them if avoiding training use matters more than being discovered."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Answer Engine Optimization (AEO)</strong>
+is making your content the thing an AI <em>quotes</em>, not just a page a human clicks. For a developer
+tool whose users increasingly ask ChatGPT, Claude, and Perplexity "what should I use for X?", being
+cited in that answer is the new front page. The playbook: <strong>answer first</strong>,
+<strong>mark it up</strong> with JSON-LD, <strong>let the AI crawlers in</strong>, and <strong>be the
+clearest source</strong> on your topic. Here's exactly how we do it for Munder Difflin — copy it.</p></div>
+
+A growing share of "how do I…" and "what's the best tool for…" questions never reach a search box
+anymore. They go to an answer engine — ChatGPT, Claude, Perplexity, Google's AI Overviews — which
+reads the web for you and hands back a synthesized answer with a few citations. If your
+[dev tool](/blog/best-claude-code-multi-agent-tools/) isn't in those citations, you're invisible to
+the exact developers evaluating tools like yours.
+
+This is the discipline of **Answer Engine Optimization (AEO)** — sometimes called Generative Engine
+Optimization (GEO). It overlaps with SEO but optimizes for a different outcome: not a ranked link, but
+a *quoted sentence*. This post is the playbook we actually run, with the real config.
+
+## AEO vs SEO: a click vs a quote
+
+**SEO optimizes a page to rank so a human clicks it. AEO optimizes content to be the source an AI
+quotes in its answer — often with no click at all.** They share foundations (crawlable, fast,
+well-structured pages) but diverge on intent:
+
+| | SEO | AEO |
+|---|---|---|
+| **Goal** | Rank → earn the click | Be the cited source in the answer |
+| **Unit that wins** | The page | The quotable sentence |
+| **Reader** | A human skimming results | An LLM extracting a claim |
+| **Best content shape** | Keyword-targeted long-form | Direct answers + structured facts |
+| **Win condition** | Position 1–3 | "According to Munder Difflin…" |
+
+The good news: you don't choose between them. AEO is mostly SEO done with a tighter discipline —
+clearer answers, stronger structure, honest facts. A page that an LLM can confidently quote is also a
+page Google's AI Overviews and traditional results reward.
+
+## Why dev tools should care more than most
+
+Developer tools sit at the perfect intersection for AEO:
+
+- **Your audience already asks LLMs.** "Best way to run multiple Claude Code agents?" is a question a
+ developer types into Claude before they type it into Google.
+- **The questions are answerable.** Tool comparisons, definitions, and how-tos have crisp, factual
+ answers — exactly what answer engines like to cite.
+- **You're awareness-stage.** A new or open-source tool has no brand gravity yet. Getting named in an
+ AI's answer *is* the introduction.
+
+That's why, for an open-source project like [Munder Difflin](/blog/why-we-built-munder-difflin/), we
+treat "get cited by the answer engines" as a first-class distribution channel, not an afterthought.
+
+## The AEO playbook (what we actually do)
+
+### 1. Answer the question in the first sentence
+
+LLMs extract claims, and the easiest claim to extract is a direct, self-contained sentence near the
+top. Lead with the answer, then explain — the inverted pyramid, not a slow build.
+
+So instead of *"There are many ways to think about agent coordination…"*, write: **"A multi-agent
+harness is software that wraps the agents you already run and coordinates them with memory, messaging,
+and orchestration."** That sentence can be lifted verbatim into an answer with your name attached.
+
+Every post we publish opens with a **TL;DR** and uses **bold, quotable one-liners** under each
+heading — see the [AI coding agent glossary](/blog/ai-agent-glossary/), which is one quotable
+definition after another. That structure isn't decoration; it's the extraction surface.
+
+### 2. Mark it up with structured data (JSON-LD)
+
+Structured data tells a machine *what the page is* without it having to infer. Three schemas do most
+of the AEO work for a dev tool:
+
+- **`SoftwareApplication`** on your homepage — name, description, operating systems, price, license,
+ download URL. This is how an engine knows you're a free, cross-platform tool.
+- **`FAQPage`** on pages with a Q&A block — each question/answer becomes individually quotable and is
+ eligible for "People also ask" surfaces.
+- **`BlogPosting` + `BreadcrumbList`** on articles — author, dates, and section, so the answer engine
+ can attribute and date your claim.
+
+Here's the shape of the FAQ markup we emit on this very post:
+
+```json
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [{
+ "@type": "Question",
+ "name": "What is Answer Engine Optimization (AEO)?",
+ "acceptedAnswer": {
+ "@type": "Answer",
+ "text": "AEO is optimizing your content so AI answer engines like ChatGPT, Claude, and Perplexity cite it when they answer a user's question."
+ }
+ }]
+}
+```
+
+> **Don't fabricate trust signals.** It's tempting to add `aggregateRating` to your
+> `SoftwareApplication` markup. Don't — inventing review data is self-serving structured-data abuse
+> that Google penalizes, and answer engines increasingly cross-check. Only mark up facts that are true.
+
+### 3. Let the AI crawlers in
+
+This is the step most teams miss: an answer engine can't cite a page it was never allowed to read.
+Many sites quietly block AI crawlers — and then wonder why they're never cited. If you want the
+citations, **explicitly allow** the answer-engine bots in `robots.txt`. This is the exact block we
+ship:
+
+```
+User-agent: *
+Allow: /
+
+# AI answer engines — explicitly welcome. We WANT to be cited.
+User-agent: GPTBot
+Allow: /
+User-agent: OAI-SearchBot
+Allow: /
+User-agent: ChatGPT-User
+Allow: /
+User-agent: PerplexityBot
+Allow: /
+User-agent: ClaudeBot
+Allow: /
+User-agent: Google-Extended
+Allow: /
+
+Sitemap: https://munderdiffl.in/sitemap.xml
+```
+
+There's a real tradeoff here, and you should decide it deliberately. Allowing `GPTBot`,
+`Google-Extended`, and `ClaudeBot` also permits training use of your content. For an awareness-stage
+open-source tool, being discoverable is worth far more than withholding text — so we allow them all.
+If avoiding training matters more to you than citations, flip those agents to `Disallow: /` and accept
+that you're opting out of the answers too. **You can't have the citations without the crawl.**
+
+### 4. Write FAQ blocks with one-sentence answers
+
+A FAQ section does double duty: it's genuinely useful to readers, and it's the most quotable format
+that exists. Each answer should be a single, complete sentence that stands on its own without the
+question. Our [Munder Difflin FAQ](/blog/munder-difflin-faq/) is built this way — "Is it free? Yes,
+it's free and open source under the MIT license." is a sentence an engine can quote whole.
+
+### 5. Be the canonical source on your topic
+
+Answer engines prefer sources that are *clear, consistent, and complete*. You earn "canonical source"
+status by:
+
+- **Defining your terms.** If you coin or popularize a concept ("single-committer pattern," "GOD
+ orchestrator"), define it crisply and link to it everywhere. Be the page that *defines* the thing.
+- **Comparison tables.** Engines love structured comparisons because they map directly onto "X vs Y"
+ questions. An honest table beats three paragraphs of prose.
+- **Consistent entity naming.** Use the same product name, the same one-sentence description, and the
+ same `sameAs` links (your GitHub repo) everywhere. Consistency is how an engine resolves "Munder
+ Difflin" to one entity instead of fragments.
+
+### 6. Treat your repo and freshness as ranking surfaces — honestly
+
+For a dev tool, your GitHub repo is a ranking surface too: a keyword-led "About" description, a strong
+README, and topics all feed the same entity. And keep content fresh — but **honestly**. Real
+`lastmod` dates and genuine updates help; faking freshness by bumping dates on unchanged pages is the
+kind of manipulation that gets discounted. Update when you actually have something new.
+
+## How to measure AEO (when there's no rank tracker)
+
+AEO has no clean "position 3" metric, so measure it directly: **ask the engines.** On a monthly
+cadence, ask ChatGPT, Claude, and Perplexity the exact questions your users would ask — *"how do I run
+multiple Claude Code agents?"*, *"best tool to coordinate AI coding agents?"* — and check whether
+you're named and whether the description matches what you wrote. When you start seeing your own
+sentences come back, the playbook is working. Pair that with a weekly glance at search-console
+impressions for the question-shaped queries.
+
+## The one-paragraph version
+
+**AEO is SEO with a tighter contract: write a sentence worth quoting, prove what the page is with
+structured data, let the AI crawlers read it, and be the clearest source on your topic — then verify
+by asking the engines directly.** None of it is exotic; it's mostly discipline. And it compounds,
+because the same page that an LLM will confidently cite is the same page a human will trust.
+
+If you want to see these patterns in a real, open codebase, every post on this blog is built to be
+quotable, and our [what is a multi-agent harness](/blog/what-is-a-multi-agent-harness/) explainer is
+the canonical-source pattern in action.
+
+---
+
+Munder Difflin is a local, open-source multi-agent harness for Claude Code — and a working example of
+AEO done in public. [Download Munder Difflin](/#install) to see it run, or read [what a multi-agent
+harness actually is](/#what). Free and MIT-licensed.
diff --git a/blog/src/posts/whats-new-in-agentic-ai-june-2026.md b/blog/src/posts/whats-new-in-agentic-ai-june-2026.md
new file mode 100644
index 00000000..ab61aaa0
--- /dev/null
+++ b/blog/src/posts/whats-new-in-agentic-ai-june-2026.md
@@ -0,0 +1,158 @@
+---
+title: "What's New in Agentic AI: A June 2026 Field Guide"
+description: "A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance."
+date: 2026-06-04
+category: guides
+categoryLabel: Guides
+type: Non-technical
+primaryKeyword: "what's new in agentic ai"
+secondaryKeywords: ["agentic ai 2026", "ai agent news june 2026", "mcp a2a agent protocols", "claude opus 4.8 agents"]
+tags: ["Agentic AI", "Industry", "Protocols", "Multi-Agent"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What changed in agentic AI in mid-2026?"
+ a: "Four things moved at once: frontier models got meaningfully better at acting autonomously (Anthropic's Claude Opus 4.8 and its parallel-subagent Dynamic Workflows), agent coordination standardized under the Linux Foundation's Agentic AI Foundation (MCP for tools, A2A for agent-to-agent), agent usage became metered (GitHub Copilot moved to usage-based AI Credits on June 1), and governance matured (Microsoft Agent 365 reached general availability as an agent control plane)."
+ - q: "What's the difference between MCP and A2A?"
+ a: "They solve different problems. The Model Context Protocol (MCP) standardizes how a single agent connects to its tools, APIs, and data — agent-to-tool. The Agent2Agent (A2A) protocol standardizes how separate agents discover and talk to each other — agent-to-agent. Both are now stewarded by the Linux Foundation, and most real systems use them together."
+ - q: "Do I need a cloud platform to run AI agents in 2026?"
+ a: "No. Alongside the big enterprise launches, 2026 has a strong local-first, open-source current: self-hosted agent frameworks and skill registries that run on your own machine. A local hive like Munder Difflin gives you coordinated multi-agent work — shared memory, messaging, an orchestrator — without sending your code or context to a SaaS."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>By June 2026, agentic AI matured on
+<strong>four fronts at once</strong>: models that <em>act</em> (Anthropic's <strong>Claude Opus 4.8</strong>
+and its parallel-subagent Dynamic Workflows), a hardening <strong>coordination layer</strong> (MCP and A2A
+now under the Linux Foundation), <strong>metered economics</strong> (GitHub Copilot moved to usage-based AI
+Credits on June 1), and <strong>governance</strong> (Microsoft Agent 365 reached general availability as an
+agent control plane). The throughline: agents went from demos to infrastructure — with a quiet
+<strong>local-first, open-source</strong> counter-current keeping that infrastructure something you can run
+yourself.</p></div>
+
+If you build or run multi-agent systems, the last few weeks have been busy. This is a curated,
+plain-English field guide to what actually shipped — grounded in primary sources, with a note on what
+each item means in practice and how it touches anyone running a local hive of coding agents.
+
+> **A note on sourcing.** This is a time-bound roundup, accurate to the best of our knowledge as of
+> **June 4, 2026**. Every factual claim links to its source — follow them, because this space moves
+> weekly and vendors revise details. Where a figure comes from a secondary aggregator rather than the
+> primary vendor, we say so. Munder Difflin is our own project; we've tried to report the rest straight.
+
+## At a glance
+
+| What | When | Why it matters |
+|---|---|---|
+| Claude Opus 4.8 + Dynamic Workflows | May 28, 2026 | Frontier coding model tuned for long-horizon, multi-subagent work |
+| MCP joins the Agentic AI Foundation | Dec 2025 → 2026 | The agent-to-tool standard is now vendor-neutral and huge |
+| A2A passes 150+ organizations | 2026 (year one) | An agent-to-agent standard reaches real adoption |
+| GitHub Copilot → usage-based AI Credits | June 1, 2026 | Agent coding became metered, token-by-token |
+| Microsoft Agent 365 GA | May 1, 2026 | Enterprise governance and identity for agents goes mainstream |
+
+## Models learned to act, not just answer
+
+The headline release is [Anthropic's Claude Opus 4.8](https://www.anthropic.com/claude/opus), out
+[May 28, 2026 — 41 days after Opus 4.7](https://techcrunch.com/2026/05/28/anthropic-releases-opus-4-8-with-new-dynamic-workflow-tool/).
+The interesting part isn't a benchmark leap; it's the *shape* of the gains. Anthropic leaned into
+**agentic reliability**: Opus 4.8 is described as more willing to
+[flag its own uncertainty and less likely to make unsupported claims](https://techcrunch.com/2026/05/28/anthropic-releases-opus-4-8-with-new-dynamic-workflow-tool/),
+and [Simon Willison's hands-on writeup](https://simonwillison.net/2026/May/28/claude-opus-4-8/) calls it
+"a modest but tangible improvement" — exactly the unglamorous kind of progress that matters when an agent
+runs unattended for an hour.
+
+Shipping alongside it is **Dynamic Workflows**, a research-preview Claude Code feature built to
+[manage a task across hundreds of parallel subagents](https://techcrunch.com/2026/05/28/anthropic-releases-opus-4-8-with-new-dynamic-workflow-tool/),
+so that Claude Code can carry out *codebase-scale migrations across hundreds of thousands of lines of
+code from kickoff to merge*, with the existing test suite as its bar. That's the through-line of 2026's
+model releases: vendors are optimizing for **autonomy and parallelism**, not just single-answer quality.
+
+**What it means in practice:** "one giant model call" is giving way to "many coordinated agents." If a
+frontier lab is now orchestrating subagents inside its own coding tool, the case for a
+[multi-agent harness](/#what) you control — where you can watch and steer that fan-out — gets stronger,
+not weaker. (For the broader tool landscape, see our
+[roundup of multi-agent Claude Code tools](/blog/best-claude-code-multi-agent-tools/).)
+
+## Agent coordination is becoming a protocol layer
+
+A year ago, every framework invented its own way for agents to reach tools and each other. That's
+consolidating fast. In December 2025, Anthropic donated the **Model Context Protocol (MCP)** to the new
+[Agentic AI Foundation (AAIF), a Linux Foundation directed fund anchored by MCP, Block's goose, and OpenAI's AGENTS.md](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation).
+MCP — the standard for **agent-to-tool** connections — has grown enormously; by one industry tally it
+had [crossed roughly 97 million SDK installs by March 2026](https://ai2.work/blog/model-context-protocol-hits-97m-installs-as-linux-foundation-takes-over)
+(treat the exact figure as directional — it's an aggregator's count, not a vendor disclosure).
+
+Its complement is the **Agent2Agent (A2A) protocol**, Google-originated and also Linux Foundation–hosted,
+which standardizes **agent-to-agent** discovery and messaging. At its one-year mark A2A reported
+[more than 150 supporting organizations and integration across Google, Microsoft, and AWS](https://www.linuxfoundation.org/press/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year).
+The clean mental model, as [IBM puts it](https://www.ibm.com/think/topics/agent2agent-protocol): **MCP is
+how an agent talks to tools; A2A is how agents talk to each other.**
+
+**What it means in practice:** the plumbing a hive needs — tool access and inter-agent messaging — is
+becoming portable and vendor-neutral. Munder Difflin already gives agents
+[MCP tools and skills](/blog/mcp-and-skills-in-a-hive/) and direct
+[agent-to-agent mailboxes](/blog/coordinating-ai-coding-agents/); standards mean those patterns aren't
+bespoke anymore, they're the industry default.
+
+## The meter is running
+
+The economics changed too. As of [June 1, 2026, all GitHub Copilot plans moved to usage-based billing](https://github.blog/changelog/2026-06-01-updates-to-github-copilot-billing-and-plans/):
+usage now consumes **GitHub AI Credits** (1 credit = $0.01), metered by input, output, and cached tokens
+per model. Paid plans include a monthly allotment —
+[Pro 1,500 credits, Pro+ 7,000, and a new Max tier at 20,000](https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/) —
+with code completions staying unlimited and user-level budgets now generally available. It's the clearest
+signal yet that **agentic coding is a metered resource**, priced like compute rather than a flat seat.
+
+**What it means in practice:** when every agent step has a token price, two things start to matter a lot —
+*visibility* into what your agents spend, and the option to run work where you control the cost. That's a
+core argument for [why local-first matters for AI agents](/blog/why-local-first-matters-for-ai-agents/): a
+hive that runs on your machine and logs its own activity puts the meter where you can see it.
+
+## Governance and identity grew up
+
+The enterprise side of agents got its control plane.
+[Microsoft Agent 365 reached general availability on May 1, 2026](https://www.microsoft.com/en-us/security/blog/2026/05/01/microsoft-agent-365-now-generally-available-expands-capabilities-and-integrations/)
+(announced in March, at $15 per user per month). It's an **identity-first** layer: Microsoft Entra issues
+identities and risk-based access for agents the way it does for people, Purview applies data-loss
+protection, and the control plane gives **real-time audit trails** for every agent — with registry sync to
+AWS Bedrock and Google Cloud in preview. The framing across coverage is consistent: 2026 is when "shadow"
+agents become a *governed* asset class.
+
+You can see the same instinct in the open standards — OpenAI's **AGENTS.md** convention, now an AAIF
+project, is essentially a shared contract for telling an agent how to behave in a repo.
+
+**What it means in practice:** governance isn't only an enterprise SaaS feature. The same primitives —
+**identity, audit, and a human in the loop** — can live locally. A hive that routes risky actions through
+[human-in-the-loop approvals](/blog/human-in-the-loop-ai-agents/) and records every step to an
+[append-only event log](/blog/append-only-event-log-agents/) is doing agent governance on your own
+machine, no control-plane subscription required.
+
+## The quiet counter-trend: local-first and open-source
+
+For all the enterprise launches, the most interesting current under them is the opposite direction. The
+community read on 2026 is that
+[agents stopped being demos and became infrastructure](https://github.com/Zijian-Ni/awesome-ai-agents-2026),
+and a large slice of that infrastructure is **self-hosted**: open-source agent frameworks, local skill
+registries, and a documented shift toward
+[controllable, self-hosted agent ecosystems](https://www.devflokers.com/blog/open-source-ai-projects-may-2026-roundup)
+that don't lock your data or your bill into a cloud platform. (Treat the headline star-counts and market
+sizes in those roundups as directional — they come from aggregators, not audited filings.)
+
+**What it means in practice:** you don't have to choose between "coordinated agents" and "runs on my
+laptop." That's the whole premise of Munder Difflin — a local, open-source hive where a
+[plain-language orchestrator](/#how) decomposes your intent and routes work across agents that share
+[long-term memory](/blog/give-claude-code-long-term-memory/) and message each other directly, all
+visualized on an office floor you can watch.
+
+## What it means if you build with agents
+
+Pulling the threads together, the June 2026 picture is a stack that's **stratifying**:
+
+- **Models** are being tuned for autonomy and parallel subagents, not just chat.
+- **Protocols** (MCP for tools, A2A for agents) are consolidating under neutral governance.
+- **Economics** moved to per-token metering, making cost visibility a first-class concern.
+- **Governance** — identity, audit, human-in-the-loop — became table stakes, on the cloud *and* locally.
+
+The practical takeaway: the building blocks for a serious multi-agent setup are now standard, cheap to
+start, and increasingly self-hostable. If you've been waiting for the space to settle before running a
+real team of agents, mid-2026 is a reasonable moment to start — and you can do it on your own hardware.
+The fastest way to feel the difference is to [download Munder Difflin](/#install) and watch a coordinated
+hive run; it's free and open source.
diff --git a/docs/blog/ai-agent-glossary/index.html b/docs/blog/ai-agent-glossary/index.html
index bd6bc7d5..852851c5 100644
--- a/docs/blog/ai-agent-glossary/index.html
+++ b/docs/blog/ai-agent-glossary/index.html
@@ -248,56 +248,56 @@ Munder Difflin</a> to see the glossary come to life — free and open source.</p
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/munder-difflin-faq/" aria-hidden="true" tabindex="-1">
+ <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-02">Jun 2, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>1 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/munder-difflin-faq/">Munder Difflin FAQ: Everything People Ask</a></h3>
- <p class="dek">Answers to the top Munder Difflin questions — what it is, is it free, does it run locally, which platforms, and how it differs from many terminals.</p>
+ <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/munder-difflin-faq/" aria-label="Read: Munder Difflin FAQ: Everything People Ask">Read →</a>
+ <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/what-are-claude-code-agents/" aria-hidden="true" tabindex="-1">
+ <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-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/what-are-claude-code-agents/">What Are Claude Code Agents? And How to Use Many at Once</a></h3>
- <p class="dek">Claude Code agents explained in plain English — what an agent actually is, how subagents differ, and the leap from one agent to a coordinated team.</p>
+ <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
+ <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/what-are-claude-code-agents/" aria-label="Read: What Are Claude Code Agents? And How to Use Many at Once">Read →</a>
+ <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/what-is-a-multi-agent-harness/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-22">May 22, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>2 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/what-is-a-multi-agent-harness/">What Is a Multi-Agent Harness? (Plain-English Guide)</a></h3>
- <p class="dek">A multi-agent harness coordinates several AI coding agents into one team — here&#39;s what that means, and how it differs from a single agent or a framework.</p>
+ <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>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/what-is-a-multi-agent-harness/" aria-label="Read: What Is a Multi-Agent Harness? (Plain-English Guide)">Read →</a>
+ <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>
</div>
</div>
</article>
diff --git a/docs/blog/best-claude-code-multi-agent-tools/index.html b/docs/blog/best-claude-code-multi-agent-tools/index.html
index 01d496c3..dd702bc8 100644
--- a/docs/blog/best-claude-code-multi-agent-tools/index.html
+++ b/docs/blog/best-claude-code-multi-agent-tools/index.html
@@ -348,7 +348,7 @@ real team of agents.</p>
</div>
<footer class="post-foot wrap"><div class="prevnext">
- <a class="pn prev" href="/blog/claude-code-automation-while-you-sleep/"><span class="k">← Older</span><span class="t">Claude Code Automation: Let Agents Build While You Sleep</span></a>
+ <a class="pn prev" href="/blog/can-claude-code-agents-talk-to-each-other/"><span class="k">← Older</span><span class="t">Can Claude Code Agents Talk to Each Other?</span></a>
<a class="pn next" href="/blog/architecture-two-planes-one-renderer/"><span class="k">Newer →</span><span class="t">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</span></a>
</div>
<section class="related">
diff --git a/docs/blog/building-a-terminal-ui-xterm-node-pty/index.html b/docs/blog/building-a-terminal-ui-xterm-node-pty/index.html
index 25471e10..536c73f7 100644
--- a/docs/blog/building-a-terminal-ui-xterm-node-pty/index.html
+++ b/docs/blog/building-a-terminal-ui-xterm-node-pty/index.html
@@ -338,7 +338,7 @@ to watch many real terminals at once; it’s free and open source.</p>
<footer class="post-foot wrap"><div class="prevnext">
<a class="pn prev" href="/blog/building-an-ai-office-floor/"><span class="k">← Older</span><span class="t">Building an AI &quot;Office Floor&quot;: Avatars, Pathfinding, Envelopes</span></a>
- <a class="pn next" href="/blog/debugging-multi-agent-systems/"><span class="k">Newer →</span><span class="t">How to Debug a Multi-Agent System</span></a>
+ <a class="pn next" href="/blog/whats-new-in-agentic-ai-june-2026/"><span class="k">Newer →</span><span class="t">What&#39;s New in Agentic AI: A June 2026 Field Guide</span></a>
</div>
<section class="related">
<h2>Related in Internals</h2>
diff --git a/docs/blog/can-claude-code-agents-talk-to-each-other/index.html b/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
new file mode 100644
index 00000000..0f74f9c6
--- /dev/null
+++ b/docs/blog/can-claude-code-agents-talk-to-each-other/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>Can Claude Code Agents Talk to Each Other? — Munder Difflin Blog</title>
+<meta name="description" content="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." />
+<link rel="canonical" href="https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/" />
+
+<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="Can Claude Code Agents Talk to Each Other? — Munder Difflin Blog" />
+<meta property="og:description" content="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." />
+<meta property="og:url" content="https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/" />
+<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="Getting Started" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Can Claude Code Agents Talk to Each Other? — Munder Difflin Blog" />
+<meta name="twitter:description" content="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." />
+<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": "Can Claude Code Agents Talk to Each Other?",
+ "description": "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.",
+ "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/can-claude-code-agents-talk-to-each-other/" },
+ "keywords": "can claude code agents talk to each other, inter-agent messaging, ai agent communication, claude code agents",
+ "articleSection": "Concepts",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/"
+}
+</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": "Can Claude Code Agents Talk to Each Other?", "item": "https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "Can Claude Code agents talk to each other?", "acceptedAnswer": { "@type": "Answer", "text": "Not by default. A Claude Code agent can spawn subagents, but those subagents only report their result back to the agent that launched them — there is no built-in peer-to-peer channel. To get true agent-to-agent communication you add a thin coordination layer, usually a file-based message system that a router delivers between agents." } },
+ { "@type": "Question", "name": "How do two AI agents send messages without a server?", "acceptedAnswer": { "@type": "Answer", "text": "Each agent writes a message as a single file into its own outbox, and a coordinating process moves that file into the recipient's inbox. No broker, no socket — just files and atomic renames. It is durable, auditable, and conflict-free because every file has exactly one writer." } },
+ { "@type": "Question", "name": "What stops two agents from messaging back and forth forever?", "acceptedAnswer": { "@type": "Answer", "text": "Two things. First, only certain message types expect a reply — a request, query, or proposal — while an inform or done is terminal and must not be answered. Second, every message carries a hop count, so a thread that bounces too many times is capped before it can loop." } }
+
+ ]
+}
+</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>Can Claude Code Agents Talk to Each Other?</h1>
+ <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="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">Concepts</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Can Claude Code agents talk to
+each other?</strong> Not out of the box — a Claude Code agent can spawn <strong>subagents</strong>,
+but they only report back to whoever launched them. There is no built-in peer-to-peer channel. Add a
+thin <strong>coordination layer</strong> — file-based mailboxes plus a router that delivers messages —
+and agents can message each other directly, escalate to a human, and stay <strong>auditable</strong>.
+That is exactly how a multi-agent harness turns several lone sessions into one team.</p></div>
+<p>It’s a fair question, and the honest answer has two halves. By default, no — Claude Code agents don’t
+talk to each other. But the gap is small, and once you close it a team of agents can coordinate as
+naturally as coworkers passing notes. Here’s the plain-English version of what’s missing and how to
+add it.</p>
+<h2 id="the-default-subagents-report-up-not-across" tabindex="-1">The default: subagents report up, not across <a class="anchor" href="#the-default-subagents-report-up-not-across" aria-hidden="true">#</a></h2>
+<p>A <a href="/blog/what-are-claude-code-agents/">Claude Code agent</a> is a running session with a goal and tools.
+It can spawn <strong>subagents</strong> — short-lived helpers that fan out a piece of work in parallel. That sounds
+like agents talking to each other, but it isn’t quite. A subagent only does one thing when it
+finishes: it hands its result back to the agent that launched it. The flow is strictly <strong>parent to
+child and back again</strong>, like a manager delegating a task and reading the report.</p>
+<p>What that flow can’t do is let two <em>peer</em> agents — two top-level sessions you started independently —
+discover each other and trade messages. Agent A has no address for Agent B. There’s no shared inbox,
+no bus, no “send this to whoever owns the auth module.” Each session lives in its own world.</p>
+<p>For a single task that’s fine. The moment you want several agents working a project together — a
+researcher feeding a builder, a reviewer flagging a fix, an orchestrator handing out assignments —
+you need them to actually communicate. So you add a layer.</p>
+<h2 id="the-coordination-layer-mailboxes-and-a-router" tabindex="-1">The coordination layer: mailboxes and a router <a class="anchor" href="#the-coordination-layer-mailboxes-and-a-router" aria-hidden="true">#</a></h2>
+<p>The most reliable way to let agents talk turns out to be almost boringly simple: <strong>files</strong>. Each agent
+gets a folder with an <code>inbox/</code> and an <code>outbox/</code>. To send a message, an agent drops a single JSON file
+into its own outbox. A coordinating process — call it the router — scans every outbox on a tick, and
+moves each message into the right recipient’s inbox. The recipient reads it at the start of its next
+turn and moves it to a <code>done/</code> folder so it’s never processed twice.</p>
+<p>That’s the whole mechanism. No Redis, no RabbitMQ, no daemon to babysit. The “infrastructure” is a
+directory and the <code>rename</code> syscall. We unpack the design in
+<a href="/blog/atomic-file-mailboxes-for-agents/">atomic file mailboxes for agents</a>, but the headline
+properties are what make it hold up:</p>
+<ul>
+<li><strong>Durable.</strong> Messages are files. If a process crashes mid-run, nothing already written is lost — the
+router picks up where it left off.</li>
+<li><strong>Auditable.</strong> Every message and every delivery is a file the coordinator commits to git, so you can
+read back exactly who said what, in order. (That works because a
+<a href="/blog/single-committer-git-pattern/">single committer owns the repository</a>.)</li>
+<li><strong>Conflict-free.</strong> Each file has exactly one writer, and delivery is an atomic rename. Agents can be
+busy at the same time without locks or races.</li>
+</ul>
+<p>The one rule that keeps it clean: <strong>never write into another agent’s folder.</strong> You only ever write to
+your own outbox; the router does the routing. Single-writer-per-file is what makes the whole thing
+safe under concurrency.</p>
+<h2 id="whats-actually-in-a-message" tabindex="-1">What’s actually in a message <a class="anchor" href="#whats-actually-in-a-message" aria-hidden="true">#</a></h2>
+<p>A message isn’t just free text — it carries a little structure so the receiving agent knows what’s
+expected of it. In practice each message names:</p>
+<ul>
+<li><strong>who it’s for</strong> — another agent, the orchestrator, everyone (<code>broadcast</code>), or a human,</li>
+<li><strong>a speech act</strong> — is this a <code>request</code>, a <code>query</code>, a <code>proposal</code>, an <code>inform</code>, an <code>agreement</code>, a
+<code>refusal</code>, or a <code>done</code>?</li>
+<li><strong>a subject and body</strong> — the actual content, and</li>
+<li><strong>a thread id</strong> — so a back-and-forth stays grouped as one conversation.</li>
+</ul>
+<p>The speech act is the quiet hero. It encodes intent, and intent is what prevents chatter from spiralling.
+Only a <code>request</code>, a <code>query</code>, or a <code>proposal</code> expects a reply. An <code>inform</code> or a <code>done</code> is <strong>terminal</strong> —
+you do not answer it. That single convention is what stops two polite agents from “thanks!” / “you’re
+welcome!”-ing each other into an infinite loop. As a backstop, every message also carries a <strong>hop
+count</strong>, so even a misbehaving thread is capped before it can run away.</p>
+<h2 id="talking-to-the-orchestrator-and-to-you" tabindex="-1">Talking to the orchestrator — and to you <a class="anchor" href="#talking-to-the-orchestrator-and-to-you" aria-hidden="true">#</a></h2>
+<p>Peer-to-peer isn’t the only direction that matters. Two special addresses round out the system.</p>
+<p>The first is the <strong>orchestrator</strong> (in our hive, the GOD agent). Anything ambiguous, cross-cutting, or
+needing sign-off goes to it rather than getting hashed out between peers. It hands out assignments,
+owns the shared plan, and is the one process allowed to commit — which is exactly why coordination
+stays coherent instead of fragmenting into side conversations. We cover that role in
+<a href="/blog/how-the-god-orchestrator-works/">how the GOD orchestrator works</a>.</p>
+<p>The second is <strong>you</strong>. A message addressed to a human doesn’t land in an agent’s inbox at all — the
+router diverts it to an approvals queue for a person to answer, and the answer comes back as a normal
+message. That’s how an agent reaches a human for the genuinely critical calls without anyone having to
+watch a terminal, the same loop we describe in
+<a href="/blog/human-in-the-loop-ai-agents/">keeping a human in the loop</a>.</p>
+<h2 id="memory-is-a-slower-kind-of-talking" tabindex="-1">Memory is a slower kind of talking <a class="anchor" href="#memory-is-a-slower-kind-of-talking" aria-hidden="true">#</a></h2>
+<p>There’s one more channel that’s easy to miss: <strong>shared memory.</strong> Messages are how agents coordinate in
+the moment; memory is how they coordinate across time. When each agent writes durable facts to a notes
+file and those notes are mined into a <a href="/blog/semantic-memory-for-ai-agents/">searchable semantic memory</a>
+the whole team can query, an agent can effectively “hear” what a teammate learned an hour ago without a
+message ever being sent. Fast lane: the mailbox. Slow lane: the shared memory. A good team uses both.</p>
+<h2 id="so-can-they-talk" tabindex="-1">So — can they talk? <a class="anchor" href="#so-can-they-talk" aria-hidden="true">#</a></h2>
+<p>Yes, with a caveat worth repeating: not on their own. A single Claude Code agent and its subagents form
+a manager-and-helpers tree, not a conversation. But the missing piece is small — mailboxes, a router,
+a handful of speech-act rules, and a hop cap — and once it’s in place, independent agents coordinate
+like a real team: requesting work, reporting <code>done</code>, escalating to an orchestrator, and pinging a human
+only when it truly matters. That shift, from isolated sessions to a coordinated crew, is the entire
+point of <a href="/blog/coordinating-ai-coding-agents/">the best way to coordinate AI coding agents</a>.</p>
+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
+<p><strong>Can Claude Code agents talk to each other out of the box?</strong> No. An agent can spawn subagents, but
+they only return their result to the agent that launched them. There’s no native peer-to-peer channel
+between two independent sessions — you add a coordination layer to get one.</p>
+<p><strong>Do I need a message broker like Redis or RabbitMQ?</strong> No. The most robust approach is file-based:
+each agent writes messages to its own outbox, and a router moves them to recipients’ inboxes via atomic
+renames. It’s durable and auditable with zero extra infrastructure.</p>
+<p><strong>How do agents avoid talking in circles?</strong> Speech acts and hop counts. Only requests, queries, and
+proposals expect a reply; informs and dones are terminal. And every message carries a hop count, so a
+thread is capped before it can loop forever.</p>
+<p><strong>How does an agent reach a human?</strong> It sends a message addressed to a human (or flagged as needing a
+human). The router diverts it to an approvals queue instead of an inbox, a person answers, and the
+reply comes back to the agent as a normal message.</p>
+<hr>
+<p>Munder Difflin runs exactly this system: a hive of Claude Code agents that message each other through
+atomic file mailboxes, escalate to <a href="https://munderdiffl.in/#how">a GOD orchestrator</a>, and ping you only
+for the calls that matter — every envelope visible on a live office floor.
+<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to watch your agents actually talk to each
+other; it’s free and open source.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">Can Claude Code agents talk to each other?</p>
+ <p class="a">Not by default. A Claude Code agent can spawn subagents, but those subagents only report their result back to the agent that launched them — there is no built-in peer-to-peer channel. To get true agent-to-agent communication you add a thin coordination layer, usually a file-based message system that a router delivers between agents.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How do two AI agents send messages without a server?</p>
+ <p class="a">Each agent writes a message as a single file into its own outbox, and a coordinating process moves that file into the recipient&#39;s inbox. No broker, no socket — just files and atomic renames. It is durable, auditable, and conflict-free because every file has exactly one writer.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What stops two agents from messaging back and forth forever?</p>
+ <p class="a">Two things. First, only certain message types expect a reply — a request, query, or proposal — while an inform or done is terminal and must not be answered. Second, every message carries a hop count, so a thread that bounces too many times is capped before it can loop.</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/getting-started/">Getting Started</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-default-subagents-report-up-not-across">The default: subagents report up, not across</a></li><li class="lvl-2"><a href="#the-coordination-layer-mailboxes-and-a-router">The coordination layer: mailboxes and a router</a></li><li class="lvl-2"><a href="#whats-actually-in-a-message">What’s actually in a message</a></li><li class="lvl-2"><a href="#talking-to-the-orchestrator-and-to-you">Talking to the orchestrator — and to you</a></li><li class="lvl-2"><a href="#memory-is-a-slower-kind-of-talking">Memory is a slower kind of talking</a></li><li class="lvl-2"><a href="#so-can-they-talk">So — can they talk?</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/claude-code-automation-while-you-sleep/"><span class="k">← Older</span><span class="t">Claude Code Automation: Let Agents Build While You Sleep</span></a>
+ <a class="pn next" href="/blog/best-claude-code-multi-agent-tools/"><span class="k">Newer →</span><span class="t">The Best Tools to Run Multiple Claude Code Agents (2026)</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Concepts</h2>
+ <div class="post-grid">
+ <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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</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/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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/claude-code-automation-while-you-sleep/index.html b/docs/blog/claude-code-automation-while-you-sleep/index.html
index f3323cf2..c568d0c4 100644
--- a/docs/blog/claude-code-automation-while-you-sleep/index.html
+++ b/docs/blog/claude-code-automation-while-you-sleep/index.html
@@ -285,7 +285,7 @@ while you sleep; it’s free and open source.</p>
<footer class="post-foot wrap"><div class="prevnext">
<a class="pn prev" href="/blog/claude-code-git-worktrees-vs-hive/"><span class="k">← Older</span><span class="t">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</span></a>
- <a class="pn next" href="/blog/best-claude-code-multi-agent-tools/"><span class="k">Newer →</span><span class="t">The Best Tools to Run Multiple Claude Code Agents (2026)</span></a>
+ <a class="pn next" href="/blog/can-claude-code-agents-talk-to-each-other/"><span class="k">Newer →</span><span class="t">Can Claude Code Agents Talk to Each Other?</span></a>
</div>
<section class="related">
<h2>Related in Guides</h2>
@@ -309,38 +309,38 @@ while you sleep; it’s free and open source.</p>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
<article class="card">
- <a class="thumb t-guides" href="/blog/mcp-and-skills-in-a-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-03">Jun 3, 2026</time>
+ <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/mcp-and-skills-in-a-hive/">Bringing Your MCP Servers and Skills Into a Hive of Agents</a></h3>
- <p class="dek">How agents in a hive inherit your existing Claude Code MCP servers, skills, and tools — and how to scope which agent gets which capability.</p>
+ <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
+ <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/mcp-and-skills-in-a-hive/" aria-label="Read: Bringing Your MCP Servers and Skills Into a Hive of Agents">Read →</a>
+ <a class="more" href="/blog/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-git-worktrees-vs-hive/index.html b/docs/blog/claude-code-git-worktrees-vs-hive/index.html
index 07b2f70f..b90813cc 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/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&#39;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&#39;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&#39;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&#39;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&#39;t Slow You Down">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/coordinating-ai-coding-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/how-the-god-orchestrator-works/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-29">May 29, 2026</time>
+ <time datetime="2026-05-30">May 30, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/coordinating-ai-coding-agents/">The Best Way to Coordinate AI Coding Agents</a></h3>
- <p class="dek">The best way to coordinate AI coding agents: single-writer files, a message router, a one-scribe plan, and an orchestrator — cooperate, not clobber.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/coordinating-ai-coding-agents/" aria-label="Read: The Best Way to Coordinate AI Coding Agents">Read →</a>
+ <a class="more" href="/blog/how-the-god-orchestrator-works/" aria-label="Read: Inside the GOD Orchestrator: Routing, Adjudication, Escalation">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-multi-agent-setup-tutorial/index.html b/docs/blog/claude-code-multi-agent-setup-tutorial/index.html
index df733363..ffca737c 100644
--- a/docs/blog/claude-code-multi-agent-setup-tutorial/index.html
+++ b/docs/blog/claude-code-multi-agent-setup-tutorial/index.html
@@ -316,20 +316,20 @@ coordinated team of Claude Code agents — it’s free, local, and open source.<
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
diff --git a/docs/blog/claude-code-orchestration-guide/index.html b/docs/blog/claude-code-orchestration-guide/index.html
index a1a3793b..fcdd8199 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/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&#39;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&#39;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&#39;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&#39;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&#39;t Slow You Down">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html b/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html
index 222c94e9..083d3dfe 100644
--- a/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html
+++ b/docs/blog/claude-code-subagents-vs-multi-agent-harness/index.html
@@ -356,20 +356,20 @@ open source.</p>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
diff --git a/docs/blog/claude-squad-vs-munder-difflin/index.html b/docs/blog/claude-squad-vs-munder-difflin/index.html
index 24733a41..bcdfbd6c 100644
--- a/docs/blog/claude-squad-vs-munder-difflin/index.html
+++ b/docs/blog/claude-squad-vs-munder-difflin/index.html
@@ -295,7 +295,7 @@ local-first.</p>
</div>
<footer class="post-foot wrap"><div class="prevnext">
- <a class="pn prev" href="/blog/debugging-multi-agent-systems/"><span class="k">← Older</span><span class="t">How to Debug a Multi-Agent System</span></a>
+ <a class="pn prev" href="/blog/context-engineering-for-ai-agents/"><span class="k">← Older</span><span class="t">Context Engineering for AI Agents: Budgeting the Window</span></a>
<a class="pn next" href="/blog/claude-code-orchestration-tools-compared/"><span class="k">Newer →</span><span class="t">Claude Code Orchestration Tools, Compared</span></a>
</div>
<section class="related">
diff --git a/docs/blog/context-engineering-for-ai-agents/index.html b/docs/blog/context-engineering-for-ai-agents/index.html
new file mode 100644
index 00000000..e5b76841
--- /dev/null
+++ b/docs/blog/context-engineering-for-ai-agents/index.html
@@ -0,0 +1,407 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Context Engineering for AI Agents: Budgeting the Window — Munder Difflin Blog</title>
+<meta name="description" content="Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean." />
+<link rel="canonical" href="https://munderdiffl.in/blog/context-engineering-for-ai-agents/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="Context Engineering for AI Agents: Budgeting the Window — Munder Difflin Blog" />
+<meta property="og:description" content="Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean." />
+<meta property="og:url" content="https://munderdiffl.in/blog/context-engineering-for-ai-agents/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Context Engineering" />
+<meta property="article:tag" content="Memory" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Claude Code" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Context Engineering for AI Agents: Budgeting the Window — Munder Difflin Blog" />
+<meta name="twitter:description" content="Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean." />
+<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": "Context Engineering for AI Agents: Budgeting the Window",
+ "description": "Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.",
+ "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/context-engineering-for-ai-agents/" },
+ "keywords": "context engineering, context engineering for ai agents, context window management, agent context window, context rot",
+ "articleSection": "Guides",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/context-engineering-for-ai-agents/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "Context Engineering for AI Agents: Budgeting the Window", "item": "https://munderdiffl.in/blog/context-engineering-for-ai-agents/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What is context engineering?", "acceptedAnswer": { "@type": "Answer", "text": "Context engineering is the discipline of deciding exactly what tokens occupy a model's finite context window at each step — instructions, tools, retrieved memory, and history — so the model has what it needs and nothing it doesn't. It's the system-level successor to prompt engineering: prompt engineering tunes the wording of one message, context engineering curates the whole window over a long-running, multi-turn agent." } },
+ { "@type": "Question", "name": "How is context engineering different from prompt engineering?", "acceptedAnswer": { "@type": "Answer", "text": "Prompt engineering optimizes a single static prompt. Context engineering manages a dynamic, growing window across many turns and often many agents — what to load, what to retrieve just-in-time, what to summarize, and what to keep out of the window entirely. For agents that run for hours and call dozens of tools, the prompt is the smallest part of the problem." } },
+ { "@type": "Question", "name": "What is context rot?", "acceptedAnswer": { "@type": "Answer", "text": "Context rot is the degradation in answer quality as a context window fills up. More tokens isn't strictly better: irrelevant history, stale tool output, and contradictory notes distract the model and crowd out what matters. A large window is a budget to spend carefully, not a bucket to fill." } },
+ { "@type": "Question", "name": "Why does context engineering matter more in a multi-agent system?", "acceptedAnswer": { "@type": "Answer", "text": "Because every agent has its own finite window and they must coordinate. If you pour all shared state into every agent's context, you pay for it in tokens, latency, and confusion. The fix is to give each agent a small, role-scoped window and keep the shared state — mailboxes, logs, the plan — in files the agent reads on demand." } }
+
+ ]
+}
+</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>Context Engineering for AI Agents: Budgeting the Window</h1>
+ <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="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>7 min read</span>
+ <span class="tag kind">Guides</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Context engineering</strong> is
+deciding what occupies a model's finite window at each step — and what stays out. It's the system-level
+successor to prompt engineering. The window is a <strong>budget</strong>, not a bucket: past a point,
+more tokens make answers <em>worse</em>. The four moves that matter for a hive of agents are
+<strong>isolation</strong> (a small window per agent), <strong>retrieval</strong> (pull the few
+relevant notes, not all of them), <strong>externalized state</strong> (keep mailboxes, logs, and the
+plan in files, not in context), and <strong>compaction</strong> (summarize the long tail). Get those
+right and a fleet of agents stays sharp for hours.</p></div>
+<p>For a long time the craft of working with language models was <em>prompt engineering</em> — finding the
+wording that coaxed the best answer out of a single request. That framing made sense when the unit of
+work was one prompt and one completion. It stops making sense the moment you have an agent that runs for
+an hour, calls thirty tools, reads files, and coordinates with five other agents. At that scale the
+exact phrasing of any one message is a rounding error. What decides whether the agent succeeds is the
+<strong>entire set of tokens in its context window at the moment it has to act</strong> — and that set is something
+you design. That design discipline is <strong>context engineering</strong>.</p>
+<h2 id="the-window-is-a-budget-not-a-bucket" tabindex="-1">The window is a budget, not a bucket <a class="anchor" href="#the-window-is-a-budget-not-a-bucket" aria-hidden="true">#</a></h2>
+<p>Every model has a finite context window, and that window is the agent’s entire working memory. Newer
+models advertise enormous windows — hundreds of thousands of tokens, sometimes a million — and the
+intuitive conclusion is “great, I’ll just put everything in.” That intuition is wrong, and it’s the
+single most expensive mistake in agent design.</p>
+<p>Quality does not increase monotonically with tokens. Past a certain fill level, answers get <em>worse</em> —
+a phenomenon now widely called <strong>context rot</strong>. Irrelevant history distracts the model; stale tool
+output gets mistaken for current state; two notes that contradict each other pull the model in two
+directions. The window is a budget you spend, and every token you add has a cost in attention even
+when it’s free in dollars. The job of context engineering is to spend that budget on the
+<strong>smallest set of high-signal tokens</strong> that lets the model take the right next step.</p>
+<p>It helps to name the ways a window goes bad. The 2025 taxonomy that stuck:</p>
+<ul>
+<li><strong>Poisoning</strong> — a wrong fact (often a hallucination) lands in context and gets referenced as truth on
+every subsequent turn.</li>
+<li><strong>Distraction</strong> — so much history accumulates that the model leans on it instead of reasoning about
+the task in front of it.</li>
+<li><strong>Confusion</strong> — irrelevant-but-present content (a tool the agent will never call, a doc for another
+feature) nudges the model off course.</li>
+<li><strong>Clash</strong> — two parts of the window disagree, and the model has no way to know which to trust.</li>
+</ul>
+<p>Notice that three of the four get <em>worse</em> as you add tokens. That’s the whole argument for treating
+context as something to curate, not accumulate.</p>
+<h2 id="multi-agent-makes-it-sharper" tabindex="-1">Multi-agent makes it sharper <a class="anchor" href="#multi-agent-makes-it-sharper" aria-hidden="true">#</a></h2>
+<p>In a single-agent setup you can sometimes get away with a messy window. In a hive you can’t. Every
+agent has its own window, and they have to coordinate. The naive design — one giant shared context that
+every agent sees — fails on all three axes at once: it’s expensive (you pay for the shared blob in every
+agent’s token bill), it’s slow (bigger windows cost latency), and it’s confusing (each agent wades
+through five other agents’ chatter to find its own task).</p>
+<p>The whole architecture of <a href="https://munderdiffl.in/#what">a multi-agent harness</a> is, viewed one way, an
+answer to a context-engineering question: <em>how do we let many agents share state without sharing
+windows?</em> The answer is to keep the shared state <strong>out</strong> of the window and let each agent pull in only
+the slice it needs.</p>
+<h2 id="four-moves-that-keep-the-window-lean" tabindex="-1">Four moves that keep the window lean <a class="anchor" href="#four-moves-that-keep-the-window-lean" aria-hidden="true">#</a></h2>
+<h3 id="1-isolation-one-small-window-per-agent" tabindex="-1">1. Isolation — one small window per agent <a class="anchor" href="#1-isolation-one-small-window-per-agent" aria-hidden="true">#</a></h3>
+<p>The first and biggest lever is to give each agent its <strong>own</strong> context, scoped to its <strong>own</strong> role.
+A planner doesn’t need the executor’s tool output; a reviewer doesn’t need the full chat history of the
+agent it’s reviewing. When an orchestrator hands a sub-task to a specialist, it hands over a <em>brief</em> —
+the goal and the few facts that matter — not a transcript.</p>
+<p>This is why “spin up a sub-agent for the search” so often beats “stuff the search results into my own
+context.” The sub-agent burns its window on the messy intermediate work and returns a clean conclusion;
+the parent’s window stays small and high-signal. Isolation is context engineering’s version of
+encapsulation. (For where this helps and where it doesn’t, see
+<a href="/blog/claude-code-subagents-vs-multi-agent-harness/">Claude Code subagents vs a multi-agent harness</a>.)</p>
+<h3 id="2-retrieval-recall-the-relevant-few-not-the-relevant-many" tabindex="-1">2. Retrieval — recall the relevant few, not the relevant many <a class="anchor" href="#2-retrieval-recall-the-relevant-few-not-the-relevant-many" aria-hidden="true">#</a></h3>
+<p>An agent that has worked for weeks has learned far more than fits in a window. The wrong fix is to load
+its whole history “just in case.” The right fix is <strong>retrieval</strong>: store everything durably outside the
+window, and at each step pull in only the handful of notes that bear on the task.</p>
+<p>This is exactly what <a href="/blog/semantic-memory-for-ai-agents/">semantic memory for AI agents</a> provides. The
+agent’s knowledge lives in <a href="/blog/markdown-first-agent-memory/">markdown files</a>; a semantic index sits on
+top; a query like <em>“how do we build the web bundle?”</em> returns the two or three relevant notes by
+meaning, even if they never used those words. The window cost stays flat as the knowledge base grows —
+that’s the property you’re buying. Recall-everything scales the window with history; retrieval keeps it
+constant.</p>
+<h3 id="3-externalized-state-files-the-agent-reads-not-tokens-it-carries" tabindex="-1">3. Externalized state — files the agent reads, not tokens it carries <a class="anchor" href="#3-externalized-state-files-the-agent-reads-not-tokens-it-carries" aria-hidden="true">#</a></h3>
+<p>The most underrated context-engineering move is to keep coordination state in <strong>files</strong> rather than in
+the window. A hive’s shared plan, its message mailboxes, and its event log are all state the agents need
+<em>access</em> to — but not state they need <em>resident</em> in context at all times.</p>
+<p>In a <a href="/blog/atomic-file-mailboxes-for-agents/">file-based coordination model</a>, an agent reads its inbox
+at the start of a task, acts, and writes a reply to its outbox — the messages live on disk, not in a
+shared prompt. The <a href="/blog/append-only-event-log-agents/">append-only event log</a> records every action for
+debugging and replay, but no agent carries the log in its window; it’s read on demand when something
+needs investigating. The shared board is the plan of record, edited by one writer, read by anyone who
+needs it. The window holds a <em>pointer</em> to the state, and the agent dereferences it just-in-time. This is
+the agent equivalent of not loading the entire database into RAM.</p>
+<p>The same principle applies to tools and docs: load a tool’s full schema or a library’s documentation
+<strong>when the agent decides to use it</strong>, not preemptively for every tool it might theoretically call.
+Just-in-time beats just-in-case.</p>
+<h3 id="4-compaction-summarize-the-long-tail" tabindex="-1">4. Compaction — summarize the long tail <a class="anchor" href="#4-compaction-summarize-the-long-tail" aria-hidden="true">#</a></h3>
+<p>Even a well-scoped agent eventually fills its window if it runs long enough. The escape valve is
+<strong>compaction</strong>: when the history grows past a threshold, summarize the old turns into a compact recap and
+continue from there. Done well, the agent keeps its conclusions, its open decisions, and its current
+state, while shedding the verbose middle — the tool calls and dead ends that got it there.</p>
+<p>Our hive’s hourly <strong>standup</strong> is compaction as a team ritual: each agent reports what it did and what’s
+next in a few lines, and that digest — not the raw hour of work — is what propagates. The transcript
+stays on disk for anyone who needs to replay it; the <em>summary</em> is what travels. Whether it’s a single
+agent compacting its own session or a team compacting into a standup, the move is the same: trade fidelity
+you no longer need for window you do.</p>
+<h2 id="a-practical-checklist" tabindex="-1">A practical checklist <a class="anchor" href="#a-practical-checklist" aria-hidden="true">#</a></h2>
+<p>When an agent underperforms, resist the urge to rewrite its prompt first. Audit its window instead:</p>
+<ol>
+<li><strong>What’s resident that shouldn’t be?</strong> Stale tool output, another agent’s chatter, a doc for a
+feature this agent doesn’t touch — evict it.</li>
+<li><strong>What’s missing that should be there?</strong> The one decision from three hours ago that changes the
+answer. Make sure retrieval surfaces it.</li>
+<li><strong>Is anything contradicting anything?</strong> Two notes that clash; an outdated fact next to its correction.
+Resolve or remove.</li>
+<li><strong>Could this be a sub-agent?</strong> If the task involves messy intermediate work, isolate it and return a
+clean result.</li>
+<li><strong>Is shared state in the window or in files?</strong> Move coordination state to disk and read it on demand.</li>
+<li><strong>Is it time to compact?</strong> If history dominates the window, summarize and continue.</li>
+</ol>
+<p>Most “the model got dumber” complaints are context problems wearing a model costume. The fix is rarely a
+better sentence; it’s a cleaner window.</p>
+<h2 id="why-this-is-the-durable-skill" tabindex="-1">Why this is the durable skill <a class="anchor" href="#why-this-is-the-durable-skill" aria-hidden="true">#</a></h2>
+<p>Models will keep getting bigger windows, and every jump tempts people to stop curating. Don’t. A bigger
+window raises the ceiling on what you <em>can</em> hold; it does nothing to change the fact that signal beats
+volume. The teams that get the most out of agents — single or swarm — are the ones who treat the context
+window as the scarce, high-value resource it is and engineer what goes into it deliberately.</p>
+<p>Munder Difflin is built around exactly these moves: <a href="https://munderdiffl.in/#what">isolated per-agent windows</a>,
+<a href="https://munderdiffl.in/#how">semantic memory</a> that recalls the relevant few, file-based mailboxes and an
+event log that keep shared state out of context, and standups that compact the long tail.
+<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run a hive that stays sharp for hours —
+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 context engineering?</p>
+ <p class="a">Context engineering is the discipline of deciding exactly what tokens occupy a model&#39;s finite context window at each step — instructions, tools, retrieved memory, and history — so the model has what it needs and nothing it doesn&#39;t. It&#39;s the system-level successor to prompt engineering: prompt engineering tunes the wording of one message, context engineering curates the whole window over a long-running, multi-turn agent.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How is context engineering different from prompt engineering?</p>
+ <p class="a">Prompt engineering optimizes a single static prompt. Context engineering manages a dynamic, growing window across many turns and often many agents — what to load, what to retrieve just-in-time, what to summarize, and what to keep out of the window entirely. For agents that run for hours and call dozens of tools, the prompt is the smallest part of the problem.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What is context rot?</p>
+ <p class="a">Context rot is the degradation in answer quality as a context window fills up. More tokens isn&#39;t strictly better: irrelevant history, stale tool output, and contradictory notes distract the model and crowd out what matters. A large window is a budget to spend carefully, not a bucket to fill.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Why does context engineering matter more in a multi-agent system?</p>
+ <p class="a">Because every agent has its own finite window and they must coordinate. If you pour all shared state into every agent&#39;s context, you pay for it in tokens, latency, and confusion. The fix is to give each agent a small, role-scoped window and keep the shared state — mailboxes, logs, the plan — in files the agent reads on demand.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/context-engineering/">Context Engineering</a><a class="tag" href="/blog/tags/memory/">Memory</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#the-window-is-a-budget-not-a-bucket">The window is a budget, not a bucket</a></li><li class="lvl-2"><a href="#multi-agent-makes-it-sharper">Multi-agent makes it sharper</a></li><li class="lvl-2"><a href="#four-moves-that-keep-the-window-lean">Four moves that keep the window lean</a></li><li class="lvl-3"><a href="#1-isolation-one-small-window-per-agent">1. Isolation — one small window per agent</a></li><li class="lvl-3"><a href="#2-retrieval-recall-the-relevant-few-not-the-relevant-many">2. Retrieval — recall the relevant few, not the relevant many</a></li><li class="lvl-3"><a href="#3-externalized-state-files-the-agent-reads-not-tokens-it-carries">3. Externalized state — files the agent reads, not tokens it carries</a></li><li class="lvl-3"><a href="#4-compaction-summarize-the-long-tail">4. Compaction — summarize the long tail</a></li><li class="lvl-2"><a href="#a-practical-checklist">A practical checklist</a></li><li class="lvl-2"><a href="#why-this-is-the-durable-skill">Why this is the durable skill</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/debugging-multi-agent-systems/"><span class="k">← Older</span><span class="t">How to Debug a Multi-Agent System</span></a>
+ <a class="pn next" href="/blog/claude-squad-vs-munder-difflin/"><span class="k">Newer →</span><span class="t">Claude Squad vs Munder Difflin: Which Should You Use?</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/debugging-multi-agent-systems/" 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/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
+ <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/coordinating-ai-coding-agents/index.html b/docs/blog/coordinating-ai-coding-agents/index.html
index d0dae8ce..2b3ef854 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/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&#39;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&#39;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&#39;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&#39;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&#39;t Slow You Down">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/debugging-multi-agent-systems/index.html b/docs/blog/debugging-multi-agent-systems/index.html
index dc7e0047..c03f9cad 100644
--- a/docs/blog/debugging-multi-agent-systems/index.html
+++ b/docs/blog/debugging-multi-agent-systems/index.html
@@ -264,8 +264,8 @@ to run agents you can actually trace; it’s free and open source.</p>
</div>
<footer class="post-foot wrap"><div class="prevnext">
- <a class="pn prev" href="/blog/building-a-terminal-ui-xterm-node-pty/"><span class="k">← Older</span><span class="t">Building a Terminal UI with xterm.js and node-pty</span></a>
- <a class="pn next" href="/blog/claude-squad-vs-munder-difflin/"><span class="k">Newer →</span><span class="t">Claude Squad vs Munder Difflin: Which Should You Use?</span></a>
+ <a class="pn prev" href="/blog/do-more-with-less-model-routing/"><span class="k">← Older</span><span class="t">Do More With Less: Smart Model Routing Across Agents</span></a>
+ <a class="pn next" href="/blog/context-engineering-for-ai-agents/"><span class="k">Newer →</span><span class="t">Context Engineering for AI Agents: Budgeting the Window</span></a>
</div>
<section class="related">
<h2>Related in Guides</h2>
@@ -307,20 +307,20 @@ to run agents you can actually trace; it’s free and open source.</p>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/mcp-and-skills-in-a-hive/" aria-hidden="true" tabindex="-1">
+ <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-03">Jun 3, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/mcp-and-skills-in-a-hive/">Bringing Your MCP Servers and Skills Into a Hive of Agents</a></h3>
- <p class="dek">How agents in a hive inherit your existing Claude Code MCP servers, skills, and tools — and how to scope which agent gets which capability.</p>
+ <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/mcp-and-skills-in-a-hive/" aria-label="Read: Bringing Your MCP Servers and Skills Into a Hive of Agents">Read →</a>
+ <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>
diff --git a/docs/blog/do-more-with-less-model-routing/index.html b/docs/blog/do-more-with-less-model-routing/index.html
new file mode 100644
index 00000000..db0c741f
--- /dev/null
+++ b/docs/blog/do-more-with-less-model-routing/index.html
@@ -0,0 +1,374 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Do More With Less: Smart Model Routing Across Agents — Munder Difflin Blog</title>
+<meta name="description" content="Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality." />
+<link rel="canonical" href="https://munderdiffl.in/blog/do-more-with-less-model-routing/" />
+
+<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="Do More With Less: Smart Model Routing Across Agents — Munder Difflin Blog" />
+<meta property="og:description" content="Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality." />
+<meta property="og:url" content="https://munderdiffl.in/blog/do-more-with-less-model-routing/" />
+<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="Model Routing" />
+<meta property="article:tag" content="Cost" />
+<meta property="article:tag" content="Orchestration" />
+<meta property="article:tag" content="Multi-Agent" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Do More With Less: Smart Model Routing Across Agents — Munder Difflin Blog" />
+<meta name="twitter:description" content="Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality." />
+<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": "Do More With Less: Smart Model Routing Across Agents",
+ "description": "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.",
+ "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/do-more-with-less-model-routing/" },
+ "keywords": "ai model routing, model routing, llm cost optimization, sonnet vs opus, ai agent cost",
+ "articleSection": "Concepts",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/do-more-with-less-model-routing/"
+}
+</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": "Do More With Less: Smart Model Routing Across Agents", "item": "https://munderdiffl.in/blog/do-more-with-less-model-routing/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What is AI model routing?", "acceptedAnswer": { "@type": "Answer", "text": "Model routing is the practice of sending each task to the model that fits it, rather than running everything on one model. A cheap, fast model handles routine work — formatting, classification, simple edits — and a heavier, more capable model is reserved for the hard reasoning. In a multi-agent system the router is usually the orchestrator, deciding per task which model an agent should use." } },
+ { "@type": "Question", "name": "Does using a smaller model hurt quality?", "acceptedAnswer": { "@type": "Answer", "text": "Only if you use it for the wrong tasks. Most of what an agent does on any given hour is routine — and a smaller model does routine work just as well for a fraction of the cost and latency. Quality drops when you under-power genuinely hard reasoning, not when you right-size the easy stuff. The skill is matching task difficulty to model capability." } },
+ { "@type": "Question", "name": "How much can model routing actually save?", "acceptedAnswer": { "@type": "Answer", "text": "It depends on your task mix, but the economics are stark: the gap between a small and a large model is often 10–20x per token. If most of your agents' work is routine and you route only the hard fraction to the big model, you can cut spend by more than half while keeping — sometimes improving — quality, because cheaper calls also run faster." } },
+ { "@type": "Question", "name": "Who decides which model to use in a multi-agent hive?", "acceptedAnswer": { "@type": "Answer", "text": "The orchestrator. It sees the task before it's assigned, so it's the natural place to pick the model: default everyone to a lean model, and escalate to a heavier one only for tasks flagged as hard, ambiguous, or high-stakes. Individual agents can also request an escalation when they detect they're out of their depth." } }
+
+ ]
+}
+</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>Do More With Less: Smart Model Routing Across Agents</h1>
+ <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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>Running every agent on the biggest model is
+the most common way to waste money on a hive. Most agent work is <strong>routine</strong> — and a
+small, fast model does routine work just as well for a fraction of the cost. <strong>Model routing</strong>
+means defaulting to the lean model and <strong>escalating to a heavyweight only when the task is
+genuinely hard</strong>. The orchestrator is the natural router because it sees the task before it's
+assigned. Done right, you cut spend by more than half <em>and</em> get faster answers — doing more with
+less.</p></div>
+<p>There’s a reflex when you wire up a team of AI agents: give all of them the best model you can afford,
+because more capability is always better, right? It feels safe. It’s also the fastest way to turn a
+useful hive into an expensive one. The truth that experienced operators learn quickly is that <strong>most of
+what agents do all day doesn’t need a frontier model at all</strong> — and paying frontier prices for routine
+work is pure waste. The fix is <strong>model routing</strong>: matching the task to the model instead of flattening
+everything onto one.</p>
+<h2 id="the-work-isnt-uniform-so-why-is-the-model" tabindex="-1">The work isn’t uniform — so why is the model? <a class="anchor" href="#the-work-isnt-uniform-so-why-is-the-model" aria-hidden="true">#</a></h2>
+<p>Watch a hive for an hour and you’ll see a huge range of task difficulty. An agent reformatting a file,
+classifying a message, renaming variables, or summarizing a short log is doing <strong>routine</strong> work — the
+kind a small model handles perfectly. Another agent untangling a subtle race condition, designing an
+architecture, or reasoning through an ambiguous spec is doing <strong>hard</strong> work that genuinely rewards a
+bigger model.</p>
+<p>If you run both on the same heavyweight model, you’re overpaying for the first kind every single time.
+The distribution matters: in most real workloads the routine tasks vastly outnumber the hard ones. So
+the single biggest cost lever isn’t a discount — it’s <strong>not using the expensive model for the 80% of
+work that doesn’t need it</strong>.</p>
+<h2 id="the-economics-plainly" tabindex="-1">The economics, plainly <a class="anchor" href="#the-economics-plainly" aria-hidden="true">#</a></h2>
+<p>The price gap between model tiers is not small. A lean model and a frontier model can differ by
+<strong>10–20x per token</strong>, and the cheaper one usually answers <strong>faster</strong> too. Put those together and the
+arithmetic is hard to ignore:</p>
+<ul>
+<li>Run <strong>everything</strong> on the big model → you pay the premium on every task, routine or not.</li>
+<li>Run <strong>everything</strong> on the small model → you save money but botch the genuinely hard tasks, and a wrong
+answer on a hard task is far more expensive than the tokens you saved.</li>
+<li><strong>Route</strong> → default to the lean model, escalate the hard fraction → you pay the premium only where it
+buys you something.</li>
+</ul>
+<p>The third option typically cuts total spend by more than half while <em>keeping</em> quality, because you only
+spend big where capability actually changes the outcome. “Do more with less” isn’t a slogan here; it’s
+just what falls out of matching price to need.</p>
+<h2 id="the-orchestrator-is-the-natural-router" tabindex="-1">The orchestrator is the natural router <a class="anchor" href="#the-orchestrator-is-the-natural-router" aria-hidden="true">#</a></h2>
+<p>In a single-agent setup, routing is a manual choice you make per session. In a hive, you can do better,
+because there’s already a component that sees every task before it’s handed out: the
+<a href="/blog/how-the-god-orchestrator-works/">orchestrator</a>. It’s the natural place to decide which model each
+task deserves.</p>
+<p>A simple, durable policy:</p>
+<ol>
+<li><strong>Default lean.</strong> Every agent starts on the small, fast model. Most tasks never need more.</li>
+<li><strong>Escalate on signal.</strong> When the orchestrator (or the agent itself) detects that a task is hard,
+ambiguous, high-stakes, or has already failed once on the lean model, it bumps that task to the
+heavyweight.</li>
+<li><strong>De-escalate after.</strong> A hard task often has easy sub-steps. Once the reasoning is done, routine
+follow-up work drops back to the lean model.</li>
+</ol>
+<p>Notice this mirrors how a good human team works: you don’t put your most senior engineer on every ticket;
+you route the gnarly ones to them and let the rest flow to whoever’s available. A lean orchestrator
+<a href="/blog/coordinating-ai-coding-agents/">coordinating specialists</a> and escalating only when needed is the
+same idea applied to models.</p>
+<h2 id="reading-the-signals" tabindex="-1">Reading the signals <a class="anchor" href="#reading-the-signals" aria-hidden="true">#</a></h2>
+<p>Routing well means knowing <em>when</em> a task deserves the expensive model. You don’t need a perfect predictor —
+a few cheap heuristics catch most of it:</p>
+<ul>
+<li><strong>Stakes.</strong> Anything touching spend, destructive operations, or shipped output earns a heavier model
+and usually <a href="/blog/human-in-the-loop-ai-agents/">a human check too</a>.</li>
+<li><strong>Ambiguity.</strong> A vague or open-ended request (design, root-cause, “figure out why”) rewards reasoning
+power; a precise mechanical request doesn’t.</li>
+<li><strong>Failure.</strong> If the lean model tried and got it wrong, escalate instead of retrying at the same tier —
+retrying a too-small model is just paying twice for the same miss.</li>
+<li><strong>Length and dependency.</strong> Tasks that chain many steps or hold a lot of state benefit from the stronger
+model’s coherence over long runs.</li>
+</ul>
+<p>Everything that trips none of these — the bulk of the day — stays lean.</p>
+<h2 id="you-cant-route-what-you-cant-see" tabindex="-1">You can’t route what you can’t see <a class="anchor" href="#you-cant-route-what-you-cant-see" aria-hidden="true">#</a></h2>
+<p>The honest caveat: routing decisions are only as good as your visibility into cost. If you don’t know
+which agents and tasks are burning the most tokens, you’re guessing. The teams that get the most out of
+routing are the ones that <strong>measure first</strong> — per-agent and per-task token spend, attributed and trended
+over time — and then tune the escalation policy against real data instead of vibes. Measurement turns
+routing from a hunch into a control you can actually steer. (It’s the same instinct as
+<a href="/blog/why-local-first-matters-for-ai-agents/">keeping the work local and observable</a>: you can’t manage
+what you can’t watch.)</p>
+<h2 id="the-bottom-line" tabindex="-1">The bottom line <a class="anchor" href="#the-bottom-line" aria-hidden="true">#</a></h2>
+<p>A hive that runs everything on the biggest model isn’t being careful — it’s being wasteful, and slowly.
+The better posture is <strong>lean by default, heavy on purpose</strong>: route the routine majority to a small fast
+model, reserve the frontier model for the hard minority, and measure enough to know which is which. You
+end up spending less, answering faster, and — because you’re no longer drowning genuinely hard tasks in
+the same undifferentiated pool — often getting <em>better</em> results where it counts.</p>
+<p>Munder Difflin is built for exactly this posture: a lean <a href="/#how">orchestrator</a> that routes work across a hive and
+escalates only when a task earns it. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to run an
+agent team that does more with less — 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 AI model routing?</p>
+ <p class="a">Model routing is the practice of sending each task to the model that fits it, rather than running everything on one model. A cheap, fast model handles routine work — formatting, classification, simple edits — and a heavier, more capable model is reserved for the hard reasoning. In a multi-agent system the router is usually the orchestrator, deciding per task which model an agent should use.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Does using a smaller model hurt quality?</p>
+ <p class="a">Only if you use it for the wrong tasks. Most of what an agent does on any given hour is routine — and a smaller model does routine work just as well for a fraction of the cost and latency. Quality drops when you under-power genuinely hard reasoning, not when you right-size the easy stuff. The skill is matching task difficulty to model capability.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How much can model routing actually save?</p>
+ <p class="a">It depends on your task mix, but the economics are stark: the gap between a small and a large model is often 10–20x per token. If most of your agents&#39; work is routine and you route only the hard fraction to the big model, you can cut spend by more than half while keeping — sometimes improving — quality, because cheaper calls also run faster.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Who decides which model to use in a multi-agent hive?</p>
+ <p class="a">The orchestrator. It sees the task before it&#39;s assigned, so it&#39;s the natural place to pick the model: default everyone to a lean model, and escalate to a heavier one only for tasks flagged as hard, ambiguous, or high-stakes. Individual agents can also request an escalation when they detect they&#39;re out of their depth.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/model-routing/">Model Routing</a><a class="tag" href="/blog/tags/cost/">Cost</a><a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/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="#the-work-isnt-uniform-so-why-is-the-model">The work isn’t uniform — so why is the model?</a></li><li class="lvl-2"><a href="#the-economics-plainly">The economics, plainly</a></li><li class="lvl-2"><a href="#the-orchestrator-is-the-natural-router">The orchestrator is the natural router</a></li><li class="lvl-2"><a href="#reading-the-signals">Reading the signals</a></li><li class="lvl-2"><a href="#you-cant-route-what-you-cant-see">You can’t route what you can’t see</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/how-agents-remember-semantic-memory/"><span class="k">← Older</span><span class="t">How AI Agents Remember: Semantic Memory in a Hive</span></a>
+ <a class="pn next" href="/blog/debugging-multi-agent-systems/"><span class="k">Newer →</span><span class="t">How to Debug a Multi-Agent System</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/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</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/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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/feed.xml b/docs/blog/feed.xml
index 5cf8eb78..babf78d9 100644
--- a/docs/blog/feed.xml
+++ b/docs/blog/feed.xml
@@ -31,6 +31,14 @@
<updated>2026-06-04T00:00:00.000Z</updated><category term="Comparisons" />
<summary>An honest 2026 roundup of tools to run multiple Claude Code agents — Claude Squad, Conductor, Crystal, vibe-kanban, and Munder Difflin — compared.</summary>
</entry>
+ <entry>
+ <title>Can Claude Code Agents Talk to Each Other?</title>
+ <link href="https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/" />
+ <id>https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />
+ <summary>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.</summary>
+ </entry>
<entry>
<title>Claude Code Automation: Let Agents Build While You Sleep</title>
<link href="https://munderdiffl.in/blog/claude-code-automation-while-you-sleep/" />
@@ -63,6 +71,14 @@
<updated>2026-06-04T00:00:00.000Z</updated><category term="Comparisons" />
<summary>Claude Squad vs Munder Difflin: a lean terminal session manager against a memory-backed, orchestrated, visual hive. Feature table and an honest verdict.</summary>
</entry>
+ <entry>
+ <title>Context Engineering for AI Agents: Budgeting the Window</title>
+ <link href="https://munderdiffl.in/blog/context-engineering-for-ai-agents/" />
+ <id>https://munderdiffl.in/blog/context-engineering-for-ai-agents/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />
+ <summary>Why context engineering beats prompt wording for agents — and the tactics (isolation, retrieval, externalized state, compaction) that keep the window lean.</summary>
+ </entry>
<entry>
<title>How to Debug a Multi-Agent System</title>
<link href="https://munderdiffl.in/blog/debugging-multi-agent-systems/" />
@@ -71,6 +87,54 @@
<updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />
<summary>How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</summary>
</entry>
+ <entry>
+ <title>Do More With Less: Smart Model Routing Across Agents</title>
+ <link href="https://munderdiffl.in/blog/do-more-with-less-model-routing/" />
+ <id>https://munderdiffl.in/blog/do-more-with-less-model-routing/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />
+ <summary>Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</summary>
+ </entry>
+ <entry>
+ <title>How AI Agents Remember: Semantic Memory in a Hive</title>
+ <link href="https://munderdiffl.in/blog/how-agents-remember-semantic-memory/" />
+ <id>https://munderdiffl.in/blog/how-agents-remember-semantic-memory/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <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>Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</title>
+ <link href="https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/" />
+ <id>https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Memory" />
+ <summary>A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</summary>
+ </entry>
+ <entry>
+ <title>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</title>
+ <link href="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />
+ <id>https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Orchestration" />
+ <summary>How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free.</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/" />
+ <id>https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />
+ <summary>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.</summary>
+ </entry>
+ <entry>
+ <title>What&#39;s New in Agentic AI: A June 2026 Field Guide</title>
+ <link href="https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/" />
+ <id>https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/</id>
+ <published>2026-06-04T00:00:00.000Z</published>
+ <updated>2026-06-04T00:00:00.000Z</updated><category term="Guides" />
+ <summary>A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</summary>
+ </entry>
<entry>
<title>Building a Terminal UI with xterm.js and node-pty</title>
<link href="https://munderdiffl.in/blog/building-a-terminal-ui-xterm-node-pty/" />
diff --git a/docs/blog/give-claude-code-long-term-memory/index.html b/docs/blog/give-claude-code-long-term-memory/index.html
index 98324099..3ee1e973 100644
--- a/docs/blog/give-claude-code-long-term-memory/index.html
+++ b/docs/blog/give-claude-code-long-term-memory/index.html
@@ -208,38 +208,56 @@ to try it; it’s free and open source.</p>
<h2>Related in Memory</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-memory" href="/blog/markdown-first-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-27">May 27, 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/markdown-first-agent-memory/">Why We Built Agent Memory Markdown-First</a></h3>
- <p class="dek">Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.</p>
+ <h3><a href="/blog/how-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
<div class="foot">
<span class="tag kind">Memory</span>
- <a class="more" href="/blog/markdown-first-agent-memory/" aria-label="Read: Why We Built Agent Memory Markdown-First">Read →</a>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-memory" href="/blog/semantic-memory-for-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-26">May 26, 2026</time>
+ <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/semantic-memory-for-ai-agents/">Semantic Memory for AI Agents: Recall in Milliseconds</a></h3>
- <p class="dek">What semantic memory for AI agents is, why a markdown-first store beats a heavy DB, and how a shared palace lets a hive recall a note by meaning, fast.</p>
+ <h3><a href="/blog/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
<div class="foot">
<span class="tag kind">Memory</span>
- <a class="more" href="/blog/semantic-memory-for-ai-agents/" aria-label="Read: Semantic Memory for AI Agents: Recall in Milliseconds">Read →</a>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/markdown-first-agent-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-27">May 27, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/markdown-first-agent-memory/">Why We Built Agent Memory Markdown-First</a></h3>
+ <p class="dek">Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/markdown-first-agent-memory/" aria-label="Read: Why We Built Agent Memory Markdown-First">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/how-agents-remember-semantic-memory/index.html b/docs/blog/how-agents-remember-semantic-memory/index.html
new file mode 100644
index 00000000..e4481a5d
--- /dev/null
+++ b/docs/blog/how-agents-remember-semantic-memory/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>How AI Agents Remember: Semantic Memory in a Hive — Munder Difflin Blog</title>
+<meta name="description" content="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." />
+<link rel="canonical" href="https://munderdiffl.in/blog/how-agents-remember-semantic-memory/" />
+
+<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 Remember: Semantic Memory in a Hive — Munder Difflin Blog" />
+<meta property="og:description" content="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." />
+<meta property="og:url" content="https://munderdiffl.in/blog/how-agents-remember-semantic-memory/" />
+<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="Memory" />
+<meta property="article:tag" content="MemPalace" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Claude Code" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="How AI Agents Remember: Semantic Memory in a Hive — Munder Difflin Blog" />
+<meta name="twitter:description" content="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." />
+<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 Remember: Semantic Memory in a Hive",
+ "description": "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.",
+ "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-agents-remember-semantic-memory/" },
+ "keywords": "how ai agents remember, semantic memory mempalace, ai agent memory, claude code memory",
+ "articleSection": "Memory",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/how-agents-remember-semantic-memory/"
+}
+</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 Remember: Semantic Memory in a Hive", "item": "https://munderdiffl.in/blog/how-agents-remember-semantic-memory/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "How do AI agents remember between sessions?", "acceptedAnswer": { "@type": "Answer", "text": "They write durable facts to a plain-markdown memory file, and the harness mines that file into a shared semantic index — so any agent can recall it by meaning in a later session, even after its context window is wiped." } },
+ { "@type": "Question", "name": "What is MemPalace?", "acceptedAnswer": { "@type": "Answer", "text": "MemPalace is the CLI-driven semantic memory layer Munder Difflin uses: one shared palace on disk, a wing per agent, mined from each agent's memory.md and queried with `mempalace search` and `mempalace wake-up`." } },
+ { "@type": "Question", "name": "Do agents manage the search index themselves?", "acceptedAnswer": { "@type": "Answer", "text": "No. The harness re-mines each changed memory.md every few minutes; agents just write notes and later run `mempalace search` or `wake-up` to recall — there's no database to administer and no MCP server to stand up." } },
+ { "@type": "Question", "name": "What happens if MemPalace isn't installed?", "acceptedAnswer": { "@type": "Answer", "text": "Nothing breaks. The semantic layer degrades to a no-op and agents fall back to reading their markdown memory directly — the fast path is an upgrade, not a dependency." } }
+
+ ]
+}
+</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/memory/">Memory</a>
+ </nav>
+ <h1>How AI Agents Remember: Semantic Memory in a Hive</h1>
+ <p class="dek">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.</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">Memory</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>An agent's working memory — its context
+window — is wiped at the end of every session. So agents "remember" in two moves: they write durable
+facts to a plain-markdown file, and the harness <strong>mines</strong> that file into a shared
+semantic index. Later, any agent recalls by <strong>meaning</strong> with <code>mempalace search</code>
+or boots with a <code>wake-up</code> digest. This is the hands-on version, grounded in the real code in
+<code>src/main/memory.ts</code> — the mine loop, the per-agent wings, and the gotchas we hit
+making it not hang.</p></div>
+<p>If you’ve read <a href="/blog/semantic-memory-for-ai-agents/">what semantic memory is and why markdown-first beats a heavy database</a>,
+this is the companion that shows the machinery actually working. No new theory — just the moving parts,
+the exact commands, and the small decisions that make shared recall reliable in
+<a href="/blog/coordinating-ai-coding-agents/">a coordinated hive of Claude Code agents</a>.</p>
+<h2 id="the-shape-one-palace-many-wings" tabindex="-1">The shape: one palace, many wings <a class="anchor" href="#the-shape-one-palace-many-wings" aria-hidden="true">#</a></h2>
+<p>The whole thing lives in one file — <code>src/main/memory.ts</code>, a <code>MemoryManager</code> running in the Electron
+main process. It’s deliberately <strong>CLI-only</strong> (no MCP server): the harness keeps a single shared
+<em>palace</em> on disk under the harness home, and points every agent’s <code>MEMPALACE_PALACE_PATH</code> at it. When
+an agent is spawned, that env var (plus <code>MEMPALACE_EMBEDDING_MODEL</code>) is merged into its environment, so
+the agent’s own <code>mempalace</code> CLI hits the shared store automatically.</p>
+<p>Inside the palace, each agent gets its own <strong>wing</strong> — addressed by its agent id (<code>--wing &lt;id&gt;</code>). This
+buys two properties at once:</p>
+<ul>
+<li><strong>Private authorship.</strong> Each agent only ever writes its own <code>memory.md</code>, which keeps the
+<a href="/blog/single-committer-git-pattern/">single-writer rule</a> intact — no two agents clobber the same file.</li>
+<li><strong>Shared recall.</strong> A query can scope to one wing <em>or</em> sweep the whole palace. So the researcher’s
+notes are recallable by the coder later, with nobody copy-pasting context.</li>
+</ul>
+<p>That second property is the entire reason a hive beats a lone agent on memory: knowledge accumulates in
+one place and everyone draws from it.</p>
+<h2 id="mining-how-a-note-becomes-searchable" tabindex="-1">Mining: how a note becomes searchable <a class="anchor" href="#mining-how-a-note-becomes-searchable" aria-hidden="true">#</a></h2>
+<p>Agents don’t touch the index by hand. A background <strong>mine loop</strong> does it for them. From the real code,
+<code>MINE_INTERVAL_MS</code> is <code>180_000</code> — so every <strong>three minutes</strong> the manager walks
+<code>hive/agents/*</code>, looks at each <code>memory.md</code>, and mines the ones that changed:</p>
+<pre class="language-bash"><code class="language-bash">mempalace mine <span class="token operator">&lt;</span>agentDir<span class="token operator">></span> <span class="token parameter variable">--wing</span> <span class="token operator">&lt;</span>id<span class="token operator">></span> <span class="token parameter variable">--agent</span> <span class="token operator">&lt;</span>id<span class="token operator">></span></code></pre>
+<p>The “ones that changed” part matters. The loop keeps a <code>lastMined</code> map of each agent’s <code>memory.md</code>
+modification time and <strong>skips files whose mtime is unchanged</strong> — so it doesn’t reload the embedding
+model to re-index notes that haven’t moved. Write a durable fact to your markdown, and a few minutes
+later it’s searchable by the whole team, with zero extra steps on your part. (This is also why
+<code>PROTOCOL.md</code> tells agents <em>“your <a href="http://memory.md">memory.md</a> is mined automatically — you don’t run mine yourself.”</em>)</p>
+<p>Two robustness details worth copying if you build something similar:</p>
+<ul>
+<li><strong>Re-mining is safe.</strong> MemPalace dedups, so mining the same notes again is idempotent. If a mine
+exits non-zero, the loop simply drops that agent from <code>lastMined</code> so the next tick retries it.</li>
+<li><strong>stdin is closed.</strong> The child is spawned with stdin ignored, because the CLI can prompt — and a
+spawned process waiting on a prompt nobody answers hangs forever.</li>
+</ul>
+<h3 id="why-we-dont-run-mempalace-init" tabindex="-1">Why we don’t run <code>mempalace init</code> <a class="anchor" href="#why-we-dont-run-mempalace-init" aria-hidden="true">#</a></h3>
+<p>This is the kind of detail you only learn by hitting it. The obvious bootstrap is <code>mempalace init</code>,
+but it ends in an interactive <code>Mine now? [Y/n]</code> prompt that <code>--yes</code> doesn’t cover — so a spawned child
+would hang on it indefinitely. The fix in <code>memory.ts</code> is to <strong>skip init entirely</strong> and let the first
+<code>mempalace mine</code> lazily create the palace (downloading the local embedding model once, on first run).
+One less moving part, and no hang.</p>
+<h2 id="recall-search-and-wake-up" tabindex="-1">Recall: <code>search</code> and <code>wake-up</code> <a class="anchor" href="#recall-search-and-wake-up" aria-hidden="true">#</a></h2>
+<p>With notes mined, an agent recalls in two ways — both plain CLI calls it runs itself:</p>
+<pre class="language-bash"><code class="language-bash">mempalace search <span class="token string">"how do we build the web bundle?"</span> <span class="token parameter variable">--results</span> <span class="token number">5</span>
+mempalace search <span class="token string">"build quirks"</span> <span class="token parameter variable">--wing</span> dwight-abc123 <span class="token comment"># scope to one agent's wing</span>
+mempalace wake-up <span class="token comment"># session-start digest</span></code></pre>
+<ul>
+<li><strong><code>search</code></strong> returns the most relevant notes <em>by meaning</em> — so “how do we build the web bundle?”
+finds a note about electron-vite even with no shared keywords. You can widen with <code>--results N</code> or
+narrow with <code>--wing &lt;id&gt;</code>.</li>
+<li><strong><code>wake-up</code></strong> returns a short digest (a few hundred tokens) structured into an identity layer and an
+“essential story” of what matters across the team. It’s meant to be read at the <em>start</em> of a task, so
+an agent boots with the hive’s relevant knowledge already in hand instead of cold. <code>PROTOCOL.md</code>
+bakes this into the routine: run <code>wake-up</code> at the start of a task, <code>search</code> when you need to recall
+something specific.</li>
+</ul>
+<p>Both calls run with a generous timeout and an empty stdin (again: never wait on a prompt). The reason
+recall feels instant is that the expensive work — turning notes into vectors — already happened during
+mining; at recall time you embed one short query and compare against pre-computed vectors.</p>
+<h2 id="graceful-degradation-is-the-safety-net" tabindex="-1">Graceful degradation is the safety net <a class="anchor" href="#graceful-degradation-is-the-safety-net" aria-hidden="true">#</a></h2>
+<p>The manager exposes a <code>status()</code> with four honest booleans — <code>available</code> (is the <code>mempalace</code> CLI on
+PATH?), <code>enabled</code> (user setting), <code>active</code>, and <code>initialized</code>. It resolves the binary across the
+shell PATH plus the usual <code>~/.local/bin</code>, Homebrew, and <code>/usr/local/bin</code> spots. And critically: <strong>if
+the CLI isn’t installed, the whole layer is a silent no-op.</strong> Agents fall back to reading their
+markdown <code>memory.md</code> directly. The semantic index is a recall <em>accelerator</em> sitting on top of the
+markdown — never a single point of failure that takes the memory down with it.</p>
+<p>The embedding model is configurable (<code>minilm</code> by default for snappy local recall, <code>embeddinggemma</code>
+when you want a heavier multilingual model). Everything runs locally — the palace, the model, the
+mining — so memory stays <a href="/blog/why-local-first-matters-for-ai-agents/">local-first</a> and private.</p>
+<h2 id="why-this-matters-for-a-hive-not-just-one-agent" tabindex="-1">Why this matters for a hive (not just one agent) <a class="anchor" href="#why-this-matters-for-a-hive-not-just-one-agent" aria-hidden="true">#</a></h2>
+<p>A single agent with memory is useful. A <em>hive</em> with shared memory compounds:</p>
+<ul>
+<li>Your briefs get shorter every week, because the team stops needing context re-explained.</li>
+<li>Agents stop contradicting each other, because they recall the same shared decisions.</li>
+<li>A brand-new agent is useful immediately — it wakes up into the team’s accumulated knowledge instead
+of a blank slate.</li>
+</ul>
+<p>That shared, durable recall is also what lets the <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a>
+route well: it can recall what’s been tried and who knows what, instead of asking you every time.</p>
+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
+<p><strong>Where does the palace actually live?</strong> Under the harness home, in a <code>palace/</code> directory. Every
+agent’s <code>MEMPALACE_PALACE_PATH</code> points there, so it’s genuinely one shared store, not a copy per agent.</p>
+<p><strong>How often is memory refreshed?</strong> Every three minutes the harness re-mines any <code>memory.md</code> that
+changed since last time. Unchanged files are skipped, so it’s cheap.</p>
+<p><strong>Do I have to write notes a certain way?</strong> Small, atomic, factual notes recall sharply; rambling ones
+recall fuzzily. Good memory hygiene is the one thing that’s on you — see
+<a href="/blog/markdown-first-agent-memory/">why we built agent memory markdown-first</a>.</p>
+<hr>
+<p>Munder Difflin gives every Claude Code agent plain-markdown memory plus a shared semantic palace the
+whole <a href="/#how">hive can recall from</a> — local, fast, and graceful when the index isn’t there.
+<a href="/#install">Download Munder Difflin</a> to give your agents memory that actually sticks; it’s free and
+open source.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">How do AI agents remember between sessions?</p>
+ <p class="a">They write durable facts to a plain-markdown memory file, and the harness mines that file into a shared semantic index — so any agent can recall it by meaning in a later session, even after its context window is wiped.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What is MemPalace?</p>
+ <p class="a">MemPalace is the CLI-driven semantic memory layer Munder Difflin uses: one shared palace on disk, a wing per agent, mined from each agent&#39;s memory.md and queried with `mempalace search` and `mempalace wake-up`.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Do agents manage the search index themselves?</p>
+ <p class="a">No. The harness re-mines each changed memory.md every few minutes; agents just write notes and later run `mempalace search` or `wake-up` to recall — there&#39;s no database to administer and no MCP server to stand up.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What happens if MemPalace isn&#39;t installed?</p>
+ <p class="a">Nothing breaks. The semantic layer degrades to a no-op and agents fall back to reading their markdown memory directly — the fast path is an upgrade, not a dependency.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/memory/">Memory</a><a class="tag" href="/blog/tags/mempalace/">MemPalace</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#the-shape-one-palace-many-wings">The shape: one palace, many wings</a></li><li class="lvl-2"><a href="#mining-how-a-note-becomes-searchable">Mining: how a note becomes searchable</a></li><li class="lvl-3"><a href="#why-we-dont-run-mempalace-init">Why we don’t run mempalace init</a></li><li class="lvl-2"><a href="#recall-search-and-wake-up">Recall: search and wake-up</a></li><li class="lvl-2"><a href="#graceful-degradation-is-the-safety-net">Graceful degradation is the safety net</a></li><li class="lvl-2"><a href="#why-this-matters-for-a-hive-not-just-one-agent">Why this matters for a hive (not just one agent)</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&#39;s Semantic Memory Clean: Don&#39;t Index the Config</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">
+ <h2>Related in Memory</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-27">May 27, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>3 min</span>
+ </div>
+ <h3><a href="/blog/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
+ <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/markdown-first-agent-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-27">May 27, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/markdown-first-agent-memory/">Why We Built Agent Memory Markdown-First</a></h3>
+ <p class="dek">Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/markdown-first-agent-memory/" aria-label="Read: Why We Built Agent Memory Markdown-First">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/how-the-god-orchestrator-works/index.html b/docs/blog/how-the-god-orchestrator-works/index.html
index 28851b4c..d545b209 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/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&#39;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&#39;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&#39;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/coordinating-ai-coding-agents/" 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-29">May 29, 2026</time>
+ <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/coordinating-ai-coding-agents/">The Best Way to Coordinate AI Coding Agents</a></h3>
- <p class="dek">The best way to coordinate AI coding agents: single-writer files, a message router, a one-scribe plan, and an orchestrator — cooperate, not clobber.</p>
+ <h3><a href="/blog/human-in-the-loop-ai-agents/">Human-in-the-Loop AI Agents: Approvals That Don&#39;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/coordinating-ai-coding-agents/" aria-label="Read: The Best Way to Coordinate AI Coding Agents">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&#39;t Slow You Down">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/how-to-install-and-use-munder-difflin/index.html b/docs/blog/how-to-install-and-use-munder-difflin/index.html
index 8aaf3a08..c18573cf 100644
--- a/docs/blog/how-to-install-and-use-munder-difflin/index.html
+++ b/docs/blog/how-to-install-and-use-munder-difflin/index.html
@@ -422,38 +422,38 @@ task.</p>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
<article class="card">
- <a class="thumb t-guides" href="/blog/mcp-and-skills-in-a-hive/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-03">Jun 3, 2026</time>
+ <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/mcp-and-skills-in-a-hive/">Bringing Your MCP Servers and Skills Into a Hive of Agents</a></h3>
- <p class="dek">How agents in a hive inherit your existing Claude Code MCP servers, skills, and tools — and how to scope which agent gets which capability.</p>
+ <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
+ <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
<div class="foot">
<span class="tag kind">Guides</span>
- <a class="more" href="/blog/mcp-and-skills-in-a-hive/" aria-label="Read: Bringing Your MCP Servers and Skills Into a Hive of Agents">Read →</a>
+ <a class="more" href="/blog/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/how-to-run-multiple-claude-code-agents/index.html b/docs/blog/how-to-run-multiple-claude-code-agents/index.html
index 289942d4..cbff0989 100644
--- a/docs/blog/how-to-run-multiple-claude-code-agents/index.html
+++ b/docs/blog/how-to-run-multiple-claude-code-agents/index.html
@@ -251,20 +251,20 @@ free and open source.</p>
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-guides" href="/blog/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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
diff --git a/docs/blog/human-in-the-loop-ai-agents/index.html b/docs/blog/human-in-the-loop-ai-agents/index.html
index 68ae2f0d..40f6cec8 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/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&#39;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>
<article class="card">
- <a class="thumb t-orchestration" href="/blog/coordinating-ai-coding-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-orchestration" href="/blog/how-the-god-orchestrator-works/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-29">May 29, 2026</time>
+ <time datetime="2026-05-30">May 30, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/coordinating-ai-coding-agents/">The Best Way to Coordinate AI Coding Agents</a></h3>
- <p class="dek">The best way to coordinate AI coding agents: single-writer files, a message router, a one-scribe plan, and an orchestrator — cooperate, not clobber.</p>
+ <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>
<div class="foot">
<span class="tag kind">Orchestration</span>
- <a class="more" href="/blog/coordinating-ai-coding-agents/" aria-label="Read: The Best Way to Coordinate AI Coding Agents">Read →</a>
+ <a class="more" href="/blog/how-the-god-orchestrator-works/" aria-label="Read: Inside the GOD Orchestrator: Routing, Adjudication, Escalation">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/index.html b/docs/blog/index.html
index 74cfaf7f..9c2161fd 100644
--- a/docs/blog/index.html
+++ b/docs/blog/index.html
@@ -85,19 +85,19 @@
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">42</span></a>
+ <a class="chip" aria-current="page">All<span class="ct">50</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
@@ -167,6 +167,24 @@
</div>
</div>
</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </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-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
@@ -239,6 +257,24 @@
</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>
<article class="card">
<a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
@@ -257,6 +293,114 @@
</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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">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>
+ </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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">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&#39;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-concepts" href="/blog/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </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>
+ </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/whats-new-in-agentic-ai-june-2026/">What&#39;s New in Agentic AI: A June 2026 Field Guide</a></h3>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-label="Read: What&#39;s New in Agentic AI: A June 2026 Field Guide">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/keep-agent-semantic-memory-clean/index.html b/docs/blog/keep-agent-semantic-memory-clean/index.html
new file mode 100644
index 00000000..35a574a4
--- /dev/null
+++ b/docs/blog/keep-agent-semantic-memory-clean/index.html
@@ -0,0 +1,388 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config — Munder Difflin Blog</title>
+<meta name="description" content="A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix." />
+<link rel="canonical" href="https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/" />
+
+<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="Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config — Munder Difflin Blog" />
+<meta property="og:description" content="A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix." />
+<meta property="og:url" content="https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/" />
+<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="Memory" />
+<meta property="article:tag" content="MemPalace" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Claude Code" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config — Munder Difflin Blog" />
+<meta name="twitter:description" content="A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix." />
+<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": "Keep Your Agent's Semantic Memory Clean: Don't Index the Config",
+ "description": "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.",
+ "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/keep-agent-semantic-memory-clean/" },
+ "keywords": "agent semantic memory hygiene, semantic memory noise, gitignore semantic index, agent memory pruning",
+ "articleSection": "Memory",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/"
+}
+</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": "Keep Your Agent's Semantic Memory Clean: Don't Index the Config", "item": "https://munderdiffl.in/blog/keep-agent-semantic-memory-clean/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "Why would an agent's semantic memory return config files instead of real notes?", "acceptedAnswer": { "@type": "Answer", "text": "Because the indexer mines a directory, and the directory holds more than your notes. If your agent's folder also contains a settings file, a cursor file, and an inbox of message JSON, a naive 'index everything' pass files all of it. A large config blob produces many embeddings, so it dominates the wake-up digest and crowds out the handful of notes you actually wrote." } },
+ { "@type": "Question", "name": "How do I stop a miner from indexing config and message files?", "acceptedAnswer": { "@type": "Answer", "text": "Most file-based miners honor .gitignore. Drop a .gitignore in each indexed directory listing the non-memory files (settings, cursor, inbox/, outbox/) and the miner skips them on the next pass. No flag, no fork — you're using a mechanism the tool already respects." } },
+ { "@type": "Question", "name": "Does adding .gitignore remove what was already indexed?", "acceptedAnswer": { "@type": "Answer", "text": "No. Mining is usually additive — it files new content but doesn't delete drawers for files it no longer scans. To clear what's already in the index you need a prune/sync pass that removes entries whose source is now gitignored, deleted, or moved. The .gitignore prevents future noise; the prune cleans up the past." } }
+
+ ]
+}
+</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/memory/">Memory</a>
+ </nav>
+ <h1>Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</h1>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</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">Memory</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>A semantic memory layer indexes whatever
+files you point it at — and an agent's folder holds more than its notes. When a large
+<strong>settings file</strong> and a folder of <strong>message JSON</strong> got mined alongside the
+real <code>memory.md</code>, the wake-up digest filled with config blobs and became unreadable. The fix
+is two moves: drop a <strong>.gitignore</strong> in each indexed directory so the miner skips the
+non-memory files, then run a <strong>prune pass</strong> to evict what was already filed. Recall is only
+as good as the corpus you feed it.</p></div>
+<p><a href="/blog/semantic-memory-for-ai-agents/">Semantic memory</a> is supposed to make an agent recall the right
+note by <em>meaning</em> — you ask “how do we build the web bundle?” and it surfaces the note about
+electron-vite even though you never typed that word. It works beautifully when the index contains your
+notes. It falls apart quietly when the index contains everything <em>else</em> too.</p>
+<p>This is a short post about a real bug I hit in a running hive, why it happened, and the small fix that
+made the memory layer useful again. The lesson generalizes to any agent that mines a directory into a
+vector store.</p>
+<h2 id="the-symptom-a-wake-up-digest-full-of-config" tabindex="-1">The symptom: a wake-up digest full of config <a class="anchor" href="#the-symptom-a-wake-up-digest-full-of-config" aria-hidden="true">#</a></h2>
+<p>Each agent in the hive keeps a markdown memory and writes durable facts to it as it works. A background
+loop mines every agent’s folder into a shared semantic store every few minutes, so the whole team can
+recall by meaning. At session start an agent runs a <code>wake-up</code> command that returns the most salient
+memories in ~600–900 tokens — its “what do I already know” digest.</p>
+<p>One morning the digest looked like this:</p>
+<pre class="language-text"><code class="language-text">## L1 — ESSENTIAL STORY
+[general]
+ - { "hooks": { "Stop": [ { "hooks": [ { "type": "command",
+ "command": "node \"/.../cth-hook.cjs\"" ... (settings.json)
+ - ] } ], "PostToolUse": [ { "matcher": "*", ... (settings.json)
+ - # Memory — Kelly _Append durable facts, decisions, and context below._ (memory.md)
+ - { "hooks": { "Stop": [ ... (settings.json)</code></pre>
+<p>The “essential story” was almost entirely a hooks configuration file, repeated across agents, with the
+occasional real note wedged between the blobs. The most important context an agent could load was
+being spent on JSON it would never need to recall.</p>
+<h2 id="the-cause-the-index-ate-the-whole-directory" tabindex="-1">The cause: the index ate the whole directory <a class="anchor" href="#the-cause-the-index-ate-the-whole-directory" aria-hidden="true">#</a></h2>
+<p>The miner does what most file-based indexers do — it walks the target directory and files every file it
+finds. But an agent’s folder isn’t just <code>memory.md</code>. It also holds:</p>
+<ul>
+<li><code>settings.json</code> — the Claude Code hooks config. A large, deeply-nested JSON blob.</li>
+<li><code>cursor.json</code> — bookkeeping for which messages have been processed.</li>
+<li><code>inbox/</code> and <code>outbox/</code> — raw inter-agent message JSON, unstructured and high-volume.</li>
+</ul>
+<p>Two things made this especially toxic to recall. First, <strong>size becomes weight</strong>: a big config file
+chunks into many embeddings, so it occupies far more of the index than a terse three-line note — and a
+digest that ranks by salience surfaces it first. Second, <strong>machine files aren’t memories</strong>: a hooks
+config or a message envelope has no durable knowledge in it, so every drawer it fills is pure noise. The
+signal — the few sentences an agent actually wrote down — drowned.</p>
+<p>This is the semantic-memory version of a classic <a href="/blog/context-engineering-for-ai-agents/">context-engineering</a>
+mistake: the failure isn’t the model or the embeddings, it’s that we fed the layer the wrong corpus.</p>
+<h2 id="the-fix-part-one-tell-the-miner-what-not-to-read" tabindex="-1">The fix, part one: tell the miner what not to read <a class="anchor" href="#the-fix-part-one-tell-the-miner-what-not-to-read" aria-hidden="true">#</a></h2>
+<p>The miner already honored <code>.gitignore</code> — it just had nothing to honor, because the agent folders had no
+<code>.gitignore</code>. So the fix is to write one. In each indexed directory:</p>
+<pre class="language-gitignore"><code class="language-gitignore"><span class="token entry string">settings.json</span>
+<span class="token entry string">cursor.json</span>
+<span class="token entry string">inbox<span class="token punctuation">/</span></span>
+<span class="token entry string">outbox<span class="token punctuation">/</span></span></code></pre>
+<p>On the next pass the miner skips those paths and files only the real memory. No new flag, no fork of the
+tool, no <code>--exclude</code> plumbing through three layers of code — we used a convention the indexer already
+respected. Two places write this file: the indexer ensures it exists right before each mine, and the
+agent bootstrap drops it in at <em>birth</em>, next to the freshly-created <code>memory.md</code>, so a new agent is clean
+from its first cycle. The write is append-only and idempotent — it adds only the missing lines and never
+rewrites a file that’s already correct, so it’s safe to call every cycle.</p>
+<p>There’s a small design principle hiding here: <strong>the directory you index should describe what belongs in
+it.</strong> A <code>.gitignore</code> is a readable, version-controlled declaration of “these files are operational, not
+knowledge.” That’s better than burying an exclude list inside the miner, where the next person has to go
+read source code to find out why their config isn’t showing up in recall.</p>
+<h2 id="the-fix-part-two-prune-whats-already-filed" tabindex="-1">The fix, part two: prune what’s already filed <a class="anchor" href="#the-fix-part-two-prune-whats-already-filed" aria-hidden="true">#</a></h2>
+<p>Adding a <code>.gitignore</code> stops <em>future</em> noise. It does nothing about the thousands of config drawers
+already sitting in the index, because mining is <strong>additive</strong> — it files new content and updates changed
+content, but it doesn’t delete drawers for files it simply stopped scanning. Re-mining the cleaned
+folder won’t help; the old entries aren’t tied to anything the new pass touches.</p>
+<p>You need a separate prune. A good memory CLI ships one — a <code>sync</code> that walks the index and removes any
+drawer whose source file is now gitignored, deleted, or moved:</p>
+<pre class="language-bash"><code class="language-bash"><span class="token comment"># preview first — see what would be removed</span>
+mempalace <span class="token function">sync</span> ./hive/agents --dry-run
+
+<span class="token comment"># then commit the deletions</span>
+mempalace <span class="token function">sync</span> ./hive/agents <span class="token parameter variable">--apply</span></code></pre>
+<p>In the live hive this evicted ~800 noise drawers (the gitignored config and message JSON, plus a few
+whose source files had already been archived) and kept ~600 real-memory drawers. The global wake-up went
+from a wall of <code>settings.json</code> to actual notes — agent roles, working directories, a design hand-off, a
+release decision — and the digest got <em>smaller</em> (754 → 603 tokens) while carrying far more signal.</p>
+<blockquote>
+<p><strong>Mental model:</strong> <code>.gitignore</code> is the filter on the way <em>in</em>; <code>sync --apply</code> is the cleanup on the way
+<em>out</em>. You need both. The first keeps the corpus clean going forward; the second repairs the damage
+already done. Doing only the first leaves you waiting for the noise to age out on its own — and it
+won’t.</p>
+</blockquote>
+<h2 id="why-this-matters-beyond-one-tool" tabindex="-1">Why this matters beyond one tool <a class="anchor" href="#why-this-matters-beyond-one-tool" aria-hidden="true">#</a></h2>
+<p>If you’re building or running any agent with a <a href="/blog/give-claude-code-long-term-memory/">long-term memory layer</a>,
+the takeaway is corpus discipline:</p>
+<ul>
+<li><strong>Index notes, not machinery.</strong> Config, cursors, locks, and message logs are operational state, not
+knowledge. Keep them out of the recall corpus on purpose.</li>
+<li><strong>Make exclusions declarative.</strong> A <code>.gitignore</code> (or equivalent manifest) at the indexed root is
+legible and diffable; an exclude list hidden in code is neither.</li>
+<li><strong>Separate “stop indexing” from “remove what’s indexed.”</strong> Additive miners don’t garbage-collect.
+Budget for a periodic prune, or your index slowly fills with the ghosts of files you’ve moved on from.</li>
+<li><strong>Watch the digest, not just the search.</strong> A keyword search can still find a good note buried under
+noise; a fixed-size wake-up digest can’t — it’s the canary that tells you the corpus has drifted.</li>
+</ul>
+<p>Good <a href="/blog/markdown-first-agent-memory/">memory hygiene</a> is the difference between a memory layer that
+sharpens an agent and one that buries it. Small, atomic, factual notes in; operational files out; a
+prune pass to keep it honest.</p>
+<hr>
+<p>Munder Difflin gives every Claude Code agent markdown memory plus
+<a href="https://munderdiffl.in/#how">a shared semantic palace the whole hive can recall from</a> — local, fast,
+and clean by default.
+<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to give your agents memory that actually
+sticks; 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 would an agent&#39;s semantic memory return config files instead of real notes?</p>
+ <p class="a">Because the indexer mines a directory, and the directory holds more than your notes. If your agent&#39;s folder also contains a settings file, a cursor file, and an inbox of message JSON, a naive &#39;index everything&#39; pass files all of it. A large config blob produces many embeddings, so it dominates the wake-up digest and crowds out the handful of notes you actually wrote.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How do I stop a miner from indexing config and message files?</p>
+ <p class="a">Most file-based miners honor .gitignore. Drop a .gitignore in each indexed directory listing the non-memory files (settings, cursor, inbox/, outbox/) and the miner skips them on the next pass. No flag, no fork — you&#39;re using a mechanism the tool already respects.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Does adding .gitignore remove what was already indexed?</p>
+ <p class="a">No. Mining is usually additive — it files new content but doesn&#39;t delete drawers for files it no longer scans. To clear what&#39;s already in the index you need a prune/sync pass that removes entries whose source is now gitignored, deleted, or moved. The .gitignore prevents future noise; the prune cleans up the past.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/memory/">Memory</a><a class="tag" href="/blog/tags/mempalace/">MemPalace</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#the-symptom-a-wake-up-digest-full-of-config">The symptom: a wake-up digest full of config</a></li><li class="lvl-2"><a href="#the-cause-the-index-ate-the-whole-directory">The cause: the index ate the whole directory</a></li><li class="lvl-2"><a href="#the-fix-part-one-tell-the-miner-what-not-to-read">The fix, part one: tell the miner what not to read</a></li><li class="lvl-2"><a href="#the-fix-part-two-prune-whats-already-filed">The fix, part two: prune what’s already filed</a></li><li class="lvl-2"><a href="#why-this-matters-beyond-one-tool">Why this matters beyond one tool</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/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 Memory</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-27">May 27, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>3 min</span>
+ </div>
+ <h3><a href="/blog/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
+ <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/markdown-first-agent-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-27">May 27, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/markdown-first-agent-memory/">Why We Built Agent Memory Markdown-First</a></h3>
+ <p class="dek">Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/markdown-first-agent-memory/" aria-label="Read: Why We Built Agent Memory Markdown-First">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/manage-multiple-claude-code-sessions/index.html b/docs/blog/manage-multiple-claude-code-sessions/index.html
index d0f11a98..d736187c 100644
--- a/docs/blog/manage-multiple-claude-code-sessions/index.html
+++ b/docs/blog/manage-multiple-claude-code-sessions/index.html
@@ -304,20 +304,20 @@ isolated agents, shared memory, and a single committer, all on your own machine.
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
diff --git a/docs/blog/markdown-first-agent-memory/index.html b/docs/blog/markdown-first-agent-memory/index.html
index 286982f3..055b70d7 100644
--- a/docs/blog/markdown-first-agent-memory/index.html
+++ b/docs/blog/markdown-first-agent-memory/index.html
@@ -273,38 +273,56 @@ to give your agents memory you can actually read; it’s free and open source.</
<h2>Related in Memory</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-27">May 27, 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/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
- <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
+ <h3><a href="/blog/how-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
<div class="foot">
<span class="tag kind">Memory</span>
- <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">Read →</a>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-memory" href="/blog/semantic-memory-for-ai-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-26">May 26, 2026</time>
+ <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/semantic-memory-for-ai-agents/">Semantic Memory for AI Agents: Recall in Milliseconds</a></h3>
- <p class="dek">What semantic memory for AI agents is, why a markdown-first store beats a heavy DB, and how a shared palace lets a hive recall a note by meaning, fast.</p>
+ <h3><a href="/blog/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-27">May 27, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>3 min</span>
+ </div>
+ <h3><a href="/blog/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
+ <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
<div class="foot">
<span class="tag kind">Memory</span>
- <a class="more" href="/blog/semantic-memory-for-ai-agents/" aria-label="Read: Semantic Memory for AI Agents: Recall in Milliseconds">Read →</a>
+ <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/mcp-and-skills-in-a-hive/index.html b/docs/blog/mcp-and-skills-in-a-hive/index.html
index a338203f..dd71c28b 100644
--- a/docs/blog/mcp-and-skills-in-a-hive/index.html
+++ b/docs/blog/mcp-and-skills-in-a-hive/index.html
@@ -320,20 +320,20 @@ existing setup into a coordinated team of agents; it’s free and open source.</
</div>
</article>
<article class="card">
- <a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
+ <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>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/debugging-multi-agent-systems/">How to Debug a Multi-Agent System</a></h3>
- <p class="dek">How to debug a multi-agent system: use the event log, per-agent terminals, message trails, and git history to find why a hive of AI agents went sideways.</p>
+ <h3><a href="/blog/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/debugging-multi-agent-systems/" aria-label="Read: How to Debug a Multi-Agent System">Read →</a>
+ <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>
diff --git a/docs/blog/munder-difflin-faq/index.html b/docs/blog/munder-difflin-faq/index.html
index eab7cbc7..49f74fd4 100644
--- a/docs/blog/munder-difflin-faq/index.html
+++ b/docs/blog/munder-difflin-faq/index.html
@@ -266,56 +266,56 @@ free, open source, and local-first.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
+ <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-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>6 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/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/ai-agent-glossary/" aria-label="Read: The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent">Read →</a>
+ <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/what-are-claude-code-agents/" aria-hidden="true" tabindex="-1">
+ <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-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/what-are-claude-code-agents/">What Are Claude Code Agents? And How to Use Many at Once</a></h3>
- <p class="dek">Claude Code agents explained in plain English — what an agent actually is, how subagents differ, and the leap from one agent to a coordinated team.</p>
+ <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
+ <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/what-are-claude-code-agents/" aria-label="Read: What Are Claude Code Agents? And How to Use Many at Once">Read →</a>
+ <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/what-is-a-multi-agent-harness/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-22">May 22, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>2 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/what-is-a-multi-agent-harness/">What Is a Multi-Agent Harness? (Plain-English Guide)</a></h3>
- <p class="dek">A multi-agent harness coordinates several AI coding agents into one team — here&#39;s what that means, and how it differs from a single agent or a framework.</p>
+ <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>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/what-is-a-multi-agent-harness/" aria-label="Read: What Is a Multi-Agent Harness? (Plain-English Guide)">Read →</a>
+ <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>
</div>
</div>
</article>
diff --git a/docs/blog/scheduling-autonomous-agent-missions/index.html b/docs/blog/scheduling-autonomous-agent-missions/index.html
new file mode 100644
index 00000000..408a5db3
--- /dev/null
+++ b/docs/blog/scheduling-autonomous-agent-missions/index.html
@@ -0,0 +1,396 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions — Munder Difflin Blog</title>
+<meta name="description" content="How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free." />
+<link rel="canonical" href="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />
+
+<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="Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions — Munder Difflin Blog" />
+<meta property="og:description" content="How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free." />
+<meta property="og:url" content="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />
+<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="Automation" />
+<meta property="article:tag" content="Autonomous" />
+<meta property="article:tag" content="Hive" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions — Munder Difflin Blog" />
+<meta name="twitter:description" content="How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free." />
+<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": "Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions",
+ "description": "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.",
+ "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/scheduling-autonomous-agent-missions/" },
+ "keywords": "scheduled agent missions, recurring autonomous tasks, schedule ai agents, cron for ai agents",
+ "articleSection": "Orchestration",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/"
+}
+</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": "Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions", "item": "https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What is a scheduled mission in a multi-agent harness?", "acceptedAnswer": { "@type": "Answer", "text": "A scheduled mission is a recurring instruction the harness fires on a fixed interval. Each tick it sends a request message to a target agent — a specific one or the whole hive — so work happens on a cadence without anyone typing a prompt. Think cron, but the job is an agent task." } },
+ { "@type": "Question", "name": "How is a scheduled mission different from an autonomous loop?", "acceptedAnswer": { "@type": "Answer", "text": "An autonomous loop keeps one agent going until its queue is empty. A scheduled mission refills that queue on a timer. The loop is the engine; the schedule is the alarm clock. Together they let a hive pick up fresh, recurring work on its own and then run each piece to completion." } },
+ { "@type": "Question", "name": "Do scheduled missions run when the app is closed?", "acceptedAnswer": { "@type": "Answer", "text": "No. The timers live in the desktop app's process, so missions only fire while it's open — this is local-first, not a cloud cron. But each mission remembers when it last fired, so on the next launch an overdue mission fires right away and the cadence resumes instead of resetting." } }
+
+ ]
+}
+</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>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</h1>
+ <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free.</p>
+ <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">Orchestration</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>A <strong>scheduled mission</strong> is a
+recurring instruction the harness fires on an interval: each tick it drops a <code>request</code> into
+a target agent's queue, so a hive does standups, audits, or nightly reports <strong>without you typing
+a prompt</strong>. It pairs with the <a href="/blog/claude-code-automation-while-you-sleep/">autonomous
+loop</a> — the loop keeps an agent working until its queue is empty, the schedule refills the queue on
+a cadence. Missions remember when they last fired, so restarts resume the rhythm instead of resetting
+it.</p></div>
+<p>There’s a difference between an agent that works <em>when you ask</em> and a hive that works <em>on a schedule</em>.
+The first still needs you at the keyboard. The second wakes itself up — runs a standup every hour,
+audits the build every night, summarizes new issues every morning — and only pulls you in when
+something actually needs a human. Munder Difflin ships this as <strong>scheduled missions</strong>, and this guide
+walks through how they work, grounded in the real code, plus the patterns that keep them useful instead
+of noisy.</p>
+<h2 id="what-a-mission-actually-is" tabindex="-1">What a mission actually is <a class="anchor" href="#what-a-mission-actually-is" aria-hidden="true">#</a></h2>
+<p>A mission is a small, persisted record. In <code>src/main/config.ts</code> it’s a <code>ScheduledMission</code>:</p>
+<pre class="language-ts"><code class="language-ts"><span class="token keyword">interface</span> <span class="token class-name">ScheduledMission</span> <span class="token punctuation">{</span>
+ id<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span>
+ label<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span> <span class="token comment">// shows up as the message subject</span>
+ intervalMs<span class="token operator">:</span> <span class="token builtin">number</span><span class="token punctuation">;</span> <span class="token comment">// the cadence</span>
+ to<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span> <span class="token comment">// target: an agent id, or 'broadcast'</span>
+ body<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span> <span class="token comment">// the instruction the agent receives</span>
+ enabled<span class="token operator">:</span> <span class="token builtin">boolean</span><span class="token punctuation">;</span>
+ lastFiredAt<span class="token operator">?</span><span class="token operator">:</span> <span class="token builtin">number</span><span class="token punctuation">;</span> <span class="token comment">// scheduler-owned; when it last ran</span>
+<span class="token punctuation">}</span></code></pre>
+<p>Missions live in the harness config under a <code>missions[]</code> array, so they survive restarts. That’s the
+whole data model — no DAG, no external job store. A mission is “send <em>this</em> instruction to <em>this</em>
+target, every <em>this often</em>.”</p>
+<h2 id="how-the-scheduler-fires" tabindex="-1">How the scheduler fires <a class="anchor" href="#how-the-scheduler-fires" aria-hidden="true">#</a></h2>
+<p>The engine is <code>syncMissions()</code> in <code>src/main/index.ts</code>. It runs on boot (right after the message router
+starts) and again after any change to your missions. Each run it does two things: clear every existing
+timer, then arm a fresh timer for each enabled mission. Clearing first is what makes editing one
+mission safe — nothing gets double-armed.</p>
+<p>When a mission’s timer fires, the <code>fire()</code> callback does exactly two things:</p>
+<pre class="language-ts"><code class="language-ts"><span class="token keyword">if</span> <span class="token punctuation">(</span>hive<span class="token punctuation">.</span><span class="token function">enabled</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
+ hive<span class="token punctuation">.</span><span class="token function">send</span><span class="token punctuation">(</span><span class="token punctuation">{</span> to<span class="token operator">:</span> m<span class="token punctuation">.</span>to<span class="token punctuation">,</span> act<span class="token operator">:</span> <span class="token string">'request'</span><span class="token punctuation">,</span> subject<span class="token operator">:</span> m<span class="token punctuation">.</span>label<span class="token punctuation">,</span> body<span class="token operator">:</span> m<span class="token punctuation">.</span>body <span class="token punctuation">}</span><span class="token punctuation">,</span> <span class="token string">'scheduler'</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
+<span class="token punctuation">}</span>
+<span class="token comment">// then stamp lastFiredAt = Date.now() back into config</span></code></pre>
+<p>That’s the heart of it. A mission tick is just a <code>request</code> message, sent <strong>from <code>scheduler</code></strong>, that
+lands in the target agent’s inbox like any other message. The agent reads it at the start of its next
+turn and acts. There’s nothing special about a scheduled task once it’s in the queue — which is exactly
+why it composes so cleanly with the rest of the hive.</p>
+<p>This very post is proof. It exists because an <strong>“Hourly Standup” mission</strong> fired: a request, from
+<code>scheduler</code>, broadcast to every agent, asking each to report status and pick up work. No one typed that
+prompt this hour. The schedule did.</p>
+<h2 id="why-lastfiredat-matters" tabindex="-1">Why <code>lastFiredAt</code> matters <a class="anchor" href="#why-lastfiredat-matters" aria-hidden="true">#</a></h2>
+<p>The one piece of cleverness worth understanding is <code>lastFiredAt</code>. A naive scheduler would restart every
+interval from zero whenever the app reboots or you edit an unrelated mission — so an hourly job could
+drift, double-fire, or never fire if you kept tweaking things. Instead, the harness computes how much
+time is actually left:</p>
+<pre class="language-ts"><code class="language-ts"><span class="token keyword">const</span> remaining <span class="token operator">=</span> Math<span class="token punctuation">.</span><span class="token function">max</span><span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">,</span> m<span class="token punctuation">.</span>intervalMs <span class="token operator">-</span> <span class="token punctuation">(</span>Date<span class="token punctuation">.</span><span class="token function">now</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">-</span> <span class="token punctuation">(</span>m<span class="token punctuation">.</span>lastFiredAt <span class="token operator">??</span> <span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
+<span class="token function">setTimeout</span><span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">=></span> <span class="token punctuation">{</span> <span class="token function">fire</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token function">setInterval</span><span class="token punctuation">(</span>fire<span class="token punctuation">,</span> m<span class="token punctuation">.</span>intervalMs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span><span class="token punctuation">,</span> remaining<span class="token punctuation">)</span><span class="token punctuation">;</span></code></pre>
+<p>It waits only the time <em>remaining</em> until the next due fire, then settles into a steady interval. If a
+mission is overdue (you closed the app over lunch), <code>remaining</code> is <code>0</code> and it fires right away on the
+next launch. The cadence resumes; it doesn’t reset. And because the renderer can never overwrite the
+scheduler’s <code>lastFiredAt</code> — <code>missions:save</code> merges by id and keeps the newer value — editing a
+mission’s text in the UI won’t accidentally rewind its clock.</p>
+<p>On shutdown, <code>clearMissionTimers()</code> tears down every pending <code>setTimeout</code> and <code>setInterval</code>, so a tick
+can never fire into half-torn-down services during quit. The result is a scheduler that’s boring in the
+best way: it survives restarts, edits, and quits without surprising you.</p>
+<h2 id="good-patterns" tabindex="-1">Good patterns <a class="anchor" href="#good-patterns" aria-hidden="true">#</a></h2>
+<p>A scheduler that fires the same instruction forever rewards a particular style of mission.</p>
+<ul>
+<li><strong>Write idempotent bodies.</strong> Because a mission runs again and again, its instruction should be safe to
+repeat. “Post a standup,” “audit the latest build,” “summarize new issues since the last run” are
+great. “Create the project” is not — it’d duplicate every tick. Phrase the body as a recurring verb,
+not a one-time setup.</li>
+<li><strong>Match cadence to how fast reality changes.</strong> <code>intervalMs</code> is your rhythm. An hourly standup, a
+nightly report, a weekly retro — pick the interval from the underlying state, not from a vague sense
+that “more often is better.”</li>
+<li><strong>Target a coordinator for fan-out work.</strong> Sending a “gather status and assign tasks” mission to
+<a href="https://munderdiffl.in/#how">the orchestrator</a> lets one coordinator decide and delegate, instead of
+blasting an identical instruction at every agent. The orchestrator is built for exactly this routing.</li>
+<li><strong>Pause with <code>enabled</code>, don’t delete.</strong> Flip <code>enabled: false</code> to stop a mission while keeping its
+history and <code>lastFiredAt</code>. You can switch it back on later and the cadence picks up cleanly.</li>
+</ul>
+<h2 id="pitfalls-to-avoid" tabindex="-1">Pitfalls to avoid <a class="anchor" href="#pitfalls-to-avoid" aria-hidden="true">#</a></h2>
+<ul>
+<li><strong>Flooding the hive.</strong> The scheduler will fire as often as you tell it to — restraint is on you. A
+one-minute mission to <code>broadcast</code> will bury every agent’s inbox and burn tokens fast. If agents can’t
+finish before the next tick, the interval is too short.</li>
+<li><strong>Non-idempotent instructions.</strong> A body that assumes it’s running for the first time will create
+duplicates on every fire. Always read a mission body as “what should happen <em>each time</em>.”</li>
+<li><strong>Expecting an interrupt.</strong> A mission is a queued <code>request</code>, not a signal that stops what an agent is
+doing. If the target is mid-task, the mission waits its turn — usually fine, but know it isn’t
+instant.</li>
+<li><strong>Forgetting it’s local-first.</strong> Timers live in the app’s process, so missions only fire while the
+desktop app is open. That’s a deliberate trade for a tool you run on your own machine — and
+<code>lastFiredAt</code> softens it by firing overdue missions on the next launch. If you need firing while the
+laptop is shut, that’s a cloud cron’s job, not this one.</li>
+</ul>
+<h2 id="where-it-fits" tabindex="-1">Where it fits <a class="anchor" href="#where-it-fits" aria-hidden="true">#</a></h2>
+<p>Scheduled missions are the alarm clock; the <a href="/blog/claude-code-automation-while-you-sleep/">autonomous
+loop</a> is the engine that keeps an agent running until
+its queue is empty; the <a href="/blog/coordinating-ai-coding-agents/">message router</a> is the nervous system
+that delivers each tick. Put them together and a hive becomes genuinely self-driving on the recurring
+work: it wakes up on schedule, routes the task through <a href="/blog/how-the-god-orchestrator-works/">the orchestrator</a>,
+runs it to completion, and escalates to you only when a decision is genuinely yours to make.</p>
+<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
+<p><strong>What is a scheduled mission?</strong> A recurring instruction the harness fires on a fixed interval. Each
+tick it sends a <code>request</code> message to a target agent (or the whole hive via <code>broadcast</code>), so work
+happens on a cadence with no prompt from you.</p>
+<p><strong>How is it different from an autonomous loop?</strong> The loop keeps a single agent working until its queue
+is empty; the schedule refills that queue on a timer. The loop is the engine, the mission is the alarm
+clock — they’re complementary, not competing.</p>
+<p><strong>Do missions fire when the app is closed?</strong> No — the timers run inside the desktop app’s process, so
+it’s local-first, not a cloud cron. But each mission records <code>lastFiredAt</code>, so an overdue mission fires
+immediately on the next launch and the cadence resumes instead of resetting.</p>
+<p><strong>How do I stop a mission without losing it?</strong> Set <code>enabled: false</code>. It stays in your config with its
+history intact, and you can re-enable it later without rewinding the clock.</p>
+<hr>
+<p>Munder Difflin runs exactly this: a local hive of Claude Code agents that picks up recurring work on a
+schedule, routes it through <a href="https://munderdiffl.in/#how">a GOD orchestrator</a>, and pings you only for
+the calls that matter. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to set your first
+mission and watch the floor wake itself up; 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 a scheduled mission in a multi-agent harness?</p>
+ <p class="a">A scheduled mission is a recurring instruction the harness fires on a fixed interval. Each tick it sends a request message to a target agent — a specific one or the whole hive — so work happens on a cadence without anyone typing a prompt. Think cron, but the job is an agent task.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How is a scheduled mission different from an autonomous loop?</p>
+ <p class="a">An autonomous loop keeps one agent going until its queue is empty. A scheduled mission refills that queue on a timer. The loop is the engine; the schedule is the alarm clock. Together they let a hive pick up fresh, recurring work on its own and then run each piece to completion.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Do scheduled missions run when the app is closed?</p>
+ <p class="a">No. The timers live in the desktop app&#39;s process, so missions only fire while it&#39;s open — this is local-first, not a cloud cron. But each mission remembers when it last fired, so on the next launch an overdue mission fires right away and the cadence resumes instead of resetting.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/autonomous/">Autonomous</a><a class="tag" href="/blog/tags/hive/">Hive</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#what-a-mission-actually-is">What a mission actually is</a></li><li class="lvl-2"><a href="#how-the-scheduler-fires">How the scheduler fires</a></li><li class="lvl-2"><a href="#why-lastfiredat-matters">Why lastFiredAt matters</a></li><li class="lvl-2"><a href="#good-patterns">Good patterns</a></li><li class="lvl-2"><a href="#pitfalls-to-avoid">Pitfalls to avoid</a></li><li class="lvl-2"><a href="#where-it-fits">Where it fits</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/keep-agent-semantic-memory-clean/"><span class="k">Newer →</span><span class="t">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;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/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&#39;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&#39;t Slow You Down">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">
+ <span>ORCHESTRATION</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-05-30">May 30, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/semantic-memory-for-ai-agents/index.html b/docs/blog/semantic-memory-for-ai-agents/index.html
index c6b65263..2094708d 100644
--- a/docs/blog/semantic-memory-for-ai-agents/index.html
+++ b/docs/blog/semantic-memory-for-ai-agents/index.html
@@ -303,38 +303,56 @@ sticks; it’s free and open source.</p>
<h2>Related in Memory</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-27">May 27, 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/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
- <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
+ <h3><a href="/blog/how-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
<div class="foot">
<span class="tag kind">Memory</span>
- <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">Read →</a>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-memory" href="/blog/markdown-first-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-05-27">May 27, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>3 min</span>
</div>
- <h3><a href="/blog/markdown-first-agent-memory/">Why We Built Agent Memory Markdown-First</a></h3>
- <p class="dek">Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.</p>
+ <h3><a href="/blog/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
+ <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
<div class="foot">
<span class="tag kind">Memory</span>
- <a class="more" href="/blog/markdown-first-agent-memory/" aria-label="Read: Why We Built Agent Memory Markdown-First">Read →</a>
+ <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/tags/aeo/index.html b/docs/blog/tags/aeo/index.html
new file mode 100644
index 00000000..a5c0a4a9
--- /dev/null
+++ b/docs/blog/tags/aeo/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>AEO — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged AEO." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/aeo/" />
+
+<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="AEO — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged AEO." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/aeo/" />
+<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="AEO — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged AEO." />
+<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>#AEO</h1>
+ <p class="lead">1 post tagged <strong>AEO</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/agentic-ai/index.html b/docs/blog/tags/agentic-ai/index.html
new file mode 100644
index 00000000..b20e3f90
--- /dev/null
+++ b/docs/blog/tags/agentic-ai/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>Agentic AI — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Agentic AI." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/agentic-ai/" />
+
+<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="Agentic AI — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Agentic AI." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/agentic-ai/" />
+<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="Agentic AI — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Agentic AI." />
+<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>#Agentic AI</h1>
+ <p class="lead">1 post tagged <strong>Agentic AI</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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>
+ </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/whats-new-in-agentic-ai-june-2026/">What&#39;s New in Agentic AI: A June 2026 Field Guide</a></h3>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-label="Read: What&#39;s New in Agentic AI: A June 2026 Field Guide">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/automation/index.html b/docs/blog/tags/automation/index.html
index c6beb75e..79c78238 100644
--- a/docs/blog/tags/automation/index.html
+++ b/docs/blog/tags/automation/index.html
@@ -58,7 +58,7 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Automation</h1>
- <p class="lead">4 posts tagged <strong>Automation</strong>.</p>
+ <p class="lead">5 posts tagged <strong>Automation</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
@@ -98,6 +98,24 @@
</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&#39;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-internals" href="/blog/claude-code-hooks-explained/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
diff --git a/docs/blog/tags/autonomous/index.html b/docs/blog/tags/autonomous/index.html
index d8c9e692..b1e46998 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">1 post tagged <strong>Autonomous</strong>.</p>
+ <p class="lead">2 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-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&#39;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>
</div>
</section>
diff --git a/docs/blog/tags/claude-code/index.html b/docs/blog/tags/claude-code/index.html
index 40488056..7ba09234 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">25 posts tagged <strong>Claude Code</strong>.</p>
+ <p class="lead">29 posts tagged <strong>Claude Code</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
@@ -98,6 +98,24 @@
</div>
</div>
</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/can-claude-code-agents-talk-to-each-other/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </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-guides" href="/blog/claude-code-automation-while-you-sleep/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
@@ -170,6 +188,60 @@
</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>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">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>
+ </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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">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.html
index 5596d286..df3a76c3 100644
--- a/docs/blog/tags/concepts/index.html
+++ b/docs/blog/tags/concepts/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Concepts</h1>
- <p class="lead">4 posts tagged <strong>Concepts</strong>.</p>
+ <p class="lead">6 posts tagged <strong>Concepts</strong>.</p>
</header>
<section class="wrap">
<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/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
diff --git a/docs/blog/tags/context-engineering/index.html b/docs/blog/tags/context-engineering/index.html
new file mode 100644
index 00000000..c505b8a6
--- /dev/null
+++ b/docs/blog/tags/context-engineering/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>Context Engineering — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Context Engineering." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/context-engineering/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Context Engineering — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Context Engineering." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/context-engineering/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Context Engineering — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Context Engineering." />
+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
+
+<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/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>#Context Engineering</h1>
+ <p class="lead">1 post tagged <strong>Context Engineering</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/cost/index.html b/docs/blog/tags/cost/index.html
new file mode 100644
index 00000000..45c98e7f
--- /dev/null
+++ b/docs/blog/tags/cost/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>Cost — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Cost." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/cost/" />
+
+<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="Cost — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Cost." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/cost/" />
+<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="Cost — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Cost." />
+<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>#Cost</h1>
+ <p class="lead">1 post tagged <strong>Cost</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/devrel/index.html b/docs/blog/tags/devrel/index.html
new file mode 100644
index 00000000..0d7c5da9
--- /dev/null
+++ b/docs/blog/tags/devrel/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>DevRel — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged DevRel." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/devrel/" />
+
+<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="DevRel — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged DevRel." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/devrel/" />
+<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="DevRel — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged DevRel." />
+<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>#DevRel</h1>
+ <p class="lead">1 post tagged <strong>DevRel</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/getting-started/index.html b/docs/blog/tags/getting-started/index.html
index 90819170..111f098a 100644
--- a/docs/blog/tags/getting-started/index.html
+++ b/docs/blog/tags/getting-started/index.html
@@ -58,7 +58,7 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Getting Started</h1>
- <p class="lead">6 posts tagged <strong>Getting Started</strong>.</p>
+ <p class="lead">7 posts tagged <strong>Getting Started</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/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/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
diff --git a/docs/blog/tags/hive/index.html b/docs/blog/tags/hive/index.html
new file mode 100644
index 00000000..4d668a29
--- /dev/null
+++ b/docs/blog/tags/hive/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>Hive — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Hive." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/hive/" />
+
+<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="Hive — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Hive." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/hive/" />
+<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="Hive — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Hive." />
+<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>#Hive</h1>
+ <p class="lead">1 post tagged <strong>Hive</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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&#39;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>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/industry/index.html b/docs/blog/tags/industry/index.html
new file mode 100644
index 00000000..8959bbf7
--- /dev/null
+++ b/docs/blog/tags/industry/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>Industry — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Industry." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/industry/" />
+
+<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="Industry — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Industry." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/industry/" />
+<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="Industry — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Industry." />
+<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>#Industry</h1>
+ <p class="lead">1 post tagged <strong>Industry</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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>
+ </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/whats-new-in-agentic-ai-june-2026/">What&#39;s New in Agentic AI: A June 2026 Field Guide</a></h3>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-label="Read: What&#39;s New in Agentic AI: A June 2026 Field Guide">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/memory/index.html b/docs/blog/tags/memory/index.html
index 126cd91c..104c945c 100644
--- a/docs/blog/tags/memory/index.html
+++ b/docs/blog/tags/memory/index.html
@@ -58,11 +58,65 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Memory</h1>
- <p class="lead">4 posts tagged <strong>Memory</strong>.</p>
+ <p class="lead">7 posts tagged <strong>Memory</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<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>
+<article class="card">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">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>
+ </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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-comparisons" href="/blog/crystal-claude-code-alternative/" aria-hidden="true" tabindex="-1">
<span>COMPARISONS</span>
</a>
diff --git a/docs/blog/tags/mempalace/index.html b/docs/blog/tags/mempalace/index.html
index dfbdd617..10c3cf15 100644
--- a/docs/blog/tags/mempalace/index.html
+++ b/docs/blog/tags/mempalace/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#MemPalace</h1>
- <p class="lead">3 posts tagged <strong>MemPalace</strong>.</p>
+ <p class="lead">5 posts tagged <strong>MemPalace</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">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>
+ </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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
diff --git a/docs/blog/tags/model-routing/index.html b/docs/blog/tags/model-routing/index.html
new file mode 100644
index 00000000..2990642a
--- /dev/null
+++ b/docs/blog/tags/model-routing/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>Model Routing — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Model Routing." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/model-routing/" />
+
+<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="Model Routing — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Model Routing." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/model-routing/" />
+<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="Model Routing — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Model Routing." />
+<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>#Model Routing</h1>
+ <p class="lead">1 post tagged <strong>Model Routing</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/multi-agent/index.html b/docs/blog/tags/multi-agent/index.html
index acf8bd8f..7b9d57bb 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">29 posts tagged <strong>Multi-Agent</strong>.</p>
+ <p class="lead">35 posts tagged <strong>Multi-Agent</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
@@ -98,6 +98,24 @@
</div>
</div>
</article>
+<article class="card">
+ <a class="thumb t-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-orchestration" href="/blog/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
@@ -134,6 +152,24 @@
</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>
<article class="card">
<a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
@@ -152,6 +188,78 @@
</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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">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>
+ </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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">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>
+ </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/whats-new-in-agentic-ai-june-2026/">What&#39;s New in Agentic AI: A June 2026 Field Guide</a></h3>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-label="Read: What&#39;s New in Agentic AI: A June 2026 Field Guide">Read →</a>
+ </div>
+ </div>
+</article>
<article class="card">
<a class="thumb t-comparisons" href="/blog/claude-squad-alternative/" aria-hidden="true" tabindex="-1">
<span>COMPARISONS</span>
diff --git a/docs/blog/tags/orchestration/index.html b/docs/blog/tags/orchestration/index.html
index 1e164d07..719a7823 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">8 posts tagged <strong>Orchestration</strong>.</p>
+ <p class="lead">10 posts tagged <strong>Orchestration</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
@@ -98,6 +98,42 @@
</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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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-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&#39;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-comparisons" href="/blog/conductor-claude-code-alternative/" aria-hidden="true" tabindex="-1">
<span>COMPARISONS</span>
diff --git a/docs/blog/tags/protocols/index.html b/docs/blog/tags/protocols/index.html
new file mode 100644
index 00000000..902b4d05
--- /dev/null
+++ b/docs/blog/tags/protocols/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>Protocols — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Protocols." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/protocols/" />
+
+<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="Protocols — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Protocols." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/protocols/" />
+<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="Protocols — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Protocols." />
+<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>#Protocols</h1>
+ <p class="lead">1 post tagged <strong>Protocols</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <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>
+ </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/whats-new-in-agentic-ai-june-2026/">What&#39;s New in Agentic AI: A June 2026 Field Guide</a></h3>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-label="Read: What&#39;s New in Agentic AI: A June 2026 Field Guide">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/seo/index.html b/docs/blog/tags/seo/index.html
new file mode 100644
index 00000000..576614f0
--- /dev/null
+++ b/docs/blog/tags/seo/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>SEO — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged SEO." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/seo/" />
+
+<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="SEO — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged SEO." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/seo/" />
+<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="SEO — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged SEO." />
+<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>#SEO</h1>
+ <p class="lead">1 post tagged <strong>SEO</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/topics/comparisons/index.html b/docs/blog/topics/comparisons/index.html
index ae821960..52c73534 100644
--- a/docs/blog/topics/comparisons/index.html
+++ b/docs/blog/topics/comparisons/index.html
@@ -68,17 +68,17 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.html
index 7455828d..6857d068 100644
--- a/docs/blog/topics/concepts/index.html
+++ b/docs/blog/topics/concepts/index.html
@@ -63,22 +63,22 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>concepts</h1>
- <p class="lead">4 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/internals/">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</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/concepts/" aria-current="page">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
@@ -90,6 +90,60 @@
<section class="wrap">
<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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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/what-is-aeo-for-dev-tools/" 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>
+ </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>
+ <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>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
diff --git a/docs/blog/topics/guides/index.html b/docs/blog/topics/guides/index.html
index 4796b95f..4b66e64a 100644
--- a/docs/blog/topics/guides/index.html
+++ b/docs/blog/topics/guides/index.html
@@ -63,22 +63,22 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>guides</h1>
- <p class="lead">8 posts in this cluster.</p>
+ <p class="lead">10 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/internals/">internals<span class="ct">10</span></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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
@@ -125,6 +125,24 @@
</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>
<article class="card">
<a class="thumb t-guides" href="/blog/debugging-multi-agent-systems/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
@@ -143,6 +161,24 @@
</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>
+ </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/whats-new-in-agentic-ai-june-2026/">What&#39;s New in Agentic AI: A June 2026 Field Guide</a></h3>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</p>
+ <div class="foot">
+ <span class="tag kind">Guides</span>
+ <a class="more" href="/blog/whats-new-in-agentic-ai-june-2026/" aria-label="Read: What&#39;s New in Agentic AI: A June 2026 Field Guide">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/topics/index.html b/docs/blog/topics/index.html
index 34e9b6b3..06a80087 100644
--- a/docs/blog/topics/index.html
+++ b/docs/blog/topics/index.html
@@ -66,20 +66,20 @@
<section class="wrap">
<div class="post-grid">
- <a class="card" href="/blog/topics/internals/" style="text-decoration:none">
- <span class="thumb t-internals" aria-hidden="true">INTERNALS</span>
+ <a class="card" href="/blog/topics/guides/" style="text-decoration:none">
+ <span class="thumb t-guides" aria-hidden="true">GUIDES</span>
<div class="body">
- <h3 style="color:var(--ink)">internals</h3>
+ <h3 style="color:var(--ink)">guides</h3>
<p class="dek">10 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
- <a class="card" href="/blog/topics/guides/" style="text-decoration:none">
- <span class="thumb t-guides" aria-hidden="true">GUIDES</span>
+ <a class="card" href="/blog/topics/internals/" style="text-decoration:none">
+ <span class="thumb t-internals" aria-hidden="true">INTERNALS</span>
<div class="body">
- <h3 style="color:var(--ink)">guides</h3>
- <p class="dek">8 posts.</p>
+ <h3 style="color:var(--ink)">internals</h3>
+ <p class="dek">10 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -93,20 +93,20 @@
</div>
</a>
- <a class="card" href="/blog/topics/orchestration/" style="text-decoration:none">
- <span class="thumb t-orchestration" aria-hidden="true">ORCHESTRATION</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)">orchestration</h3>
- <p class="dek">5 posts.</p>
+ <h3 style="color:var(--ink)">concepts</h3>
+ <p class="dek">7 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/orchestration/" style="text-decoration:none">
+ <span class="thumb t-orchestration" aria-hidden="true">ORCHESTRATION</span>
<div class="body">
- <h3 style="color:var(--ink)">concepts</h3>
- <p class="dek">4 posts.</p>
+ <h3 style="color:var(--ink)">orchestration</h3>
+ <p class="dek">6 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -115,7 +115,7 @@
<span class="thumb t-memory" aria-hidden="true">MEMORY</span>
<div class="body">
<h3 style="color:var(--ink)">memory</h3>
- <p class="dek">3 posts.</p>
+ <p class="dek">5 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -144,29 +144,29 @@
<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">29</span></a>
+ <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">35</span></a>
- <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">25</span></a>
+ <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">29</span></a>
<a class="chip" href="/blog/tags/internals/">Internals<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/orchestration/">Orchestration<span class="ct">10</span></a>
- <a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">8</span></a>
+ <a class="chip" href="/blog/tags/guides/">Guides<span class="ct">8</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/getting-started/">Getting Started<span class="ct">6</span></a>
+ <a class="chip" href="/blog/tags/getting-started/">Getting Started<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/tags/memory/">Memory<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/memory/">Memory<span class="ct">4</span></a>
+ <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">6</span></a>
- <a class="chip" href="/blog/tags/automation/">Automation<span class="ct">4</span></a>
+ <a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">5</span></a>
- <a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">3</span></a>
+ <a class="chip" href="/blog/tags/automation/">Automation<span class="ct">5</span></a>
<a class="chip" href="/blog/tags/observability/">Observability<span class="ct">3</span></a>
@@ -190,6 +190,8 @@
<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/subagents/">Subagents<span class="ct">1</span></a>
<a class="chip" href="/blog/tags/markdown/">Markdown<span class="ct">1</span></a>
@@ -230,10 +232,28 @@
<a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">1</span></a>
- <a class="chip" href="/blog/tags/autonomous/">Autonomous<span class="ct">1</span></a>
+ <a class="chip" href="/blog/tags/context-engineering/">Context Engineering<span class="ct">1</span></a>
<a class="chip" href="/blog/tags/debugging/">Debugging<span class="ct">1</span></a>
+ <a class="chip" href="/blog/tags/model-routing/">Model Routing<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/cost/">Cost<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/hive/">Hive<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/aeo/">AEO<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/seo/">SEO<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/devrel/">DevRel<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/agentic-ai/">Agentic AI<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/industry/">Industry<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/protocols/">Protocols<span class="ct">1</span></a>
+
<a class="chip" href="/blog/tags/tutorial/">Tutorial<span class="ct">1</span></a>
</div>
diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.html
index 6b00c679..cf997bab 100644
--- a/docs/blog/topics/internals/index.html
+++ b/docs/blog/topics/internals/index.html
@@ -68,17 +68,17 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.html
index 90028ded..d66de363 100644
--- a/docs/blog/topics/memory/index.html
+++ b/docs/blog/topics/memory/index.html
@@ -63,22 +63,22 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>memory</h1>
- <p class="lead">3 posts in this cluster.</p>
+ <p class="lead">5 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/" aria-current="page">memory<span class="ct">3</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>
@@ -90,6 +90,42 @@
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1">
+ <span>MEMORY</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-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
+ <p class="dek">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.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">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>
+ </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/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
+ <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
+ <div class="foot">
+ <span class="tag kind">Memory</span>
+ <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1">
<span>MEMORY</span>
</a>
diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.html
index 581e656a..2ff83417 100644
--- a/docs/blog/topics/orchestration/index.html
+++ b/docs/blog/topics/orchestration/index.html
@@ -63,22 +63,22 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>orchestration</h1>
- <p class="lead">5 posts in this cluster.</p>
+ <p class="lead">6 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/internals/">internals<span class="ct">10</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">8</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/orchestration/" aria-current="page">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</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/memory/">memory<span class="ct">3</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>
@@ -107,6 +107,24 @@
</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&#39;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>
diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.html
index 6d7a210c..4f078320 100644
--- a/docs/blog/topics/story/index.html
+++ b/docs/blog/topics/story/index.html
@@ -68,17 +68,17 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.html
index f147700b..23513399 100644
--- a/docs/blog/topics/use-cases/index.html
+++ b/docs/blog/topics/use-cases/index.html
@@ -68,17 +68,17 @@
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">10</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">8</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/orchestration/">orchestration<span class="ct">5</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">7</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">4</span></a>
+ <a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">6</span></a>
- <a class="chip" href="/blog/topics/memory/">memory<span class="ct">3</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>
diff --git a/docs/blog/what-are-claude-code-agents/index.html b/docs/blog/what-are-claude-code-agents/index.html
index 2ab6afe4..cc933065 100644
--- a/docs/blog/what-are-claude-code-agents/index.html
+++ b/docs/blog/what-are-claude-code-agents/index.html
@@ -247,56 +247,56 @@ into an office; it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
+ <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-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>6 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/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/ai-agent-glossary/" aria-label="Read: The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent">Read →</a>
+ <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/munder-difflin-faq/" aria-hidden="true" tabindex="-1">
+ <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-02">Jun 2, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>1 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/munder-difflin-faq/">Munder Difflin FAQ: Everything People Ask</a></h3>
- <p class="dek">Answers to the top Munder Difflin questions — what it is, is it free, does it run locally, which platforms, and how it differs from many terminals.</p>
+ <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
+ <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/munder-difflin-faq/" aria-label="Read: Munder Difflin FAQ: Everything People Ask">Read →</a>
+ <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/what-is-a-multi-agent-harness/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-05-22">May 22, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>2 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/what-is-a-multi-agent-harness/">What Is a Multi-Agent Harness? (Plain-English Guide)</a></h3>
- <p class="dek">A multi-agent harness coordinates several AI coding agents into one team — here&#39;s what that means, and how it differs from a single agent or a framework.</p>
+ <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>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/what-is-a-multi-agent-harness/" aria-label="Read: What Is a Multi-Agent Harness? (Plain-English Guide)">Read →</a>
+ <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>
</div>
</div>
</article>
diff --git a/docs/blog/what-is-a-multi-agent-harness/index.html b/docs/blog/what-is-a-multi-agent-harness/index.html
index e9d89fb1..2f39b639 100644
--- a/docs/blog/what-is-a-multi-agent-harness/index.html
+++ b/docs/blog/what-is-a-multi-agent-harness/index.html
@@ -234,56 +234,56 @@ want to watch a coordinated team of agents work an office floor,
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
+ <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-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>6 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/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/ai-agent-glossary/" aria-label="Read: The AI Coding Agent Glossary: Harness, Orchestrator, Hive, Subagent">Read →</a>
+ <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/munder-difflin-faq/" aria-hidden="true" tabindex="-1">
+ <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-02">Jun 2, 2026</time>
+ <time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>1 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/munder-difflin-faq/">Munder Difflin FAQ: Everything People Ask</a></h3>
- <p class="dek">Answers to the top Munder Difflin questions — what it is, is it free, does it run locally, which platforms, and how it differs from many terminals.</p>
+ <h3><a href="/blog/do-more-with-less-model-routing/">Do More With Less: Smart Model Routing Across Agents</a></h3>
+ <p class="dek">Why a hive of agents shouldn&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/munder-difflin-faq/" aria-label="Read: Munder Difflin FAQ: Everything People Ask">Read →</a>
+ <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/what-are-claude-code-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/what-is-aeo-for-dev-tools/" 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>7 min</span>
</div>
- <h3><a href="/blog/what-are-claude-code-agents/">What Are Claude Code Agents? And How to Use Many at Once</a></h3>
- <p class="dek">Claude Code agents explained in plain English — what an agent actually is, how subagents differ, and the leap from one agent to a coordinated team.</p>
+ <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>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/what-are-claude-code-agents/" aria-label="Read: What Are Claude Code Agents? And How to Use Many at Once">Read →</a>
+ <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>
</div>
</div>
</article>
diff --git a/docs/blog/what-is-aeo-for-dev-tools/index.html b/docs/blog/what-is-aeo-for-dev-tools/index.html
new file mode 100644
index 00000000..8a618438
--- /dev/null
+++ b/docs/blog/what-is-aeo-for-dev-tools/index.html
@@ -0,0 +1,466 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>AEO for Dev Tools: Getting Cited by ChatGPT and Claude — Munder Difflin Blog</title>
+<meta name="description" content="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." />
+<link rel="canonical" href="https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/" />
+
+<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="AEO for Dev Tools: Getting Cited by ChatGPT and Claude — Munder Difflin Blog" />
+<meta property="og:description" content="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." />
+<meta property="og:url" content="https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/" />
+<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="AEO" />
+<meta property="article:tag" content="SEO" />
+<meta property="article:tag" content="DevRel" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="AEO for Dev Tools: Getting Cited by ChatGPT and Claude — Munder Difflin Blog" />
+<meta name="twitter:description" content="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." />
+<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": "AEO for Dev Tools: Getting Cited by ChatGPT and Claude",
+ "description": "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.",
+ "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/what-is-aeo-for-dev-tools/" },
+ "keywords": "answer engine optimization, aeo, generative engine optimization, ai search",
+ "articleSection": "Concepts",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/"
+}
+</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": "AEO for Dev Tools: Getting Cited by ChatGPT and Claude", "item": "https://munderdiffl.in/blog/what-is-aeo-for-dev-tools/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What is Answer Engine Optimization (AEO)?", "acceptedAnswer": { "@type": "Answer", "text": "AEO is optimizing your content so AI answer engines like ChatGPT, Claude, and Perplexity cite it when they answer a user's question — the AI-era successor to ranking in Google's blue links." } },
+ { "@type": "Question", "name": "How is AEO different from SEO?", "acceptedAnswer": { "@type": "Answer", "text": "SEO optimizes a page to rank so a human clicks it; AEO optimizes content to be the source an AI quotes in its synthesized answer, often with no click at all." } },
+ { "@type": "Question", "name": "How do I get my dev tool cited by ChatGPT and Claude?", "acceptedAnswer": { "@type": "Answer", "text": "Answer the question in the first sentence, mark it up with FAQPage and SoftwareApplication JSON-LD, let AI crawlers like GPTBot and ClaudeBot into your robots.txt, and be the clearest canonical source on your topic." } },
+ { "@type": "Question", "name": "Should I block AI crawlers in robots.txt?", "acceptedAnswer": { "@type": "Answer", "text": "If you want citations, no — blocking GPTBot, ClaudeBot, or Google-Extended removes you from the answers; only block them if avoiding training use matters more than being discovered." } }
+
+ ]
+}
+</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>AEO for Dev Tools: Getting Cited by ChatGPT and Claude</h1>
+ <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>
+ <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>7 min read</span>
+ <span class="tag kind">Concepts</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Answer Engine Optimization (AEO)</strong>
+is making your content the thing an AI <em>quotes</em>, not just a page a human clicks. For a developer
+tool whose users increasingly ask ChatGPT, Claude, and Perplexity "what should I use for X?", being
+cited in that answer is the new front page. The playbook: <strong>answer first</strong>,
+<strong>mark it up</strong> with JSON-LD, <strong>let the AI crawlers in</strong>, and <strong>be the
+clearest source</strong> on your topic. Here's exactly how we do it for Munder Difflin — copy it.</p></div>
+<p>A growing share of “how do I…” and “what’s the best tool for…” questions never reach a search box
+anymore. They go to an answer engine — ChatGPT, Claude, Perplexity, Google’s AI Overviews — which
+reads the web for you and hands back a synthesized answer with a few citations. If your
+<a href="/blog/best-claude-code-multi-agent-tools/">dev tool</a> isn’t in those citations, you’re invisible to
+the exact developers evaluating tools like yours.</p>
+<p>This is the discipline of <strong>Answer Engine Optimization (AEO)</strong> — sometimes called Generative Engine
+Optimization (GEO). It overlaps with SEO but optimizes for a different outcome: not a ranked link, but
+a <em>quoted sentence</em>. This post is the playbook we actually run, with the real config.</p>
+<h2 id="aeo-vs-seo-a-click-vs-a-quote" tabindex="-1">AEO vs SEO: a click vs a quote <a class="anchor" href="#aeo-vs-seo-a-click-vs-a-quote" aria-hidden="true">#</a></h2>
+<p><strong>SEO optimizes a page to rank so a human clicks it. AEO optimizes content to be the source an AI
+quotes in its answer — often with no click at all.</strong> They share foundations (crawlable, fast,
+well-structured pages) but diverge on intent:</p>
+<table>
+<thead>
+<tr>
+<th></th>
+<th>SEO</th>
+<th>AEO</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><strong>Goal</strong></td>
+<td>Rank → earn the click</td>
+<td>Be the cited source in the answer</td>
+</tr>
+<tr>
+<td><strong>Unit that wins</strong></td>
+<td>The page</td>
+<td>The quotable sentence</td>
+</tr>
+<tr>
+<td><strong>Reader</strong></td>
+<td>A human skimming results</td>
+<td>An LLM extracting a claim</td>
+</tr>
+<tr>
+<td><strong>Best content shape</strong></td>
+<td>Keyword-targeted long-form</td>
+<td>Direct answers + structured facts</td>
+</tr>
+<tr>
+<td><strong>Win condition</strong></td>
+<td>Position 1–3</td>
+<td>“According to Munder Difflin…”</td>
+</tr>
+</tbody>
+</table>
+<p>The good news: you don’t choose between them. AEO is mostly SEO done with a tighter discipline —
+clearer answers, stronger structure, honest facts. A page that an LLM can confidently quote is also a
+page Google’s AI Overviews and traditional results reward.</p>
+<h2 id="why-dev-tools-should-care-more-than-most" tabindex="-1">Why dev tools should care more than most <a class="anchor" href="#why-dev-tools-should-care-more-than-most" aria-hidden="true">#</a></h2>
+<p>Developer tools sit at the perfect intersection for AEO:</p>
+<ul>
+<li><strong>Your audience already asks LLMs.</strong> “Best way to run multiple Claude Code agents?” is a question a
+developer types into Claude before they type it into Google.</li>
+<li><strong>The questions are answerable.</strong> Tool comparisons, definitions, and how-tos have crisp, factual
+answers — exactly what answer engines like to cite.</li>
+<li><strong>You’re awareness-stage.</strong> A new or open-source tool has no brand gravity yet. Getting named in an
+AI’s answer <em>is</em> the introduction.</li>
+</ul>
+<p>That’s why, for an open-source project like <a href="/blog/why-we-built-munder-difflin/">Munder Difflin</a>, we
+treat “get cited by the answer engines” as a first-class distribution channel, not an afterthought.</p>
+<h2 id="the-aeo-playbook-what-we-actually-do" tabindex="-1">The AEO playbook (what we actually do) <a class="anchor" href="#the-aeo-playbook-what-we-actually-do" aria-hidden="true">#</a></h2>
+<h3 id="1-answer-the-question-in-the-first-sentence" tabindex="-1">1. Answer the question in the first sentence <a class="anchor" href="#1-answer-the-question-in-the-first-sentence" aria-hidden="true">#</a></h3>
+<p>LLMs extract claims, and the easiest claim to extract is a direct, self-contained sentence near the
+top. Lead with the answer, then explain — the inverted pyramid, not a slow build.</p>
+<p>So instead of <em>“There are many ways to think about agent coordination…”</em>, write: <strong>“A multi-agent
+harness is software that wraps the agents you already run and coordinates them with memory, messaging,
+and orchestration.”</strong> That sentence can be lifted verbatim into an answer with your name attached.</p>
+<p>Every post we publish opens with a <strong>TL;DR</strong> and uses <strong>bold, quotable one-liners</strong> under each
+heading — see the <a href="/blog/ai-agent-glossary/">AI coding agent glossary</a>, which is one quotable
+definition after another. That structure isn’t decoration; it’s the extraction surface.</p>
+<h3 id="2-mark-it-up-with-structured-data-json-ld" tabindex="-1">2. Mark it up with structured data (JSON-LD) <a class="anchor" href="#2-mark-it-up-with-structured-data-json-ld" aria-hidden="true">#</a></h3>
+<p>Structured data tells a machine <em>what the page is</em> without it having to infer. Three schemas do most
+of the AEO work for a dev tool:</p>
+<ul>
+<li><strong><code>SoftwareApplication</code></strong> on your homepage — name, description, operating systems, price, license,
+download URL. This is how an engine knows you’re a free, cross-platform tool.</li>
+<li><strong><code>FAQPage</code></strong> on pages with a Q&amp;A block — each question/answer becomes individually quotable and is
+eligible for “People also ask” surfaces.</li>
+<li><strong><code>BlogPosting</code> + <code>BreadcrumbList</code></strong> on articles — author, dates, and section, so the answer engine
+can attribute and date your claim.</li>
+</ul>
+<p>Here’s the shape of the FAQ markup we emit on this very post:</p>
+<pre class="language-json"><code class="language-json"><span class="token punctuation">{</span>
+ <span class="token property">"@context"</span><span class="token operator">:</span> <span class="token string">"https://schema.org"</span><span class="token punctuation">,</span>
+ <span class="token property">"@type"</span><span class="token operator">:</span> <span class="token string">"FAQPage"</span><span class="token punctuation">,</span>
+ <span class="token property">"mainEntity"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token punctuation">{</span>
+ <span class="token property">"@type"</span><span class="token operator">:</span> <span class="token string">"Question"</span><span class="token punctuation">,</span>
+ <span class="token property">"name"</span><span class="token operator">:</span> <span class="token string">"What is Answer Engine Optimization (AEO)?"</span><span class="token punctuation">,</span>
+ <span class="token property">"acceptedAnswer"</span><span class="token operator">:</span> <span class="token punctuation">{</span>
+ <span class="token property">"@type"</span><span class="token operator">:</span> <span class="token string">"Answer"</span><span class="token punctuation">,</span>
+ <span class="token property">"text"</span><span class="token operator">:</span> <span class="token string">"AEO is optimizing your content so AI answer engines like ChatGPT, Claude, and Perplexity cite it when they answer a user's question."</span>
+ <span class="token punctuation">}</span>
+ <span class="token punctuation">}</span><span class="token punctuation">]</span>
+<span class="token punctuation">}</span></code></pre>
+<blockquote>
+<p><strong>Don’t fabricate trust signals.</strong> It’s tempting to add <code>aggregateRating</code> to your
+<code>SoftwareApplication</code> markup. Don’t — inventing review data is self-serving structured-data abuse
+that Google penalizes, and answer engines increasingly cross-check. Only mark up facts that are true.</p>
+</blockquote>
+<h3 id="3-let-the-ai-crawlers-in" tabindex="-1">3. Let the AI crawlers in <a class="anchor" href="#3-let-the-ai-crawlers-in" aria-hidden="true">#</a></h3>
+<p>This is the step most teams miss: an answer engine can’t cite a page it was never allowed to read.
+Many sites quietly block AI crawlers — and then wonder why they’re never cited. If you want the
+citations, <strong>explicitly allow</strong> the answer-engine bots in <code>robots.txt</code>. This is the exact block we
+ship:</p>
+<pre><code>User-agent: *
+Allow: /
+
+# AI answer engines — explicitly welcome. We WANT to be cited.
+User-agent: GPTBot
+Allow: /
+User-agent: OAI-SearchBot
+Allow: /
+User-agent: ChatGPT-User
+Allow: /
+User-agent: PerplexityBot
+Allow: /
+User-agent: ClaudeBot
+Allow: /
+User-agent: Google-Extended
+Allow: /
+
+Sitemap: https://munderdiffl.in/sitemap.xml
+</code></pre>
+<p>There’s a real tradeoff here, and you should decide it deliberately. Allowing <code>GPTBot</code>,
+<code>Google-Extended</code>, and <code>ClaudeBot</code> also permits training use of your content. For an awareness-stage
+open-source tool, being discoverable is worth far more than withholding text — so we allow them all.
+If avoiding training matters more to you than citations, flip those agents to <code>Disallow: /</code> and accept
+that you’re opting out of the answers too. <strong>You can’t have the citations without the crawl.</strong></p>
+<h3 id="4-write-faq-blocks-with-one-sentence-answers" tabindex="-1">4. Write FAQ blocks with one-sentence answers <a class="anchor" href="#4-write-faq-blocks-with-one-sentence-answers" aria-hidden="true">#</a></h3>
+<p>A FAQ section does double duty: it’s genuinely useful to readers, and it’s the most quotable format
+that exists. Each answer should be a single, complete sentence that stands on its own without the
+question. Our <a href="/blog/munder-difflin-faq/">Munder Difflin FAQ</a> is built this way — “Is it free? Yes,
+it’s free and open source under the MIT license.” is a sentence an engine can quote whole.</p>
+<h3 id="5-be-the-canonical-source-on-your-topic" tabindex="-1">5. Be the canonical source on your topic <a class="anchor" href="#5-be-the-canonical-source-on-your-topic" aria-hidden="true">#</a></h3>
+<p>Answer engines prefer sources that are <em>clear, consistent, and complete</em>. You earn “canonical source”
+status by:</p>
+<ul>
+<li><strong>Defining your terms.</strong> If you coin or popularize a concept (“single-committer pattern,” “GOD
+orchestrator”), define it crisply and link to it everywhere. Be the page that <em>defines</em> the thing.</li>
+<li><strong>Comparison tables.</strong> Engines love structured comparisons because they map directly onto “X vs Y”
+questions. An honest table beats three paragraphs of prose.</li>
+<li><strong>Consistent entity naming.</strong> Use the same product name, the same one-sentence description, and the
+same <code>sameAs</code> links (your GitHub repo) everywhere. Consistency is how an engine resolves “Munder
+Difflin” to one entity instead of fragments.</li>
+</ul>
+<h3 id="6-treat-your-repo-and-freshness-as-ranking-surfaces-honestly" tabindex="-1">6. Treat your repo and freshness as ranking surfaces — honestly <a class="anchor" href="#6-treat-your-repo-and-freshness-as-ranking-surfaces-honestly" aria-hidden="true">#</a></h3>
+<p>For a dev tool, your GitHub repo is a ranking surface too: a keyword-led “About” description, a strong
+README, and topics all feed the same entity. And keep content fresh — but <strong>honestly</strong>. Real
+<code>lastmod</code> dates and genuine updates help; faking freshness by bumping dates on unchanged pages is the
+kind of manipulation that gets discounted. Update when you actually have something new.</p>
+<h2 id="how-to-measure-aeo-when-theres-no-rank-tracker" tabindex="-1">How to measure AEO (when there’s no rank tracker) <a class="anchor" href="#how-to-measure-aeo-when-theres-no-rank-tracker" aria-hidden="true">#</a></h2>
+<p>AEO has no clean “position 3” metric, so measure it directly: <strong>ask the engines.</strong> On a monthly
+cadence, ask ChatGPT, Claude, and Perplexity the exact questions your users would ask — <em>“how do I run
+multiple Claude Code agents?”</em>, <em>“best tool to coordinate AI coding agents?”</em> — and check whether
+you’re named and whether the description matches what you wrote. When you start seeing your own
+sentences come back, the playbook is working. Pair that with a weekly glance at search-console
+impressions for the question-shaped queries.</p>
+<h2 id="the-one-paragraph-version" tabindex="-1">The one-paragraph version <a class="anchor" href="#the-one-paragraph-version" aria-hidden="true">#</a></h2>
+<p><strong>AEO is SEO with a tighter contract: write a sentence worth quoting, prove what the page is with
+structured data, let the AI crawlers read it, and be the clearest source on your topic — then verify
+by asking the engines directly.</strong> None of it is exotic; it’s mostly discipline. And it compounds,
+because the same page that an LLM will confidently cite is the same page a human will trust.</p>
+<p>If you want to see these patterns in a real, open codebase, every post on this blog is built to be
+quotable, and our <a href="/blog/what-is-a-multi-agent-harness/">what is a multi-agent harness</a> explainer is
+the canonical-source pattern in action.</p>
+<hr>
+<p>Munder Difflin is a local, open-source multi-agent harness for Claude Code — and a working example of
+AEO done in public. <a href="/#install">Download Munder Difflin</a> to see it run, or read <a href="/#what">what a multi-agent
+harness actually is</a>. Free and MIT-licensed.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">What is Answer Engine Optimization (AEO)?</p>
+ <p class="a">AEO is optimizing your content so AI answer engines like ChatGPT, Claude, and Perplexity cite it when they answer a user&#39;s question — the AI-era successor to ranking in Google&#39;s blue links.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How is AEO different from SEO?</p>
+ <p class="a">SEO optimizes a page to rank so a human clicks it; AEO optimizes content to be the source an AI quotes in its synthesized answer, often with no click at all.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How do I get my dev tool cited by ChatGPT and Claude?</p>
+ <p class="a">Answer the question in the first sentence, mark it up with FAQPage and SoftwareApplication JSON-LD, let AI crawlers like GPTBot and ClaudeBot into your robots.txt, and be the clearest canonical source on your topic.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Should I block AI crawlers in robots.txt?</p>
+ <p class="a">If you want citations, no — blocking GPTBot, ClaudeBot, or Google-Extended removes you from the answers; only block them if avoiding training use matters more than being discovered.</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/aeo/">AEO</a><a class="tag" href="/blog/tags/seo/">SEO</a><a class="tag" href="/blog/tags/devrel/">DevRel</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="#aeo-vs-seo-a-click-vs-a-quote">AEO vs SEO: a click vs a quote</a></li><li class="lvl-2"><a href="#why-dev-tools-should-care-more-than-most">Why dev tools should care more than most</a></li><li class="lvl-2"><a href="#the-aeo-playbook-what-we-actually-do">The AEO playbook (what we actually do)</a></li><li class="lvl-3"><a href="#1-answer-the-question-in-the-first-sentence">1. Answer the question in the first sentence</a></li><li class="lvl-3"><a href="#2-mark-it-up-with-structured-data-json-ld">2. Mark it up with structured data (JSON-LD)</a></li><li class="lvl-3"><a href="#3-let-the-ai-crawlers-in">3. Let the AI crawlers in</a></li><li class="lvl-3"><a href="#4-write-faq-blocks-with-one-sentence-answers">4. Write FAQ blocks with one-sentence answers</a></li><li class="lvl-3"><a href="#5-be-the-canonical-source-on-your-topic">5. Be the canonical source on your topic</a></li><li class="lvl-3"><a href="#6-treat-your-repo-and-freshness-as-ranking-surfaces-honestly">6. Treat your repo and freshness as ranking surfaces — honestly</a></li><li class="lvl-2"><a href="#how-to-measure-aeo-when-theres-no-rank-tracker">How to measure AEO (when there’s no rank tracker)</a></li><li class="lvl-2"><a href="#the-one-paragraph-version">The one-paragraph version</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <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&#39;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>
+ </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&#39;t all run the biggest model — and how routing the right task to the right model cuts cost and latency without losing quality.</p>
+ <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/ai-agent-glossary/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</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/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>
+ <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>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/whats-new-in-agentic-ai-june-2026/index.html b/docs/blog/whats-new-in-agentic-ai-june-2026/index.html
new file mode 100644
index 00000000..1a5c3339
--- /dev/null
+++ b/docs/blog/whats-new-in-agentic-ai-june-2026/index.html
@@ -0,0 +1,425 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>What&#39;s New in Agentic AI: A June 2026 Field Guide — Munder Difflin Blog</title>
+<meta name="description" content="A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance." />
+<link rel="canonical" href="https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="article" />
+<meta property="og:title" content="What&#39;s New in Agentic AI: A June 2026 Field Guide — Munder Difflin Blog" />
+<meta property="og:description" content="A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance." />
+<meta property="og:url" content="https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/" />
+<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="Agentic AI" />
+<meta property="article:tag" content="Industry" />
+<meta property="article:tag" content="Protocols" />
+<meta property="article:tag" content="Multi-Agent" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="What&#39;s New in Agentic AI: A June 2026 Field Guide — Munder Difflin Blog" />
+<meta name="twitter:description" content="A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance." />
+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
+
+<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "What's New in Agentic AI: A June 2026 Field Guide",
+ "description": "A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.",
+ "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/whats-new-in-agentic-ai-june-2026/" },
+ "keywords": "what's new in agentic ai, agentic ai 2026, ai agent news june 2026, mcp a2a agent protocols, claude opus 4.8 agents",
+ "articleSection": "Guides",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/"
+}
+</script>
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BreadcrumbList",
+ "itemListElement": [
+ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
+ { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
+ { "@type": "ListItem", "position": 3, "name": "What's New in Agentic AI: A June 2026 Field Guide", "item": "https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What changed in agentic AI in mid-2026?", "acceptedAnswer": { "@type": "Answer", "text": "Four things moved at once: frontier models got meaningfully better at acting autonomously (Anthropic's Claude Opus 4.8 and its parallel-subagent Dynamic Workflows), agent coordination standardized under the Linux Foundation's Agentic AI Foundation (MCP for tools, A2A for agent-to-agent), agent usage became metered (GitHub Copilot moved to usage-based AI Credits on June 1), and governance matured (Microsoft Agent 365 reached general availability as an agent control plane)." } },
+ { "@type": "Question", "name": "What's the difference between MCP and A2A?", "acceptedAnswer": { "@type": "Answer", "text": "They solve different problems. The Model Context Protocol (MCP) standardizes how a single agent connects to its tools, APIs, and data — agent-to-tool. The Agent2Agent (A2A) protocol standardizes how separate agents discover and talk to each other — agent-to-agent. Both are now stewarded by the Linux Foundation, and most real systems use them together." } },
+ { "@type": "Question", "name": "Do I need a cloud platform to run AI agents in 2026?", "acceptedAnswer": { "@type": "Answer", "text": "No. Alongside the big enterprise launches, 2026 has a strong local-first, open-source current: self-hosted agent frameworks and skill registries that run on your own machine. A local hive like Munder Difflin gives you coordinated multi-agent work — shared memory, messaging, an orchestrator — without sending your code or context to a SaaS." } }
+
+ ]
+}
+</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>What&#39;s New in Agentic AI: A June 2026 Field Guide</h1>
+ <p class="dek">A grounded June 2026 roundup of agentic AI: Claude Opus 4.8, the MCP and A2A protocol layer, usage-based agent billing, and agent governance.</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>By June 2026, agentic AI matured on
+<strong>four fronts at once</strong>: models that <em>act</em> (Anthropic's <strong>Claude Opus 4.8</strong>
+and its parallel-subagent Dynamic Workflows), a hardening <strong>coordination layer</strong> (MCP and A2A
+now under the Linux Foundation), <strong>metered economics</strong> (GitHub Copilot moved to usage-based AI
+Credits on June 1), and <strong>governance</strong> (Microsoft Agent 365 reached general availability as an
+agent control plane). The throughline: agents went from demos to infrastructure — with a quiet
+<strong>local-first, open-source</strong> counter-current keeping that infrastructure something you can run
+yourself.</p></div>
+<p>If you build or run multi-agent systems, the last few weeks have been busy. This is a curated,
+plain-English field guide to what actually shipped — grounded in primary sources, with a note on what
+each item means in practice and how it touches anyone running a local hive of coding agents.</p>
+<blockquote>
+<p><strong>A note on sourcing.</strong> This is a time-bound roundup, accurate to the best of our knowledge as of
+<strong>June 4, 2026</strong>. Every factual claim links to its source — follow them, because this space moves
+weekly and vendors revise details. Where a figure comes from a secondary aggregator rather than the
+primary vendor, we say so. Munder Difflin is our own project; we’ve tried to report the rest straight.</p>
+</blockquote>
+<h2 id="at-a-glance" tabindex="-1">At a glance <a class="anchor" href="#at-a-glance" aria-hidden="true">#</a></h2>
+<table>
+<thead>
+<tr>
+<th>What</th>
+<th>When</th>
+<th>Why it matters</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>Claude Opus 4.8 + Dynamic Workflows</td>
+<td>May 28, 2026</td>
+<td>Frontier coding model tuned for long-horizon, multi-subagent work</td>
+</tr>
+<tr>
+<td>MCP joins the Agentic AI Foundation</td>
+<td>Dec 2025 → 2026</td>
+<td>The agent-to-tool standard is now vendor-neutral and huge</td>
+</tr>
+<tr>
+<td>A2A passes 150+ organizations</td>
+<td>2026 (year one)</td>
+<td>An agent-to-agent standard reaches real adoption</td>
+</tr>
+<tr>
+<td>GitHub Copilot → usage-based AI Credits</td>
+<td>June 1, 2026</td>
+<td>Agent coding became metered, token-by-token</td>
+</tr>
+<tr>
+<td>Microsoft Agent 365 GA</td>
+<td>May 1, 2026</td>
+<td>Enterprise governance and identity for agents goes mainstream</td>
+</tr>
+</tbody>
+</table>
+<h2 id="models-learned-to-act-not-just-answer" tabindex="-1">Models learned to act, not just answer <a class="anchor" href="#models-learned-to-act-not-just-answer" aria-hidden="true">#</a></h2>
+<p>The headline release is <a href="https://www.anthropic.com/claude/opus">Anthropic’s Claude Opus 4.8</a>, out
+<a href="https://techcrunch.com/2026/05/28/anthropic-releases-opus-4-8-with-new-dynamic-workflow-tool/">May 28, 2026 — 41 days after Opus 4.7</a>.
+The interesting part isn’t a benchmark leap; it’s the <em>shape</em> of the gains. Anthropic leaned into
+<strong>agentic reliability</strong>: Opus 4.8 is described as more willing to
+<a href="https://techcrunch.com/2026/05/28/anthropic-releases-opus-4-8-with-new-dynamic-workflow-tool/">flag its own uncertainty and less likely to make unsupported claims</a>,
+and <a href="https://simonwillison.net/2026/May/28/claude-opus-4-8/">Simon Willison’s hands-on writeup</a> calls it
+“a modest but tangible improvement” — exactly the unglamorous kind of progress that matters when an agent
+runs unattended for an hour.</p>
+<p>Shipping alongside it is <strong>Dynamic Workflows</strong>, a research-preview Claude Code feature built to
+<a href="https://techcrunch.com/2026/05/28/anthropic-releases-opus-4-8-with-new-dynamic-workflow-tool/">manage a task across hundreds of parallel subagents</a>,
+so that Claude Code can carry out <em>codebase-scale migrations across hundreds of thousands of lines of
+code from kickoff to merge</em>, with the existing test suite as its bar. That’s the through-line of 2026’s
+model releases: vendors are optimizing for <strong>autonomy and parallelism</strong>, not just single-answer quality.</p>
+<p><strong>What it means in practice:</strong> “one giant model call” is giving way to “many coordinated agents.” If a
+frontier lab is now orchestrating subagents inside its own coding tool, the case for a
+<a href="/#what">multi-agent harness</a> you control — where you can watch and steer that fan-out — gets stronger,
+not weaker. (For the broader tool landscape, see our
+<a href="/blog/best-claude-code-multi-agent-tools/">roundup of multi-agent Claude Code tools</a>.)</p>
+<h2 id="agent-coordination-is-becoming-a-protocol-layer" tabindex="-1">Agent coordination is becoming a protocol layer <a class="anchor" href="#agent-coordination-is-becoming-a-protocol-layer" aria-hidden="true">#</a></h2>
+<p>A year ago, every framework invented its own way for agents to reach tools and each other. That’s
+consolidating fast. In December 2025, Anthropic donated the <strong>Model Context Protocol (MCP)</strong> to the new
+<a href="https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation">Agentic AI Foundation (AAIF), a Linux Foundation directed fund anchored by MCP, Block’s goose, and OpenAI’s AGENTS.md</a>.
+MCP — the standard for <strong>agent-to-tool</strong> connections — has grown enormously; by one industry tally it
+had <a href="https://ai2.work/blog/model-context-protocol-hits-97m-installs-as-linux-foundation-takes-over">crossed roughly 97 million SDK installs by March 2026</a>
+(treat the exact figure as directional — it’s an aggregator’s count, not a vendor disclosure).</p>
+<p>Its complement is the <strong>Agent2Agent (A2A) protocol</strong>, Google-originated and also Linux Foundation–hosted,
+which standardizes <strong>agent-to-agent</strong> discovery and messaging. At its one-year mark A2A reported
+<a href="https://www.linuxfoundation.org/press/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year">more than 150 supporting organizations and integration across Google, Microsoft, and AWS</a>.
+The clean mental model, as <a href="https://www.ibm.com/think/topics/agent2agent-protocol">IBM puts it</a>: <strong>MCP is
+how an agent talks to tools; A2A is how agents talk to each other.</strong></p>
+<p><strong>What it means in practice:</strong> the plumbing a hive needs — tool access and inter-agent messaging — is
+becoming portable and vendor-neutral. Munder Difflin already gives agents
+<a href="/blog/mcp-and-skills-in-a-hive/">MCP tools and skills</a> and direct
+<a href="/blog/coordinating-ai-coding-agents/">agent-to-agent mailboxes</a>; standards mean those patterns aren’t
+bespoke anymore, they’re the industry default.</p>
+<h2 id="the-meter-is-running" tabindex="-1">The meter is running <a class="anchor" href="#the-meter-is-running" aria-hidden="true">#</a></h2>
+<p>The economics changed too. As of <a href="https://github.blog/changelog/2026-06-01-updates-to-github-copilot-billing-and-plans/">June 1, 2026, all GitHub Copilot plans moved to usage-based billing</a>:
+usage now consumes <strong>GitHub AI Credits</strong> (1 credit = $0.01), metered by input, output, and cached tokens
+per model. Paid plans include a monthly allotment —
+<a href="https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/">Pro 1,500 credits, Pro+ 7,000, and a new Max tier at 20,000</a> —
+with code completions staying unlimited and user-level budgets now generally available. It’s the clearest
+signal yet that <strong>agentic coding is a metered resource</strong>, priced like compute rather than a flat seat.</p>
+<p><strong>What it means in practice:</strong> when every agent step has a token price, two things start to matter a lot —
+<em>visibility</em> into what your agents spend, and the option to run work where you control the cost. That’s a
+core argument for <a href="/blog/why-local-first-matters-for-ai-agents/">why local-first matters for AI agents</a>: a
+hive that runs on your machine and logs its own activity puts the meter where you can see it.</p>
+<h2 id="governance-and-identity-grew-up" tabindex="-1">Governance and identity grew up <a class="anchor" href="#governance-and-identity-grew-up" aria-hidden="true">#</a></h2>
+<p>The enterprise side of agents got its control plane.
+<a href="https://www.microsoft.com/en-us/security/blog/2026/05/01/microsoft-agent-365-now-generally-available-expands-capabilities-and-integrations/">Microsoft Agent 365 reached general availability on May 1, 2026</a>
+(announced in March, at $15 per user per month). It’s an <strong>identity-first</strong> layer: Microsoft Entra issues
+identities and risk-based access for agents the way it does for people, Purview applies data-loss
+protection, and the control plane gives <strong>real-time audit trails</strong> for every agent — with registry sync to
+AWS Bedrock and Google Cloud in preview. The framing across coverage is consistent: 2026 is when “shadow”
+agents become a <em>governed</em> asset class.</p>
+<p>You can see the same instinct in the open standards — OpenAI’s <strong><a href="http://AGENTS.md">AGENTS.md</a></strong> convention, now an AAIF
+project, is essentially a shared contract for telling an agent how to behave in a repo.</p>
+<p><strong>What it means in practice:</strong> governance isn’t only an enterprise SaaS feature. The same primitives —
+<strong>identity, audit, and a human in the loop</strong> — can live locally. A hive that routes risky actions through
+<a href="/blog/human-in-the-loop-ai-agents/">human-in-the-loop approvals</a> and records every step to an
+<a href="/blog/append-only-event-log-agents/">append-only event log</a> is doing agent governance on your own
+machine, no control-plane subscription required.</p>
+<h2 id="the-quiet-counter-trend-local-first-and-open-source" tabindex="-1">The quiet counter-trend: local-first and open-source <a class="anchor" href="#the-quiet-counter-trend-local-first-and-open-source" aria-hidden="true">#</a></h2>
+<p>For all the enterprise launches, the most interesting current under them is the opposite direction. The
+community read on 2026 is that
+<a href="https://github.com/Zijian-Ni/awesome-ai-agents-2026">agents stopped being demos and became infrastructure</a>,
+and a large slice of that infrastructure is <strong>self-hosted</strong>: open-source agent frameworks, local skill
+registries, and a documented shift toward
+<a href="https://www.devflokers.com/blog/open-source-ai-projects-may-2026-roundup">controllable, self-hosted agent ecosystems</a>
+that don’t lock your data or your bill into a cloud platform. (Treat the headline star-counts and market
+sizes in those roundups as directional — they come from aggregators, not audited filings.)</p>
+<p><strong>What it means in practice:</strong> you don’t have to choose between “coordinated agents” and “runs on my
+laptop.” That’s the whole premise of Munder Difflin — a local, open-source hive where a
+<a href="/#how">plain-language orchestrator</a> decomposes your intent and routes work across agents that share
+<a href="/blog/give-claude-code-long-term-memory/">long-term memory</a> and message each other directly, all
+visualized on an office floor you can watch.</p>
+<h2 id="what-it-means-if-you-build-with-agents" tabindex="-1">What it means if you build with agents <a class="anchor" href="#what-it-means-if-you-build-with-agents" aria-hidden="true">#</a></h2>
+<p>Pulling the threads together, the June 2026 picture is a stack that’s <strong>stratifying</strong>:</p>
+<ul>
+<li><strong>Models</strong> are being tuned for autonomy and parallel subagents, not just chat.</li>
+<li><strong>Protocols</strong> (MCP for tools, A2A for agents) are consolidating under neutral governance.</li>
+<li><strong>Economics</strong> moved to per-token metering, making cost visibility a first-class concern.</li>
+<li><strong>Governance</strong> — identity, audit, human-in-the-loop — became table stakes, on the cloud <em>and</em> locally.</li>
+</ul>
+<p>The practical takeaway: the building blocks for a serious multi-agent setup are now standard, cheap to
+start, and increasingly self-hostable. If you’ve been waiting for the space to settle before running a
+real team of agents, mid-2026 is a reasonable moment to start — and you can do it on your own hardware.
+The fastest way to feel the difference is to <a href="/#install">download Munder Difflin</a> and watch a coordinated
+hive run; 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 changed in agentic AI in mid-2026?</p>
+ <p class="a">Four things moved at once: frontier models got meaningfully better at acting autonomously (Anthropic&#39;s Claude Opus 4.8 and its parallel-subagent Dynamic Workflows), agent coordination standardized under the Linux Foundation&#39;s Agentic AI Foundation (MCP for tools, A2A for agent-to-agent), agent usage became metered (GitHub Copilot moved to usage-based AI Credits on June 1), and governance matured (Microsoft Agent 365 reached general availability as an agent control plane).</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What&#39;s the difference between MCP and A2A?</p>
+ <p class="a">They solve different problems. The Model Context Protocol (MCP) standardizes how a single agent connects to its tools, APIs, and data — agent-to-tool. The Agent2Agent (A2A) protocol standardizes how separate agents discover and talk to each other — agent-to-agent. Both are now stewarded by the Linux Foundation, and most real systems use them together.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Do I need a cloud platform to run AI agents in 2026?</p>
+ <p class="a">No. Alongside the big enterprise launches, 2026 has a strong local-first, open-source current: self-hosted agent frameworks and skill registries that run on your own machine. A local hive like Munder Difflin gives you coordinated multi-agent work — shared memory, messaging, an orchestrator — without sending your code or context to a SaaS.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/agentic-ai/">Agentic AI</a><a class="tag" href="/blog/tags/industry/">Industry</a><a class="tag" href="/blog/tags/protocols/">Protocols</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="#at-a-glance">At a glance</a></li><li class="lvl-2"><a href="#models-learned-to-act-not-just-answer">Models learned to act, not just answer</a></li><li class="lvl-2"><a href="#agent-coordination-is-becoming-a-protocol-layer">Agent coordination is becoming a protocol layer</a></li><li class="lvl-2"><a href="#the-meter-is-running">The meter is running</a></li><li class="lvl-2"><a href="#governance-and-identity-grew-up">Governance and identity grew up</a></li><li class="lvl-2"><a href="#the-quiet-counter-trend-local-first-and-open-source">The quiet counter-trend: local-first and open-source</a></li><li class="lvl-2"><a href="#what-it-means-if-you-build-with-agents">What it means if you build with agents</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/building-a-terminal-ui-xterm-node-pty/"><span class="k">← Older</span><span class="t">Building a Terminal UI with xterm.js and node-pty</span></a>
+ <a class="pn next" href="/blog/what-is-aeo-for-dev-tools/"><span class="k">Newer →</span><span class="t">AEO for Dev Tools: Getting Cited by ChatGPT and Claude</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 &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/sitemap.xml b/docs/sitemap.xml
index 68330c24..1f372afc 100644
--- a/docs/sitemap.xml
+++ b/docs/sitemap.xml
@@ -35,6 +35,12 @@
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
+ <url>
+ <loc>https://munderdiffl.in/blog/can-claude-code-agents-talk-to-each-other/</loc>
+ <lastmod>2026-06-04</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
<url>
<loc>https://munderdiffl.in/blog/claude-code-automation-while-you-sleep/</loc>
<lastmod>2026-06-04</lastmod>
@@ -59,12 +65,54 @@
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
+ <url>
+ <loc>https://munderdiffl.in/blog/context-engineering-for-ai-agents/</loc>
+ <lastmod>2026-06-04</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
<url>
<loc>https://munderdiffl.in/blog/debugging-multi-agent-systems/</loc>
<lastmod>2026-06-04</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
+ <url>
+ <loc>https://munderdiffl.in/blog/do-more-with-less-model-routing/</loc>
+ <lastmod>2026-06-04</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/how-agents-remember-semantic-memory/</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/scheduling-autonomous-agent-missions/</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>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/whats-new-in-agentic-ai-june-2026/</loc>
+ <lastmod>2026-06-04</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
<url>
<loc>https://munderdiffl.in/blog/building-a-terminal-ui-xterm-node-pty/</loc>
<lastmod>2026-06-03</lastmod>
@@ -269,26 +317,26 @@
<changefreq>monthly</changefreq>
<priority>0.8</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/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/orchestration/</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/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>
<url><loc>https://munderdiffl.in/blog/topics/story/</loc><changefreq>weekly</changefreq><priority>0.5</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/multi-agent/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/claude-code/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/internals/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/guides/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/orchestration/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/guides/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/comparisons/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/tools/</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/concepts/</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/automation/</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/terminals/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
@@ -300,6 +348,7 @@
<url><loc>https://munderdiffl.in/blog/tags/pixijs/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/visualization/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/xtermjs/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/autonomous/</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>
@@ -320,7 +369,16 @@
<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/autonomous/</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/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>
+ <url><loc>https://munderdiffl.in/blog/tags/devrel/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/agentic-ai/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/industry/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/protocols/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/tutorial/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
</urlset>