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

docs: v0.2.8 shareable hires — landing, README, and 3 blog posts

Chaitanya Giri01e6443693ec
diff --git a/README.md b/README.md
index 48038360..85513f8f 100644
--- a/README.md
+++ b/README.md
@@ -117,6 +117,7 @@ terminal/event plane, and [`DESIGN.md`](./DESIGN.md) for the visual system.
| **MemoryReflector** | Memory condensation that summarizes and bounds per-agent memory over time, so long-term memory doesn't grow without limit. |
| **Configurable home folder** | Point the hive/memory home at any folder, with a safe move that relocates existing state without losing it. |
| **Restore team** | One-click "Restore team" rebuilds last session's workers after a harness restart — no more re-adding agents by hand. |
+| **Shareable hires** | Import a ready-made agent role — provider, model, flags, goal, capabilities, token budget — from a `munderdifflin://hire` deep link or a local manifest file. Import only *pre-fills* the Add-Agent modal (behind an "imported" banner); spawning stays a human click. The manifest is validated as untrusted input (no executable field, a default-deny flag allowlist, an https-only bounded fetch). Browse ready-made roles at [The Hiring Fair](https://munderdiffl.in/hires/). |
| **Task kanban** | Dependency-aware kanban board in the Command Center Tasks tab — assign tasks to agents, track status across todo/doing/blocked/done, wire dependencies so work starts in order. |
| **Scheduled missions & heartbeat** | Recurring auto-dispatch missions with label, interval, target agent, and body — plus a scheduler heartbeat that re-engages the floor when it goes quiet. Missions now live in their own Schedules tab with last/next-fired times. |
| **Terminal work-order handoff** | Providers without an inbox-drain hook receive hive mail as a `WORK ORDER FROM HIVE` typed into their terminal; if the renderer is unavailable, the message bounces to the GOD agent instead of disappearing. |
@@ -129,7 +130,7 @@ terminal/event plane, and [`DESIGN.md`](./DESIGN.md) for the visual system.
| **Avatar states** | Avatars reflect real work — including new v0.2.0 states for *compacting* (context compaction) and *looping* (circuit-breaker intervention), on top of crisper HiDPI floor text and high-contrast speech bubbles. |
> [!NOTE]
-> **Status: v0.2.7 — voice, memory, floors & polish.** Building on the multi-provider floor — Claude Code, Antigravity (Gemini via `agy`), and OpenAI Codex all work as first-class hive participants (Antigravity via a native `agy-hook` bridge, Codex via lifecycle-hook parity plus protocol injection and provider-agnostic inbox/outbox routing) — v0.2.4→v0.2.7 add: **Free Flow voice dictation** (hold Option to talk; Groq Whisper transcribes straight into the composer), an opt-in **enterprise Knowledge Graph** agents query for ranked passages from your own documents/policies/context, **multi-window "floors"** (isolated offices with per-PTY routing), a **richer message composer** with file & image attachments, **agent session resume** across restarts (with a per-agent *Restart & Continue* button), **drag-a-file-onto-the-terminal** path injection, and **Slack/webhook triggers** that pipe a channel straight into Michael's queue. Everything from v0.2.0–v0.2.3 — observability, circuit breaker, durable persistence, context gauges, Command Center, task kanban, GitHub/CI integration, threaded conversations, desktop notifications, agent archival, and the dedicated Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page.
+> **Status: v0.2.8 — shareable hires.** The headline: **shareable hires** — package a role-configured agent (provider, model, flags, goal, capabilities, token budget) as a portable `munder-difflin/hire@1` manifest, share it as a file or host it in **[The Hiring Fair](https://munderdiffl.in/hires/)**, and import it into any office with one click. Import only *pre-fills* the Add-Agent modal (the human always clicks spawn), with the manifest validated end to end as untrusted input (no executable field, a default-deny flag allowlist, an https-only bounded fetch with per-hop redirect re-validation). Building on the multi-provider floor — Claude Code, Antigravity (Gemini via `agy`), and OpenAI Codex all work as first-class hive participants (Antigravity via a native `agy-hook` bridge, Codex via lifecycle-hook parity plus protocol injection and provider-agnostic inbox/outbox routing) — v0.2.4→v0.2.7 add: **Free Flow voice dictation** (hold Option to talk; Groq Whisper transcribes straight into the composer), an opt-in **enterprise Knowledge Graph** agents query for ranked passages from your own documents/policies/context, **multi-window "floors"** (isolated offices with per-PTY routing), a **richer message composer** with file & image attachments, **agent session resume** across restarts (with a per-agent *Restart & Continue* button), **drag-a-file-onto-the-terminal** path injection, and **Slack/webhook triggers** that pipe a channel straight into Michael's queue. Everything from v0.2.0–v0.2.3 — observability, circuit breaker, durable persistence, context gauges, Command Center, task kanban, GitHub/CI integration, threaded conversations, desktop notifications, agent archival, and the dedicated Schedules tab — remains functional and shipping. macOS (signed), Windows, and Linux builds are available on the releases page.
## Getting started
@@ -254,7 +255,9 @@ chrome. The 15 avatars are the cast of *The Office*, differentiated by hair/skin
## Roadmap
-Shipped in **v0.2.0–v0.2.7**:
+Shipped in **v0.2.0–v0.2.8**:
+
+- [x] **Shareable hires** — import a role-configured agent from a `munderdifflin://hire` deep link or a local manifest; import pre-fills the Add-Agent modal (the human spawns), and the manifest is validated as untrusted input. Ready-made roles live in [The Hiring Fair](https://munderdiffl.in/hires/).
- [x] **Heartbeat** — scheduler heartbeat that re-engages the floor when it goes quiet, with last/next-fired times surfaced in the Schedules tab.
- [x] **Memory reflection** — the MemoryReflector summarizes and bounds per-agent memory over time to prevent unbounded growth.
diff --git a/blog/src/posts/hire-manifest-untrusted-input.md b/blog/src/posts/hire-manifest-untrusted-input.md
new file mode 100644
index 00000000..2e8cd88f
--- /dev/null
+++ b/blog/src/posts/hire-manifest-untrusted-input.md
@@ -0,0 +1,181 @@
+---
+title: "Treating a Hire Manifest as Untrusted Input"
+description: "A shareable agent-config manifest is attacker input. How Munder Difflin's import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch."
+date: 2026-06-15
+category: internals
+categoryLabel: Internals
+type: Technical
+primaryKeyword: "untrusted input agent config"
+secondaryKeywords: ["command injection electron", "ssrf deep link", "default-deny allowlist", "shareable agent config security", "cmd.exe argument quoting"]
+tags: ["Security", "Internals", "Electron", "Command Injection", "SSRF"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Why is a shareable agent-config file a security problem?"
+ a: "Because importing one is the same trust event as opening any link or downloading any file: the bytes are attacker-controlled. A 'hire' manifest is a JSON document you get by clicking a munderdifflin:// link or saving a file someone sent you. If any field in it can influence what process runs, what flags get passed, or what URL the app fetches, then a manifest is no longer data — it's an action an attacker triggers on your machine. So the import pipeline is built as a security boundary, not a convenience."
+ - q: "Can importing a hire manifest spawn an agent on its own?"
+ a: "No. Import only pre-fills the Add-Agent modal behind an 'imported' banner. The agent spawns solely when the human clicks submit in that modal. There is no code path that spawns on import — the manifest is data that proposes a configuration; the human is always the spawn gate."
+ - q: "Can a manifest choose what program runs?"
+ a: "No. There is no command or executable field in the schema. The binary always comes from the user's locally configured provider preset — claude, antigravity, or codex. provider: \"custom\" is rejected outright. A manifest can only select among providers you already installed; it can never name a new program to run."
+ - q: "Why an allowlist for command flags instead of blocking the dangerous ones?"
+ a: "Because the manifest's provider is attacker-chosen and each CLI keeps adding flags, a denylist is a bet that you enumerated every dangerous value — and it drifts and leaks as the tools evolve (ours leaked across three review rounds). A default-deny allowlist (SAFE_FLAG_NAMES) is a bet that you enumerated every safe value, and the safe set is small and stable. For attacker-controlled input, allowlist beats denylist."
+ - q: "How does the deep-link fetch avoid SSRF?"
+ a: "The fetch is https-only (plain http allowed only for loopback, for local gallery dev), follows redirects manually and re-validates every Location hop against the same https/loopback allowlist (capped at 5 hops), resolves and blocks private/loopback/link-local addresses including the 169.254.169.254 cloud-metadata endpoint, and streams the body through a bounded reader that aborts past 64 KB with a 10s timeout. A remote page can never redirect the app into http://127.0.0.1 or a metadata IP, and a hostile host can't OOM the main process by streaming an unbounded body."
+ - q: "What risk is still left after all this?"
+ a: "Free-text fields — goal and description — pre-fill the prompt the agent will run on, which is a prompt-injection surface. v1 accepts this because the human reviews every field before spawning and the binary and flags are locked down. The human remains the spawn gate; the manifest can suggest a task, but a person decides to run it."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>In v0.2.8 we shipped <strong>shareable hires</strong> — JSON manifests that configure an agent role and travel by link. A manifest is <strong>attacker-controlled input</strong> (you click a link, you download a file), so the import pipeline is a <strong>security boundary</strong>. The defenses: <strong>import never spawns</strong> (it only pre-fills a modal the human submits); <strong>no executable field</strong> (the binary comes from your own provider presets, <code>custom</code> is rejected); a <strong>default-deny flag allowlist</strong> (allowlist &gt; denylist for hostile input); strict charset validation on every stringly-typed field <em>plus</em> a hardened <code>cmd.exe</code> quoter at the sink; and an <strong>SSRF-safe, bounded fetch</strong> that re-validates every redirect hop and caps the body at 64 KB. Validate at the boundary <em>and</em> quote at the sink — defense in depth, both layers.</p></div>
+
+A shareable hire is a nice feature with a sharp edge. You see a link — `munderdifflin://hire?src=https://gallery.example/pr-reviewer.json` — you click it, and the Add-Agent modal opens pre-filled with a tidy "PR Reviewer" role: a sprite, a model, a goal, a couple of flags. One more click and it's on your office floor. The convenience is the whole point. The problem is that everything in that manifest came from *someone else*.
+
+That makes a hire manifest the same category of thing as a downloaded file or a clicked URL: **attacker-controlled input**. Nobody audits a JSON file before importing it any more than they read a `.dmg` before opening it. So the import pipeline can't treat the manifest as a trusted config object. It has to treat it as hostile bytes and prove, field by field, that nothing in it can turn into an *action* on your machine. This post is the threat model and the defense-in-depth that came out of a two-round security review — including one HIGH-severity bug that turned a clicked link into arbitrary code execution on Windows.
+
+## The shape of the feature
+
+A "hire" is a JSON manifest tagged `munder-difflin/hire@1`. The interesting fields:
+
+```json
+{
+ "spec": "munder-difflin/hire@1",
+ "name": "PR Reviewer",
+ "sprite": "dwight",
+ "provider": "claude",
+ "model": "claude-sonnet-4-6",
+ "commandFlags": ["--verbose"],
+ "goal": "Review open PRs and leave inline comments.",
+ "capabilities": ["read", "comment"],
+ "tokenCap": 200000,
+ "isolate": true
+}
+```
+
+`provider` must be one of `claude` | `antigravity` | `codex`. There are two ways a manifest gets in: a `munderdifflin://hire?src=<https-url>` deep link, which the Electron **main** process fetches and validates, and a plain local-file import. Both paths funnel into **one** validator (`src/shared/hire.ts`) and end at the same place: the Add-Agent modal, pre-filled.
+
+The single most important property of the whole design falls out of that last sentence.
+
+## Trust boundary #1: import never spawns
+
+**The manifest is data, never an action.** Importing a hire does exactly one thing — it pre-fills the Add-Agent modal, behind an "imported" banner that tells you these values came from outside. It does not start anything. The agent spawns only when *you* click submit in that modal, after the fields are sitting in front of you.
+
+There is no code path — not the deep link, not the file import, not a malformed-but-clever payload — that spawns an agent as a side effect of import. This is the cleanest defense there is, because it makes the human the spawn gate by construction. Every other layer below is about ensuring that the *configuration* a manifest proposes is safe to hand to a person for one-click approval. But even if a field slipped through, nothing runs until a human says so. Import proposes; the human disposes.
+
+## No executable field
+
+The second structural defense is an absence. **There is no `command` or `executable` field in the schema.** A manifest cannot name the program that runs. The binary always comes from the user's **locally configured provider preset** — the `claude`, `agy`, or `codex` you installed and pointed the app at. `provider: "custom"` is rejected by the validator outright, precisely because a custom provider is a user-side escape hatch for naming an arbitrary binary, and we will not let a downloaded file reach through it.
+
+So the worst a manifest can do on the "what runs" axis is *select among providers you already trust*. It picks `claude` or `codex`; it cannot introduce `curl` or `/bin/sh`. That shrinks the attack surface to the *arguments* passed to a binary you already chose to install — which is exactly where the interesting bug lived.
+
+## The HIGH-severity bug: Windows command injection via `model`
+
+The first review found it. `commandFlags` were validated tightly from day one — but `model` was only **length-capped**, never **shape-checked**. And `model` is not inert: it flows onto the spawn command line as `--model <model>`, quoted only if it contained whitespace.
+
+That "quoted only if it contained whitespace" is the whole bug. Consider this manifest field:
+
+```json
+"model": "x&calc"
+```
+
+No whitespace, so the spawn logic passed it through unquoted. On macOS and Linux that's harmless — argv goes straight to `node-pty`, no shell is involved, and `x&calc` is just one literal (nonsense) argument. But on **Windows**, when the provider binary is a `.cmd` or `.bat` shim — which is the **default** for an npm-installed `claude` / `agy` / `codex` — Node routes the spawn through `cmd.exe /d /s /c`. And `cmd.exe`'s argument quoter, at the time, only escaped space, tab, and `"`. It did **not** escape `cmd` metacharacters like `&`. So the command line became:
+
+```text
+claude --model x & calc
+```
+
+`cmd.exe` reads `&` as a command separator. It runs `claude --model x`, then runs `calc`. One clicked `munderdifflin://hire` link → arbitrary code execution.
+
+This is the classic failure mode for untrusted input, and worth naming precisely: **untrusted JSON is supposed to stay inert, but a stringly-typed field leaked out of the data plane and into a shell.** `commandFlags` got the scrutiny because it *looked* dangerous; `model` looked like a harmless label, so it was only length-checked — and a label that reaches a command line is not a label, it's an argument, and on Windows an argument that reaches `cmd.exe` is potentially a command.
+
+## The two-layer fix (do both)
+
+The fix is deliberately redundant, because the two layers fail differently and a defense-in-depth posture wants both.
+
+**Layer 1 — validate at the boundary.** Constrain `model` to a safe charset so a hostile value never makes it past the validator in the first place:
+
+```js
+const MODEL_RE = /^[A-Za-z0-9 ._()[\]\/:@+-]{1,80}$/;
+```
+
+`&` is not in that class. Neither is `| ^ < > ; $ % \` " '`. The PoC `x&calc` fails `MODEL_RE.test(model)` and the import is rejected with a validation error. This restores the invariant that *untrusted JSON stays inert* — a malicious `model` can't even reach the modal, let alone a spawn.
+
+**Layer 2 — quote at the sink.** Harden the Windows `cmd.exe` argument quoter so it also quotes any token containing `& | ^ < > ( ) % !`. This is the belt to the validation suspenders, and it's broader than the hire feature: it guards **every** spawn path in the app, not just imported manifests. If some *other* future field ever leaks a metacharacter onto a command line, the quoter catches it even if a validator forgot to.
+
+Why both? Because they protect against different mistakes. Validation is the *specific* fix — it knows `model` should look like a model id. The quoter is the *general* fix — it knows that no argument, from any source, should be able to break out of its slot on a Windows command line. Either one alone closes the PoC; together they mean a single forgotten check on one field is not, by itself, a code-execution bug. **Validate at the boundary and quote at the sink** is one of the durable lessons here.
+
+## Default-deny: the flag allowlist
+
+`commandFlags` is the field most obviously capable of mischief, and it's where the review process taught the cleanest lesson. The first version used a **denylist** — a set of dangerous flags to reject (`--dangerously-*`, settings overrides, MCP config, and so on). It was reasonable, and it leaked.
+
+It leaked because the manifest's `provider` is attacker-chosen, and each CLI — claude, agy, codex — keeps adding flags release over release. A denylist is a snapshot of "every bad flag we could think of," and the moment a CLI ships a new dangerous flag (or you discover a `codex`/`agy` superset gap you'd missed), the denylist has a hole. Ours leaked across **three** review rounds: each round found another flag — a config-override here, a base-URL redirect there — that the denylist didn't know to block.
+
+So we flipped it. `commandFlags` is now a **default-deny allowlist**. Every flag-shaped token has to clear two gates:
+
+```js
+const FLAG_RE = /^[A-Za-z0-9._\/=:,@+-]{1,100}$/; // no whitespace, no shell metachars, no % env-expansion
+const SAFE_FLAG_NAMES = new Set([ /* a small, curated set of known-harmless flags */ ]);
+```
+
+A token must (a) match `FLAG_RE` — so no whitespace, no shell metacharacters, no `%` (which would invite `cmd.exe` environment expansion) — **and** (b) have a flag name that's in `SAFE_FLAG_NAMES`. Nothing system-prompt-related, settings-related, MCP-related, or provider/base-URL-related is ever allowlisted, because those are the flags that change *what the agent trusts* or *where it talks to*. And the args, once validated, go to `node-pty` as an **argv array** — never concatenated into a shell string.
+
+The general principle is worth stating plainly: **for attacker-controlled input, an allowlist beats a denylist.** A denylist is a bet that you enumerated every *bad* value — and that bet loses every time the world adds a new bad value you didn't anticipate. An allowlist is a bet that you enumerated every *safe* value — and the safe set is small, well-understood, and changes slowly. When the input is hostile and the surface keeps growing, you want to be betting on the small stable set, not the unbounded one.
+
+## SSRF-safe, bounded fetch
+
+The deep link `munderdifflin://hire?src=<url>` hands the app a URL it will fetch from the **main** process — which has the network and the OS at its disposal. A naive fetch here is a classic server-side request forgery (SSRF) primitive: a remote page tells *your* app to make a request *you* didn't intend. The transport (`src/main/hire.ts`) is hardened on three axes, each of which started out wrong in the first cut.
+
+### https-only, with a loopback carve-out
+
+The fetch is **https-only**. Plain `http` is allowed *only* for loopback, so the local hire-gallery dev server works over `http://127.0.0.1`. The carve-out is deliberately narrow: a remote, public page can never point the app at an `http://` target, so it can't downgrade you onto an internal plaintext service.
+
+### Redirect SSRF, closed
+
+The first version used `fetch(url, { redirect: 'follow' })`. That validates only the **initial** URL — the final hop after a redirect is never re-checked. So an attacker hosts `https://evil.example/m.json`, the app validates *that* (it's https, it's public, fine), and then the server answers `302 Location: http://127.0.0.1:PORT/...` or `→ http://169.254.169.254/...` (the cloud-metadata endpoint). `fetch` follows the redirect, and the app has now made a request to an internal address it would never have accepted directly.
+
+The fix is to take over redirect handling:
+
+```text
+redirect: 'manual' // don't auto-follow
+for hop in 0..5: // cap at 5 hops
+ if status is 3xx:
+ loc = response Location header
+ next = new URL(loc, current)
+ if next.protocol !== 'https:' → reject // a hop may not drop into http/loopback
+ if !isPublicAddress(next.host) → reject // re-validate the resolved address
+ current = next; continue
+ else: this is the real response
+```
+
+Every `Location` is re-validated against the **same** https/public-address allowlist as the initial request, with a hard cap of ≤5 hops. `https → https` redirects (link shorteners, CDNs) still work; `https → http://127.0.0.1` and `https → 169.254.169.254` are dead. The same pass also closed an **IPv6-bracket bypass** in the host check — the host parser strips `[`/`]` before resolving, so `https://[::1]/` and friends can't sneak a loopback address past a string comparison.
+
+### Streamed byte cap
+
+The first version trusted the `content-length` header, then did `await res.text()`. Two bugs in one line. First, it buffered the **entire** body before checking length — so a hostile host could just *not send* a `content-length` (or lie about it) and stream gigabytes, OOM-ing the main process. Second, `.length` on the resulting string counts UTF-16 code units, not bytes, so the cap it *did* apply was measuring the wrong thing.
+
+The fix is a bounded reader (`readBounded`) that streams the response and **aborts the moment the accumulated byte count exceeds 64 KB**, never trusting `content-length` as anything but a hint. A 10-second timeout bounds the time axis too. A manifest is a few hundred bytes of JSON; anything claiming to be megabytes is, by definition, not a hire.
+
+## One validator, four copies in sync
+
+A security boundary is only as good as its consistency. The validator in `src/shared/hire.ts` is **dependency-free and pure** — no I/O, no imports beyond the language — which is exactly what lets it run in three places at once: the Electron **main** process (for the deep-link path) and the **renderer** (for file import and modal pre-fill). The hire **gallery** mirrors the same rules in a client-side validator (`docs/hires/validator.js`), and a JSON schema (`docs/hires/spec/hire.schema.json`) encodes them once more for tooling. Same charset rules, same allowlist, same provider constraint, everywhere — so a manifest that the gallery says is valid is the manifest the app will accept, and there's no soft spot where one copy is laxer than another.
+
+## What's still on the human
+
+The honest caveat. Two fields — `goal` and `description` — are free text, and they pre-fill the **prompt** the agent will run on. That's a prompt-injection surface: a manifest can suggest a task, and the words of that task are attacker-influenced. v1 accepts this deliberately, on two grounds. First, the human **reviews every field** in the modal before clicking spawn — the goal text is right there to read. Second, the things that would turn a poisoned prompt into real damage are locked down upstream: the binary is your own provider, the flags are allowlisted, no settings or system-prompt overrides get through. The prompt can ask the agent to do something dubious, but the agent runs inside the same [permission and sandboxing model](/blog/agent-security-and-sandboxing/) as any other, and the [human is in the loop](/blog/human-in-the-loop-ai-agents/) on the actions that matter. The manifest never gets to be the spawn gate. A person does.
+
+That's the line we hold for v1, and we're candid that it *is* a line and not a wall: free text into a prompt is, fundamentally, part of the [lethal trifecta](/blog/the-lethal-trifecta-for-coding-agents/) story, and the durable answer there is architectural, not a regex. Locking the binary and flags is how we keep a poisoned goal a *nuisance* rather than a *breach*.
+
+## The transferable lessons
+
+Strip away the specifics and the hire pipeline is a small catalog of rules for any "import an untrusted config" feature:
+
+- **Make import inert.** Importing data should never be an action. Pre-fill, then make a human commit. The spawn gate is a person, by construction.
+- **Don't let data name the executable.** Configs select among *your* trusted programs; they never introduce one. Reject the custom-provider escape hatch.
+- **Validate at the boundary *and* quote at the sink.** A charset check on each field and a hardened quoter on the command line catch different mistakes; defense in depth wants both.
+- **Allowlist, don't denylist, hostile input.** A denylist bets you enumerated every bad value against a growing surface; an allowlist bets you enumerated the small, stable safe set. The latter doesn't rot.
+- **Re-validate every redirect hop, and never trust `content-length`.** SSRF lives in the *final* hop and in *unbounded* bodies. Follow redirects manually, re-check each target's protocol and resolved address, cap the hops, and stream the body to a hard byte limit with a timeout.
+
+A shareable hire is a link you click. The whole point of the import pipeline is that clicking it stays as boring as it looks.
+
+---
+
+Shareable hires shipped in **v0.2.8** — see the [launch notes](/blog/launching-munder-difflin-v0-2-8/) and the [concept companion on shareable agent roles](/blog/shareable-agent-roles/) for the feature side, and the [CHANGELOG](https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md) for the full diff. The security posture here is the same one that runs through the rest of the harness: [permission modes and sandboxing](/blog/agent-security-and-sandboxing/), the [lethal trifecta](/blog/the-lethal-trifecta-for-coding-agents/), and [human-in-the-loop on the actions that matter](/blog/human-in-the-loop-ai-agents/).
diff --git a/blog/src/posts/launching-munder-difflin-v0-2-8.md b/blog/src/posts/launching-munder-difflin-v0-2-8.md
new file mode 100644
index 00000000..9a96321d
--- /dev/null
+++ b/blog/src/posts/launching-munder-difflin-v0-2-8.md
@@ -0,0 +1,133 @@
+---
+title: "Launching Munder Difflin v0.2.8: Shareable Hires"
+description: "Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself."
+date: 2026-06-15
+category: story
+categoryLabel: Story
+type: Non-technical
+primaryKeyword: "munder difflin v0.2.8"
+secondaryKeywords: ["shareable agent roles", "the hiring fair", "one-click ai agent hire", "munderdifflin deep link", "ai agent role manifest"]
+tags: ["Story", "Release", "Multi-Agent", "Claude Code", "Open Source"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What's new in Munder Difflin v0.2.8?"
+ a: "The headline is Shareable Hires. A hire is a portable JSON manifest (format id munder-difflin/hire@1) that captures a fully role-configured agent — name, avatar, provider, model, command flags, a goal, capability tags, and a token budget. You can share it as a link or a file, and the recipient gets the Add-Agent modal pre-filled, ready to review and spawn. It ships alongside a community gallery called The Hiring Fair at munderdiffl.in/hires."
+ - q: "What exactly is a 'hire'?"
+ a: "Think of it as a job description for an AI coworker. It's a single JSON manifest that describes a role-configured agent: which provider runs it (Claude Code, Antigravity, or Codex), the model, the command flags, a goal/role description, capability tags, and a token budget. Hand it to anyone's office and they can spin up that exact role."
+ - q: "Does importing a hire automatically run an agent?"
+ a: "No — and this is the whole point. Importing a hire (by link or by file) only pre-fills the Add-Agent modal, with an explicit 'imported' banner. Nothing spawns until you review every field and click spawn yourself. A hire you got from the internet can't run itself. The human is always the trigger."
+ - q: "What is The Hiring Fair?"
+ a: "It's a community gallery at munderdiffl.in/hires — static, no login. It's full of ready-made roles from the cast: Pam writes docs, Dwight enforces QA, Jim reviews PRs, Creed audits security, Angela audits the office's own token spend, and Stanley does the migrations nobody wants. Each card has a Claude Code / Antigravity / Codex toggle and function filters. Browse, click the ⚡hire button, review, spawn."
+ - q: "How are the two ways to hire different?"
+ a: "There are two front doors, one pipeline. A deep link (munderdifflin://hire?src=<https-url>) makes the app fetch and validate a manifest, then open the Add-Agent modal pre-filled — that's what the gallery's ⚡hire button uses. A file import is the 'import hire…' button in the Add-Agent modal, which reads a local .hire.json file. Both end at the same review-and-spawn step."
+ - q: "Is it safe to import a hire from someone else?"
+ a: "A manifest is treated as untrusted input: there's no executable field, no auto-spawn, and the fetch is validated and bounded. It can only pre-fill a form you review by hand. We go deep on the trust model in a separate post — see the hire manifest security deep-dive."
+ - q: "Do I still get everything from v0.2.7?"
+ a: "Yes. v0.2.8 includes everything from v0.2.7 (voice dictation, the Knowledge Graph, multi-window floors, the rich composer, session resume) and earlier. Shareable Hires is purely additive."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin v0.2.8</strong> ships <strong>Shareable Hires</strong>. A <strong>hire</strong> is a portable JSON manifest — a job description for an AI coworker (provider, model, flags, goal, capability tags, token budget) — that you can share as a <strong>link</strong> or a <strong>file</strong>. Click a hire, and the Add-Agent modal opens <em>pre-filled</em>. It never spawns anything on its own: <strong>you</strong> review every field and hit spawn. Plus <strong>The Hiring Fair</strong> at <a href="https://munderdiffl.in/hires">munderdiffl.in/hires</a> — a no-login gallery of ready-made roles (Pam writes docs, Dwight does QA, Creed audits security…). Browse → ⚡hire → review → spawn. Free, open source, local-first.</p></div>
+
+ok so picture this. you've got a whole floor of pixel coworkers — Claude Code agents, Antigravity (Gemini) workers, Codex CLIs — all run by Michael, the GOD orchestrator who routes work like a slightly unhinged regional manager. it's great. but here's the part nobody tells you about a fresh, empty office:
+
+**the first hire is the hard one.**
+
+a blank floor is intimidating. what model? what provider? what flags? what should this thing's *job* even be? for a newcomer, that's a lot of staring at an empty Add-Agent dialog before anything fun happens. you basically have to know how to write an orchestrator brief before you can watch a single agent do a single thing.
+
+**v0.2.8 fixes the cold start.** meet **Shareable Hires**.
+
+## what's a "hire"?
+
+a hire is a tiny, portable **JSON manifest** — format id `munder-difflin/hire@1` — that captures a *fully role-configured agent*. not just "an agent," but a coworker with a job already figured out:
+
+- 🏷️ a **name** and an **avatar/sprite** (yes, the little pixel face)
+- 🤖 a **provider** — Claude Code, Antigravity, or Codex
+- 🧠 a **model** and the **command flags** it should run with
+- 🎯 a **goal / role description** — what this coworker is actually here to do
+- 🏆 **capability tags** — what it's good at, so it's filterable
+- 📊 a **token budget** — so it can't quietly torch your bill
+
+think of it as a **job description you can hand to anyone's office**. someone figured out a great "PR reviewer" setup once? they export it as a hire, you drop it into your floor, and now you've got that exact coworker — without reverse-engineering anyone's prompt.
+
+the neat trick: a manifest maps **1:1** onto what the Add-Agent modal already sends. it's not a new system bolted on the side — it's just a portable snapshot of the per-agent config you've always had. "hire Pam" is a *way* easier first step than writing an orchestrator prompt from a cold start.
+
+## two ways to hire, one pipeline
+
+there are two front doors, but they both end at the same place: a modal you review and a spawn button **you** press.
+
+### 🔗 the deep link
+
+click a `munderdifflin://hire?src=<https-url>` link — say, from the gallery — and the app does the legwork: it **fetches** the manifest, **validates** it, and pops open the Add-Agent modal **pre-filled** with everything that hire describes. one click from "ooh, that's a nice role" to "let me look this over."
+
+### 📁 the file import
+
+prefer files? there's an **import hire…** button right inside the Add-Agent modal. point it at a local `.hire.json` file and it reads it in. same destination: the modal, pre-filled.
+
+both paths converge. link or file, you land in the same review screen.
+
+## the part that matters: import never spawns anything
+
+read this twice, because it's the whole trust promise:
+
+> **importing a hire does not start an agent. ever.**
+
+all it does is **pre-fill the modal** — and it slaps an explicit *"imported"* banner on it so you're never confused about where these values came from. then **you** read every field. you check the goal. you eyeball the provider and the budget. and then **you** click spawn. yourself. on purpose.
+
+**a hire you got off the internet can't run itself.** the human is always the trigger. that's not a setting you can flip off; it's how the feature is built. it's the difference between "here's a job description, want to hire this person?" and "this résumé is now a manager." we are firmly the former.
+
+🔒 on the security of it: a manifest is treated as **untrusted input** — there's no executable field, no auto-spawn, and the fetch is validated and bounded. that's the short version. we wrote a whole post on the trust model so this one can stay fun — go read the [hire manifest security deep-dive](/blog/hire-manifest-untrusted-input/) if you want the bolts and the threat model.
+
+## The Hiring Fair 🎪
+
+ok, the fun part. all of this would be a neat plumbing feature with nothing to plug into — so we built the thing to plug into.
+
+**The Hiring Fair** is a community gallery at **[munderdiffl.in/hires](https://munderdiffl.in/hires)**. static, no login, no account. just a wall of ready-made coworkers you can hire in one click. and because the floor looks like *The Office*, of course the cast showed up to apply:
+
+- 📝 **Pam** writes the docs (the README nobody wants to write? Pam wants to write it.)
+- 🥋 **Dwight** enforces QA. Dwight does not negotiate with bugs. *FACT.*
+- 🔍 **Jim** reviews your PRs (calm, reasonable, occasionally pranks the diff)
+- 🕵️ **Creed** audits security (look, who *better* to think like an attacker)
+- 💰 **Angela** audits the office's **own** token spend — she runs the numbers on your other agents and judges them for it. perfect casting.
+- 🗄️ **Stanley** does the migrations nobody else will touch. he's not thrilled. he does them anyway.
+
+each card has a **Claude Code / Antigravity / Codex** toggle and **function filters** — the same ones from the main landing page, so it all feels like one place. pick the provider you actually have installed, filter by what you need, then hit the **⚡hire** button.
+
+the loop is dead simple:
+
+> **browse → click ⚡hire → review → spawn.**
+
+that's it. that's the whole onboarding. instead of "here's an empty floor, good luck," it's "here's Pam, want her to write your docs? yes? she's at her desk now."
+
+## why this is secretly a growth thing
+
+here's the bit we're genuinely excited about. the hardest moment in any tool like this is the **first five minutes**. an empty office asks too much of a newcomer.
+
+a hire collapses that. somebody who already runs a great floor can package up their best role and **share the link**. the recipient clicks it, reviews it, spawns it — and now they've got a working agent on their *first* try, before they've learned a single thing about orchestrator prompts. then *they* tweak it, build their own great role, and share *that*.
+
+that's a **community growth loop**: roles people actually use, shared as one-click links, each one a doorway into the floor that doesn't start with a blank page. The Hiring Fair is the marketplace; the hire manifest is the currency. and none of it costs you an API key — hires drive the CLIs and subscriptions you already pay for.
+
+## everything from 0.2.7 is still in the box
+
+Shareable Hires is purely **additive**. nothing got taken away. v0.2.8 includes everything from v0.2.7 and earlier:
+
+- 🎙️ **voice dictation** — talk to your floor
+- 🕸️ **the Knowledge Graph** — the office remembers how things connect
+- 🪟 **multi-window floors** — spread the office across monitors
+- ✍️ **the rich composer** — attachments + a taller, friendlier input
+- ⏯️ **session resume** — pick a long-running session back up where it left off
+
+plus the multi-provider parity (Claude Code + Antigravity + Codex, no second-class citizens), shared memory, the inbox/outbox mailbox, schedules, token budgets, close-the-lid overnight runs, and Slack/webhook triggers. the floor you already love, now with a front door for new coworkers.
+
+## get v0.2.8
+
+Munder Difflin is **free, open source, and local-first** on macOS, Windows, and Linux. no account, no cloud — your machine, your subscriptions, your floor.
+
+[**Download v0.2.8**](https://github.com/chaitanyagiri/munder-difflin/releases/latest), then head over to [**The Hiring Fair**](https://munderdiffl.in/hires), find a coworker, and hit ⚡hire. review the modal. spawn it. watch Pam get to work.
+
+want the why-it's-built-this-way story? read the concept companion on [shareable agent roles](/blog/shareable-agent-roles/). want the trust model and threat surface in detail? that's the [hire manifest security deep-dive](/blog/hire-manifest-untrusted-input/). curious how we even ended up with a Dwight in the first place? the [Office parody behind Munder Difflin](/blog/the-office-parody-behind-munder-difflin/) explains the casting. and if you missed the multi-provider launch, [v0.2.4 is right here](/blog/launching-munder-difflin-v0-2-4/).
+
+full release notes live in the [CHANGELOG](https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md).
+
+that's it. go hire someone. (Dwight is already volunteering.)
diff --git a/blog/src/posts/shareable-agent-roles.md b/blog/src/posts/shareable-agent-roles.md
new file mode 100644
index 00000000..34639015
--- /dev/null
+++ b/blog/src/posts/shareable-agent-roles.md
@@ -0,0 +1,123 @@
+---
+title: "Shareable Agent Roles: A Portable Format for Hiring AI Coworkers"
+description: "Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact."
+date: 2026-06-15
+category: concepts
+categoryLabel: Concepts
+type: Non-technical
+primaryKeyword: "shareable agent roles"
+secondaryKeywords: ["portable agent config", "ai agent role manifest", "the hiring fair", "one-click ai agent", "reusable agent personas"]
+tags: ["Concepts", "Multi-Agent", "Open Source", "Agent Design"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is a 'shareable agent role'?"
+ a: "It's an agent role packaged as a portable file — a small JSON manifest (format id munder-difflin/hire@1) that captures everything needed to spin up a role-configured agent: name, avatar, provider, model, command flags, a goal/role description, capability tags, and a token budget. We call one a 'hire.' Instead of explaining your setup in a tutorial, you hand someone the file and they get the same coworker."
+ - q: "Why should agent roles be portable at all?"
+ a: "Because a good role is real, hard-won configuration work — the right provider and model, the right flags, a sharp goal prompt, sane capabilities and a token budget — and today that knowledge is trapped in one person's setup or buried in prose. Portability turns that tacit knowledge into an artifact you can share, fork, and improve, the same move package registries made for code libraries."
+ - q: "If I import a role from a link, does it start running on its own?"
+ a: "No. Import never spawns anything. It only pre-fills the Add-Agent modal behind an explicit 'imported' banner. You review every field and you click spawn. A role you got from the internet is inert data until a human acts on it — the human is always the spawn gate."
+ - q: "How is a role manifest different from just sharing a prompt?"
+ a: "A prompt is one ingredient. A hire manifest is the whole recipe: which provider runs it, the model, the command flags, the goal, the capability tags, and the budget — mapped 1:1 onto the fields the app's Add-Agent flow already uses. It's the difference between a sentence in a README and a job description you can hand to anyone's office."
+ - q: "What is The Hiring Fair?"
+ a: "A static community gallery at munderdiffl.in/hires — no login, no trackers, MIT-licensed. It's stocked with ready-made roles from the cast: Pam writes docs, Dwight enforces QA, Jim reviews PRs, Creed audits security, Angela audits the office's own token spend, Stanley does the migrations nobody wants. Each card has a Claude Code / Antigravity / Codex toggle and function filters. Browse, hire, review, spawn."
+ - q: "Can I submit my own roles to The Hiring Fair today?"
+ a: "Not yet. Today, curation is a maintainer commit — there is deliberately no public write or submission pipeline. A community submission queue needs its own review-and-trust design, so we scoped it out of this first release rather than ship it half-built."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>A well-configured agent <strong>role</strong> is real work — the right provider, model, flags, goal prompt, capabilities, and budget — and today that knowledge is trapped in one person's setup. Munder Difflin v0.2.8 makes a role a <strong>portable artifact</strong>: a small JSON manifest we call a <strong>hire</strong> (a job description as a file). You hire from a <strong>link</strong> or a <strong>file</strong>, and the Add-Agent modal opens <em>pre-filled</em> — but <strong>import never spawns anything</strong>; you review every field and you press spawn. Browse ready-made roles at <strong>The Hiring Fair</strong> (<a href="https://munderdiffl.in/hires/">munderdiffl.in/hires</a>). The thesis: portable roles create a community growth loop, the way package registries did for libraries.</p></div>
+
+There's a moment, the first time you open a fresh agent floor, where the hard part isn't running an agent — it's *configuring* one. Which provider? Which model? What flags? And the question that actually stalls people: what is this thing's *job*? Writing a role from a blank box is a steep first step, and it's the step that stands between a curious newcomer and watching a single agent do a single useful thing.
+
+This post is about a small idea with an outsized payoff: **make an agent role a portable artifact** — something you can hand to someone, the way you'd hand them a file. In v0.2.8 we shipped that idea as **Shareable Hires**, and a gallery to share them in, called **The Hiring Fair**. Here's why portable roles matter, what the format encodes, and the trust design that makes "hire from a link" both easy and safe.
+
+## The problem: a good role is tacit knowledge
+
+Spin up an agent that's genuinely good at one job — say, reviewing pull requests — and notice how much of the value is *configuration*, not code. You picked a provider. You picked a model that's strong enough for the task but not wastefully expensive ([the clone army trap](/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/) is what happens when you skip this). You set command flags. You wrote a goal prompt sharp enough that the agent doesn't need a follow-up question. You gave it the right capabilities and a token budget so it can't quietly torch your bill.
+
+That's a real, hard-won bundle of decisions. And right now, it lives in exactly one place: your setup. If a teammate wants the same PR reviewer, your options are bad. You can write a tutorial — paragraphs of "set the model to X, add these flags, here's the prompt I use" — and hope they transcribe it correctly. Or you can screen-share and walk them through the dialog field by field.
+
+Either way, **you can't just hand someone a role.** The knowledge is tacit: trapped in one person's head, or buried in prose that goes stale the moment a default changes. For a newcomer, "write an orchestrator prompt from scratch" is the worst possible first task — it asks for expertise before they've earned any. The thing that should be a starting point is instead a wall.
+
+## The idea: a role as a file you can pass around
+
+The fix is to stop describing roles and start *packaging* them. A **hire** is a small JSON manifest — format id `munder-difflin/hire@1` — that captures a role-configured agent in full:
+
+- a **name** and an **avatar/sprite** (the pixel face on the floor),
+- a **provider** — Claude Code, Antigravity (Gemini, `agy`), or Codex,
+- a **model** and the **command flags** it runs with,
+- a **goal / role description** — what this coworker is here to do,
+- **capability tags** — what it's good at, so it's filterable,
+- and a **token budget** — a spend ceiling baked in.
+
+Think of it as a **job description as a file.** The manifest isn't a new runtime or a clever new way to start agents — it maps **1:1 onto what the app's Add-Agent flow already does**. Every field above is a field the dialog already has. So a hire is, very precisely, a *pre-filled version of the form you've always used*. Nothing new spawns it; it's just a portable starting point for the same flow.
+
+### What one looks like
+
+Here's an *illustrative* manifest (realistic fields, but don't copy-paste it as gospel — it's a teaching example, not a spec):
+
+```json
+{
+ "format": "munder-difflin/hire@1",
+ "name": "Jim",
+ "sprite": "jim",
+ "provider": "claude-code",
+ "model": "claude-sonnet",
+ "flags": ["--permission-mode", "plan"],
+ "goal": "Review open pull requests. Read the diff against the base branch, flag correctness bugs, risky side effects, and missing tests. Comment with specifics; do not merge.",
+ "capabilities": ["code-review", "testing", "git"],
+ "tokenBudget": 200000
+}
+```
+
+Read it top to bottom and it tells you everything: *who* (Jim, the PR reviewer), *what runs it* (Claude Code on a mid-tier model), *how it behaves* (plan mode, so it proposes before acting), *what it's for* (the goal), *what it's good at* (the tags), and *how much it's allowed to spend* (the budget). That's the entire role, and it fits in a screenshot. The point of the format is exactly that legibility: a role you can read, diff, and reason about — not a black box.
+
+## Two ways to hire, one pipeline
+
+There are two front doors, and they both lead to the same place.
+
+- **Deep link.** A `munderdifflin://hire?src=<https-url>` link — the kind behind a ⚡hire button in the gallery — opens the app and fetches the manifest, then opens the **Add-Agent modal pre-filled**. One click from a web page to a populated form.
+- **File import.** An *import hire…* button in the Add-Agent modal reads a local `.hire.json` file. Same destination: the form, pre-filled.
+
+The two doors exist because the two situations are different — clicking a button in a browser versus opening a file someone sent you — but they converge immediately. Both end at one modal, one review, one spawn button. There's deliberately not a second mechanism to maintain.
+
+## The trust design: import never spawns
+
+This is the heart of the UX, and it's a single, load-bearing rule: **importing a hire never spawns anything.** Whether it arrives by deep link or file, an imported manifest only ever *pre-fills the Add-Agent modal*, behind an explicit "imported" banner so you always know this config came from outside. You review every field — the goal, the flags, the budget — and **you** click spawn. A role you got from the internet is inert data until a human acts on it. The human is the spawn gate, every time.
+
+A few properties make that guarantee real rather than aspirational: there's **no executable in the format** — a manifest names a provider preset, and the actual binary always comes from your own local install, never the file (`provider: "custom"` is rejected outright). The import is **validated and bounded**, so a malformed or oversized manifest is refused, not trusted. The mechanics of treating a downloaded manifest as untrusted input — the validation, the bounds, the threat model — get their own [security deep-dive](/blog/hire-manifest-untrusted-input/); here the takeaway is the principle. **Portability and safety aren't in tension** as long as import is data-only and a human owns the spawn. You can share a role freely *because* sharing it can't, by construction, run anything.
+
+## The Hiring Fair: a gallery of ready-made roles
+
+Portable roles are more fun when there's somewhere to get them. **The Hiring Fair** is a static community gallery at [munderdiffl.in/hires](https://munderdiffl.in/hires/) — no login, no trackers, MIT-licensed — stocked with roles from the cast:
+
+- **Pam** writes docs.
+- **Dwight** enforces QA (relentlessly).
+- **Jim** reviews PRs.
+- **Creed** audits security.
+- **Angela** audits the office's *own* token spend — the accountant for your agents.
+- **Stanley** does the migrations nobody wants to touch.
+
+Each card carries one **base manifest per role**, with **per-provider variants generated** so you can flip a Claude Code / Antigravity / Codex toggle and get the same role configured for whichever CLI you run. **Function filters** let you find roles by what they do — review, docs, security, ops — instead of scrolling. Browse, hit ⚡hire, land in the pre-filled modal, review, spawn.
+
+One honest scope note: **today, curation is a maintainer commit.** There is deliberately *no public write or submission pipeline yet*. You can browse and hire, but you can't push your own role into the gallery — that has to come through a maintainer. That's a real cut, and an intentional one: a community submission queue is its own design problem (who reviews, what's trusted, how you keep a public gallery from becoming an attack surface), and it deserves its own treatment rather than being bolted on half-built. The format is portable today; the *open submission loop* is the next conversation, not this one.
+
+## Why it matters: a registry for roles
+
+Here's the thesis. Once a role is a portable artifact, something compounding happens — a **community growth loop**. The best-tuned roles can be shared, then forked, then improved, then shared again. The person who finally nails the "security auditor" prompt doesn't keep that win to themselves and doesn't bury it in a blog post; they export a hire, and everyone downstream starts from their best version instead of from a blank box. Good configuration stops being a thing each person rediscovers and becomes a thing the community *accumulates*.
+
+This is the same move package registries made for code. Before npm or PyPI, reusing a library meant copying files and re-reading install instructions; the registry turned "here's how you set it up" into "here's the artifact, take it." Shareable Hires does that for agent *roles*. "Hire Pam" becomes the easy on-ramp that "write a system prompt" never was — and the floor that the [GOD orchestrator](/blog/how-the-god-orchestrator-works/) coordinates can fill up with proven coworkers instead of guesses.
+
+It also fits the broader bet behind Munder Difflin: **local-first, open-source, you own your floor.** The roles are MIT, the gallery has no login or trackers, the binary that runs an agent is always your own, and the human is always the one who hits spawn. Portability here doesn't mean handing control to a cloud — it means handing a *file* to a person, who stays in charge of what they do with it. (For why we [built it this way](/blog/why-we-built-munder-difflin/) in the first place, the origin story has the rest.)
+
+## Go browse The Hiring Fair
+
+The fastest way to feel the idea is to use it. Open [The Hiring Fair](https://munderdiffl.in/hires/), pick a role that matches something on your plate, flip it to your provider, and hire it — then read every field in the modal before you spawn, because that review step is the whole point.
+
+- [Launching Munder Difflin v0.2.8: Shareable Hires](/blog/launching-munder-difflin-v0-2-8/) — the release.
+- [The hire manifest as untrusted input](/blog/hire-manifest-untrusted-input/) — the security deep-dive on the trust model.
+- [Inside the GOD orchestrator](/blog/how-the-god-orchestrator-works/) — who coordinates the roles you hire.
+- [The clone army trap](/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/) — why a *mix* of well-chosen roles beats ten identical agents.
+- [Why we built Munder Difflin](/blog/why-we-built-munder-difflin/) — the origin story.
+- [CHANGELOG](https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md) — everything that shipped.
diff --git a/docs/blog/agents-rule-of-two/index.html b/docs/blog/agents-rule-of-two/index.html
index d8542b45..2eb5c693 100644
--- a/docs/blog/agents-rule-of-two/index.html
+++ b/docs/blog/agents-rule-of-two/index.html
@@ -276,25 +276,25 @@ open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -303,29 +303,29 @@ open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/ai-agent-glossary/index.html b/docs/blog/ai-agent-glossary/index.html
index a250e8e8..cdfba8cc 100644
--- a/docs/blog/ai-agent-glossary/index.html
+++ b/docs/blog/ai-agent-glossary/index.html
@@ -248,25 +248,25 @@ 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/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -275,29 +275,29 @@ Munder Difflin</a> to see the glossary come to life — free and open source.</p
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/append-only-event-log-agents/index.html b/docs/blog/append-only-event-log-agents/index.html
index 843df6f2..9b356678 100644
--- a/docs/blog/append-only-event-log-agents/index.html
+++ b/docs/blog/append-only-event-log-agents/index.html
@@ -286,56 +286,56 @@ it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/architecture-two-planes-one-renderer/index.html b/docs/blog/architecture-two-planes-one-renderer/index.html
index 32c08675..a94ba379 100644
--- a/docs/blog/architecture-two-planes-one-renderer/index.html
+++ b/docs/blog/architecture-two-planes-one-renderer/index.html
@@ -289,43 +289,43 @@ free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/observability-for-agent-fleets/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
@@ -334,11 +334,11 @@ free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>4 min</span>
</div>
- <h3><a href="/blog/observability-for-agent-fleets/">Observability for Agent Fleets: Seeing What Your Agents Do</a></h3>
- <p class="dek">Agent fleet observability: the four questions your dashboard must answer about who&#39;s working, what they&#39;re doing, what it costs, and what they know.</p>
+ <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
+ <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/observability-for-agent-fleets/" aria-label="Read: Observability for Agent Fleets: Seeing What Your Agents Do">Read →</a>
+ <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/atomic-file-mailboxes-for-agents/index.html b/docs/blog/atomic-file-mailboxes-for-agents/index.html
index ce59d1dc..57f87aba 100644
--- a/docs/blog/atomic-file-mailboxes-for-agents/index.html
+++ b/docs/blog/atomic-file-mailboxes-for-agents/index.html
@@ -301,56 +301,56 @@ the office floor; it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
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 1e271195..ce987450 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
@@ -344,56 +344,56 @@ to watch many real terminals at once; it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/building-an-ai-office-floor/index.html b/docs/blog/building-an-ai-office-floor/index.html
index 2f80ba9c..48ec58fd 100644
--- a/docs/blog/building-an-ai-office-floor/index.html
+++ b/docs/blog/building-an-ai-office-floor/index.html
@@ -289,56 +289,56 @@ techniques — the hard part is wiring them to <em>real</em> agent events, not t
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/can-claude-code-agents-talk-to-each-other/index.html b/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
index 7ad8d0e1..3d984a3b 100644
--- a/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
+++ b/docs/blog/can-claude-code-agents-talk-to-each-other/index.html
@@ -286,25 +286,25 @@ other; it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -313,29 +313,29 @@ other; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/claude-code-hooks-explained/index.html b/docs/blog/claude-code-hooks-explained/index.html
index 7c64fbbc..6e0b2e4c 100644
--- a/docs/blog/claude-code-hooks-explained/index.html
+++ b/docs/blog/claude-code-hooks-explained/index.html
@@ -303,56 +303,56 @@ free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/compressing-agent-memory/index.html b/docs/blog/compressing-agent-memory/index.html
index 7276440b..25ca1461 100644
--- a/docs/blog/compressing-agent-memory/index.html
+++ b/docs/blog/compressing-agent-memory/index.html
@@ -271,43 +271,43 @@ without forgetting; it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/observability-for-agent-fleets/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
@@ -316,11 +316,11 @@ without forgetting; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>4 min</span>
</div>
- <h3><a href="/blog/observability-for-agent-fleets/">Observability for Agent Fleets: Seeing What Your Agents Do</a></h3>
- <p class="dek">Agent fleet observability: the four questions your dashboard must answer about who&#39;s working, what they&#39;re doing, what it costs, and what they know.</p>
+ <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
+ <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/observability-for-agent-fleets/" aria-label="Read: Observability for Agent Fleets: Seeing What Your Agents Do">Read →</a>
+ <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/deploy-a-blog-writer-agent/index.html b/docs/blog/deploy-a-blog-writer-agent/index.html
index 40106fe7..bce6eb56 100644
--- a/docs/blog/deploy-a-blog-writer-agent/index.html
+++ b/docs/blog/deploy-a-blog-writer-agent/index.html
@@ -287,7 +287,7 @@ floor; it’s free and open source.</p>
<footer class="post-foot wrap"><div class="prevnext">
<a class="pn prev" href="/blog/deploy-automated-pr-reviewer-agent/"><span class="k">← Older</span><span class="t">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</span></a>
- <span></span>
+ <a class="pn next" href="/blog/shareable-agent-roles/"><span class="k">Newer →</span><span class="t">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</span></a>
</div>
<section class="related">
<h2>Related in Use Cases</h2>
diff --git a/docs/blog/do-more-with-less-model-routing/index.html b/docs/blog/do-more-with-less-model-routing/index.html
index bb7a78dc..3629df1b 100644
--- a/docs/blog/do-more-with-less-model-routing/index.html
+++ b/docs/blog/do-more-with-less-model-routing/index.html
@@ -275,25 +275,25 @@ agent team that does more with less — it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -302,29 +302,29 @@ agent team that does more with less — it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/feed.xml b/docs/blog/feed.xml
index d6f90dc5..9dbae894 100644
--- a/docs/blog/feed.xml
+++ b/docs/blog/feed.xml
@@ -4,9 +4,33 @@
<subtitle>Guides, deep dives, and comparisons on running multi-agent Claude Code: orchestration, agent memory, automation, and the tooling landscape.</subtitle>
<link href="https://munderdiffl.in/blog/feed.xml" rel="self" />
<link href="https://munderdiffl.in/blog/" />
- <updated>2026-06-10T00:00:00.000Z</updated>
+ <updated>2026-06-15T00:00:00.000Z</updated>
<id>https://munderdiffl.in/blog/</id>
<author><name>Chaitanya Giri</name><uri>https://munderdiffl.in</uri></author>
+ <entry>
+ <title>Treating a Hire Manifest as Untrusted Input</title>
+ <link href="https://munderdiffl.in/blog/hire-manifest-untrusted-input/" />
+ <id>https://munderdiffl.in/blog/hire-manifest-untrusted-input/</id>
+ <published>2026-06-15T00:00:00.000Z</published>
+ <updated>2026-06-15T00:00:00.000Z</updated><category term="Internals" />
+ <summary>A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</summary>
+ </entry>
+ <entry>
+ <title>Launching Munder Difflin v0.2.8: Shareable Hires</title>
+ <link href="https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/" />
+ <id>https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/</id>
+ <published>2026-06-15T00:00:00.000Z</published>
+ <updated>2026-06-15T00:00:00.000Z</updated><category term="Story" />
+ <summary>Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</summary>
+ </entry>
+ <entry>
+ <title>Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</title>
+ <link href="https://munderdiffl.in/blog/shareable-agent-roles/" />
+ <id>https://munderdiffl.in/blog/shareable-agent-roles/</id>
+ <published>2026-06-15T00:00:00.000Z</published>
+ <updated>2026-06-15T00:00:00.000Z</updated><category term="Concepts" />
+ <summary>Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</summary>
+ </entry>
<entry>
<title>Deploy a Blog-Writer Agent: The One That Wrote This Post</title>
<link href="https://munderdiffl.in/blog/deploy-a-blog-writer-agent/" />
@@ -463,28 +487,4 @@
<updated>2026-06-04T00:00:00.000Z</updated><category term="Concepts" />
<summary>When do AI agents need a protocol like MCP or A2A? Agents you own coordinate fine with file mailboxes; protocols earn their keep across boundaries.</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/" />
- <id>https://munderdiffl.in/blog/building-a-terminal-ui-xterm-node-pty/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Internals" />
- <summary>Wire xterm.js to a node-pty backend: stream output, write keystrokes back, handle resize, and keep many live terminals fast with a terminal pool.</summary>
- </entry>
- <entry>
- <title>Building an AI &quot;Office Floor&quot;: Avatars, Pathfinding, Envelopes</title>
- <link href="https://munderdiffl.in/blog/building-an-ai-office-floor/" />
- <id>https://munderdiffl.in/blog/building-an-ai-office-floor/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Internals" />
- <summary>The game-dev techniques behind a dev tool&#39;s office floor: Tiled maps, BFS pathfinding, sprite recoloring, and flying message envelopes in Pixi.js.</summary>
- </entry>
- <entry>
- <title>Claude Code Hooks, Explained (PreToolUse, PostToolUse, Stop)</title>
- <link href="https://munderdiffl.in/blog/claude-code-hooks-explained/" />
- <id>https://munderdiffl.in/blog/claude-code-hooks-explained/</id>
- <published>2026-06-03T00:00:00.000Z</published>
- <updated>2026-06-03T00:00:00.000Z</updated><category term="Internals" />
- <summary>A practical tour of Claude Code hooks — the PreToolUse, PostToolUse, and Stop lifecycle — and how a Unix-socket hook shim drives a live office floor.</summary>
- </entry>
</feed>
diff --git a/docs/blog/file-based-coordination-vs-message-queues/index.html b/docs/blog/file-based-coordination-vs-message-queues/index.html
index 2cfca2b6..54d756d0 100644
--- a/docs/blog/file-based-coordination-vs-message-queues/index.html
+++ b/docs/blog/file-based-coordination-vs-message-queues/index.html
@@ -262,56 +262,56 @@ durable, git-versioned, and debuggable by just looking.
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/observability-for-agent-fleets/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/observability-for-agent-fleets/">Observability for Agent Fleets: Seeing What Your Agents Do</a></h3>
- <p class="dek">Agent fleet observability: the four questions your dashboard must answer about who&#39;s working, what they&#39;re doing, what it costs, and what they know.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/observability-for-agent-fleets/" aria-label="Read: Observability for Agent Fleets: Seeing What Your Agents Do">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/generative-engine-optimization-techniques/index.html b/docs/blog/generative-engine-optimization-techniques/index.html
index cc277523..287e6936 100644
--- a/docs/blog/generative-engine-optimization-techniques/index.html
+++ b/docs/blog/generative-engine-optimization-techniques/index.html
@@ -280,25 +280,25 @@ and quotable. <a href="/#install">Download Munder Difflin</a> to see it; free an
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -307,29 +307,29 @@ and quotable. <a href="/#install">Download Munder Difflin</a> to see it; free an
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/hire-manifest-untrusted-input/index.html b/docs/blog/hire-manifest-untrusted-input/index.html
new file mode 100644
index 00000000..31a86bb0
--- /dev/null
+++ b/docs/blog/hire-manifest-untrusted-input/index.html
@@ -0,0 +1,386 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Treating a Hire Manifest as Untrusted Input — Munder Difflin Blog</title>
+<meta name="description" content="A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch." />
+<link rel="canonical" href="https://munderdiffl.in/blog/hire-manifest-untrusted-input/" />
+
+<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="Treating a Hire Manifest as Untrusted Input — Munder Difflin Blog" />
+<meta property="og:description" content="A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch." />
+<meta property="og:url" content="https://munderdiffl.in/blog/hire-manifest-untrusted-input/" />
+<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-15T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Security" />
+<meta property="article:tag" content="Internals" />
+<meta property="article:tag" content="Electron" />
+<meta property="article:tag" content="Command Injection" />
+<meta property="article:tag" content="SSRF" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Treating a Hire Manifest as Untrusted Input — Munder Difflin Blog" />
+<meta name="twitter:description" content="A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch." />
+<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": "Treating a Hire Manifest as Untrusted Input",
+ "description": "A shareable agent-config manifest is attacker input. How Munder Difflin's import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-15T00:00:00.000Z",
+ "dateModified": "2026-06-15T00: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/hire-manifest-untrusted-input/" },
+ "keywords": "untrusted input agent config, command injection electron, ssrf deep link, default-deny allowlist, shareable agent config security, cmd.exe argument quoting",
+ "articleSection": "Internals",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/hire-manifest-untrusted-input/"
+}
+</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": "Treating a Hire Manifest as Untrusted Input", "item": "https://munderdiffl.in/blog/hire-manifest-untrusted-input/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "Why is a shareable agent-config file a security problem?", "acceptedAnswer": { "@type": "Answer", "text": "Because importing one is the same trust event as opening any link or downloading any file: the bytes are attacker-controlled. A 'hire' manifest is a JSON document you get by clicking a munderdifflin:// link or saving a file someone sent you. If any field in it can influence what process runs, what flags get passed, or what URL the app fetches, then a manifest is no longer data — it's an action an attacker triggers on your machine. So the import pipeline is built as a security boundary, not a convenience." } },
+ { "@type": "Question", "name": "Can importing a hire manifest spawn an agent on its own?", "acceptedAnswer": { "@type": "Answer", "text": "No. Import only pre-fills the Add-Agent modal behind an 'imported' banner. The agent spawns solely when the human clicks submit in that modal. There is no code path that spawns on import — the manifest is data that proposes a configuration; the human is always the spawn gate." } },
+ { "@type": "Question", "name": "Can a manifest choose what program runs?", "acceptedAnswer": { "@type": "Answer", "text": "No. There is no command or executable field in the schema. The binary always comes from the user's locally configured provider preset — claude, antigravity, or codex. provider: \"custom\" is rejected outright. A manifest can only select among providers you already installed; it can never name a new program to run." } },
+ { "@type": "Question", "name": "Why an allowlist for command flags instead of blocking the dangerous ones?", "acceptedAnswer": { "@type": "Answer", "text": "Because the manifest's provider is attacker-chosen and each CLI keeps adding flags, a denylist is a bet that you enumerated every dangerous value — and it drifts and leaks as the tools evolve (ours leaked across three review rounds). A default-deny allowlist (SAFE_FLAG_NAMES) is a bet that you enumerated every safe value, and the safe set is small and stable. For attacker-controlled input, allowlist beats denylist." } },
+ { "@type": "Question", "name": "How does the deep-link fetch avoid SSRF?", "acceptedAnswer": { "@type": "Answer", "text": "The fetch is https-only (plain http allowed only for loopback, for local gallery dev), follows redirects manually and re-validates every Location hop against the same https/loopback allowlist (capped at 5 hops), resolves and blocks private/loopback/link-local addresses including the 169.254.169.254 cloud-metadata endpoint, and streams the body through a bounded reader that aborts past 64 KB with a 10s timeout. A remote page can never redirect the app into http://127.0.0.1 or a metadata IP, and a hostile host can't OOM the main process by streaming an unbounded body." } },
+ { "@type": "Question", "name": "What risk is still left after all this?", "acceptedAnswer": { "@type": "Answer", "text": "Free-text fields — goal and description — pre-fill the prompt the agent will run on, which is a prompt-injection surface. v1 accepts this because the human reviews every field before spawning and the binary and flags are locked down. The human remains the spawn gate; the manifest can suggest a task, but a person decides to run it." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/internals/">Internals</a>
+ </nav>
+ <h1>Treating a Hire Manifest as Untrusted Input</h1>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</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-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>12 min read</span>
+ <span class="tag kind">Internals</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p>In v0.2.8 we shipped <strong>shareable hires</strong> — JSON manifests that configure an agent role and travel by link. A manifest is <strong>attacker-controlled input</strong> (you click a link, you download a file), so the import pipeline is a <strong>security boundary</strong>. The defenses: <strong>import never spawns</strong> (it only pre-fills a modal the human submits); <strong>no executable field</strong> (the binary comes from your own provider presets, <code>custom</code> is rejected); a <strong>default-deny flag allowlist</strong> (allowlist &gt; denylist for hostile input); strict charset validation on every stringly-typed field <em>plus</em> a hardened <code>cmd.exe</code> quoter at the sink; and an <strong>SSRF-safe, bounded fetch</strong> that re-validates every redirect hop and caps the body at 64 KB. Validate at the boundary <em>and</em> quote at the sink — defense in depth, both layers.</p></div>
+<p>A shareable hire is a nice feature with a sharp edge. You see a link — <code>munderdifflin://hire?src=https://gallery.example/pr-reviewer.json</code> — you click it, and the Add-Agent modal opens pre-filled with a tidy “PR Reviewer” role: a sprite, a model, a goal, a couple of flags. One more click and it’s on your office floor. The convenience is the whole point. The problem is that everything in that manifest came from <em>someone else</em>.</p>
+<p>That makes a hire manifest the same category of thing as a downloaded file or a clicked URL: <strong>attacker-controlled input</strong>. Nobody audits a JSON file before importing it any more than they read a <code>.dmg</code> before opening it. So the import pipeline can’t treat the manifest as a trusted config object. It has to treat it as hostile bytes and prove, field by field, that nothing in it can turn into an <em>action</em> on your machine. This post is the threat model and the defense-in-depth that came out of a two-round security review — including one HIGH-severity bug that turned a clicked link into arbitrary code execution on Windows.</p>
+<h2 id="the-shape-of-the-feature" tabindex="-1">The shape of the feature <a class="anchor" href="#the-shape-of-the-feature" aria-hidden="true">#</a></h2>
+<p>A “hire” is a JSON manifest tagged <code>munder-difflin/hire@1</code>. The interesting fields:</p>
+<pre class="language-json"><code class="language-json"><span class="token punctuation">{</span>
+ <span class="token property">"spec"</span><span class="token operator">:</span> <span class="token string">"munder-difflin/hire@1"</span><span class="token punctuation">,</span>
+ <span class="token property">"name"</span><span class="token operator">:</span> <span class="token string">"PR Reviewer"</span><span class="token punctuation">,</span>
+ <span class="token property">"sprite"</span><span class="token operator">:</span> <span class="token string">"dwight"</span><span class="token punctuation">,</span>
+ <span class="token property">"provider"</span><span class="token operator">:</span> <span class="token string">"claude"</span><span class="token punctuation">,</span>
+ <span class="token property">"model"</span><span class="token operator">:</span> <span class="token string">"claude-sonnet-4-6"</span><span class="token punctuation">,</span>
+ <span class="token property">"commandFlags"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token string">"--verbose"</span><span class="token punctuation">]</span><span class="token punctuation">,</span>
+ <span class="token property">"goal"</span><span class="token operator">:</span> <span class="token string">"Review open PRs and leave inline comments."</span><span class="token punctuation">,</span>
+ <span class="token property">"capabilities"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token string">"read"</span><span class="token punctuation">,</span> <span class="token string">"comment"</span><span class="token punctuation">]</span><span class="token punctuation">,</span>
+ <span class="token property">"tokenCap"</span><span class="token operator">:</span> <span class="token number">200000</span><span class="token punctuation">,</span>
+ <span class="token property">"isolate"</span><span class="token operator">:</span> <span class="token boolean">true</span>
+<span class="token punctuation">}</span></code></pre>
+<p><code>provider</code> must be one of <code>claude</code> | <code>antigravity</code> | <code>codex</code>. There are two ways a manifest gets in: a <code>munderdifflin://hire?src=&lt;https-url&gt;</code> deep link, which the Electron <strong>main</strong> process fetches and validates, and a plain local-file import. Both paths funnel into <strong>one</strong> validator (<code>src/shared/hire.ts</code>) and end at the same place: the Add-Agent modal, pre-filled.</p>
+<p>The single most important property of the whole design falls out of that last sentence.</p>
+<h2 id="trust-boundary-1-import-never-spawns" tabindex="-1">Trust boundary #1: import never spawns <a class="anchor" href="#trust-boundary-1-import-never-spawns" aria-hidden="true">#</a></h2>
+<p><strong>The manifest is data, never an action.</strong> Importing a hire does exactly one thing — it pre-fills the Add-Agent modal, behind an “imported” banner that tells you these values came from outside. It does not start anything. The agent spawns only when <em>you</em> click submit in that modal, after the fields are sitting in front of you.</p>
+<p>There is no code path — not the deep link, not the file import, not a malformed-but-clever payload — that spawns an agent as a side effect of import. This is the cleanest defense there is, because it makes the human the spawn gate by construction. Every other layer below is about ensuring that the <em>configuration</em> a manifest proposes is safe to hand to a person for one-click approval. But even if a field slipped through, nothing runs until a human says so. Import proposes; the human disposes.</p>
+<h2 id="no-executable-field" tabindex="-1">No executable field <a class="anchor" href="#no-executable-field" aria-hidden="true">#</a></h2>
+<p>The second structural defense is an absence. <strong>There is no <code>command</code> or <code>executable</code> field in the schema.</strong> A manifest cannot name the program that runs. The binary always comes from the user’s <strong>locally configured provider preset</strong> — the <code>claude</code>, <code>agy</code>, or <code>codex</code> you installed and pointed the app at. <code>provider: &quot;custom&quot;</code> is rejected by the validator outright, precisely because a custom provider is a user-side escape hatch for naming an arbitrary binary, and we will not let a downloaded file reach through it.</p>
+<p>So the worst a manifest can do on the “what runs” axis is <em>select among providers you already trust</em>. It picks <code>claude</code> or <code>codex</code>; it cannot introduce <code>curl</code> or <code>/bin/sh</code>. That shrinks the attack surface to the <em>arguments</em> passed to a binary you already chose to install — which is exactly where the interesting bug lived.</p>
+<h2 id="the-high-severity-bug-windows-command-injection-via-model" tabindex="-1">The HIGH-severity bug: Windows command injection via <code>model</code> <a class="anchor" href="#the-high-severity-bug-windows-command-injection-via-model" aria-hidden="true">#</a></h2>
+<p>The first review found it. <code>commandFlags</code> were validated tightly from day one — but <code>model</code> was only <strong>length-capped</strong>, never <strong>shape-checked</strong>. And <code>model</code> is not inert: it flows onto the spawn command line as <code>--model &lt;model&gt;</code>, quoted only if it contained whitespace.</p>
+<p>That “quoted only if it contained whitespace” is the whole bug. Consider this manifest field:</p>
+<pre class="language-json"><code class="language-json"><span class="token property">"model"</span><span class="token operator">:</span> <span class="token string">"x&amp;calc"</span></code></pre>
+<p>No whitespace, so the spawn logic passed it through unquoted. On macOS and Linux that’s harmless — argv goes straight to <code>node-pty</code>, no shell is involved, and <code>x&amp;calc</code> is just one literal (nonsense) argument. But on <strong>Windows</strong>, when the provider binary is a <code>.cmd</code> or <code>.bat</code> shim — which is the <strong>default</strong> for an npm-installed <code>claude</code> / <code>agy</code> / <code>codex</code> — Node routes the spawn through <code>cmd.exe /d /s /c</code>. And <code>cmd.exe</code>’s argument quoter, at the time, only escaped space, tab, and <code>&quot;</code>. It did <strong>not</strong> escape <code>cmd</code> metacharacters like <code>&amp;</code>. So the command line became:</p>
+<pre class="language-text"><code class="language-text">claude --model x & calc</code></pre>
+<p><code>cmd.exe</code> reads <code>&amp;</code> as a command separator. It runs <code>claude --model x</code>, then runs <code>calc</code>. One clicked <code>munderdifflin://hire</code> link → arbitrary code execution.</p>
+<p>This is the classic failure mode for untrusted input, and worth naming precisely: <strong>untrusted JSON is supposed to stay inert, but a stringly-typed field leaked out of the data plane and into a shell.</strong> <code>commandFlags</code> got the scrutiny because it <em>looked</em> dangerous; <code>model</code> looked like a harmless label, so it was only length-checked — and a label that reaches a command line is not a label, it’s an argument, and on Windows an argument that reaches <code>cmd.exe</code> is potentially a command.</p>
+<h2 id="the-two-layer-fix-do-both" tabindex="-1">The two-layer fix (do both) <a class="anchor" href="#the-two-layer-fix-do-both" aria-hidden="true">#</a></h2>
+<p>The fix is deliberately redundant, because the two layers fail differently and a defense-in-depth posture wants both.</p>
+<p><strong>Layer 1 — validate at the boundary.</strong> Constrain <code>model</code> to a safe charset so a hostile value never makes it past the validator in the first place:</p>
+<pre class="language-js"><code class="language-js"><span class="token keyword">const</span> <span class="token constant">MODEL_RE</span> <span class="token operator">=</span> <span class="token regex"><span class="token regex-delimiter">/</span><span class="token regex-source language-regex">^[A-Za-z0-9 ._()[\]\/:@+-]{1,80}$</span><span class="token regex-delimiter">/</span></span><span class="token punctuation">;</span></code></pre>
+<p><code>&amp;</code> is not in that class. Neither is <code>| ^ &lt; &gt; ; $ % \</code> &quot; '<code>. The PoC </code>x&amp;calc<code>fails</code>MODEL_RE.test(model)<code>and the import is rejected with a validation error. This restores the invariant that *untrusted JSON stays inert* — a malicious</code>model` can’t even reach the modal, let alone a spawn.</p>
+<p><strong>Layer 2 — quote at the sink.</strong> Harden the Windows <code>cmd.exe</code> argument quoter so it also quotes any token containing <code>&amp; | ^ &lt; &gt; ( ) % !</code>. This is the belt to the validation suspenders, and it’s broader than the hire feature: it guards <strong>every</strong> spawn path in the app, not just imported manifests. If some <em>other</em> future field ever leaks a metacharacter onto a command line, the quoter catches it even if a validator forgot to.</p>
+<p>Why both? Because they protect against different mistakes. Validation is the <em>specific</em> fix — it knows <code>model</code> should look like a model id. The quoter is the <em>general</em> fix — it knows that no argument, from any source, should be able to break out of its slot on a Windows command line. Either one alone closes the PoC; together they mean a single forgotten check on one field is not, by itself, a code-execution bug. <strong>Validate at the boundary and quote at the sink</strong> is one of the durable lessons here.</p>
+<h2 id="default-deny-the-flag-allowlist" tabindex="-1">Default-deny: the flag allowlist <a class="anchor" href="#default-deny-the-flag-allowlist" aria-hidden="true">#</a></h2>
+<p><code>commandFlags</code> is the field most obviously capable of mischief, and it’s where the review process taught the cleanest lesson. The first version used a <strong>denylist</strong> — a set of dangerous flags to reject (<code>--dangerously-*</code>, settings overrides, MCP config, and so on). It was reasonable, and it leaked.</p>
+<p>It leaked because the manifest’s <code>provider</code> is attacker-chosen, and each CLI — claude, agy, codex — keeps adding flags release over release. A denylist is a snapshot of “every bad flag we could think of,” and the moment a CLI ships a new dangerous flag (or you discover a <code>codex</code>/<code>agy</code> superset gap you’d missed), the denylist has a hole. Ours leaked across <strong>three</strong> review rounds: each round found another flag — a config-override here, a base-URL redirect there — that the denylist didn’t know to block.</p>
+<p>So we flipped it. <code>commandFlags</code> is now a <strong>default-deny allowlist</strong>. Every flag-shaped token has to clear two gates:</p>
+<pre class="language-js"><code class="language-js"><span class="token keyword">const</span> <span class="token constant">FLAG_RE</span> <span class="token operator">=</span> <span class="token regex"><span class="token regex-delimiter">/</span><span class="token regex-source language-regex">^[A-Za-z0-9._\/=:,@+-]{1,100}$</span><span class="token regex-delimiter">/</span></span><span class="token punctuation">;</span> <span class="token comment">// no whitespace, no shell metachars, no % env-expansion</span>
+<span class="token keyword">const</span> <span class="token constant">SAFE_FLAG_NAMES</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Set</span><span class="token punctuation">(</span><span class="token punctuation">[</span> <span class="token comment">/* a small, curated set of known-harmless flags */</span> <span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span></code></pre>
+<p>A token must (a) match <code>FLAG_RE</code> — so no whitespace, no shell metacharacters, no <code>%</code> (which would invite <code>cmd.exe</code> environment expansion) — <strong>and</strong> (b) have a flag name that’s in <code>SAFE_FLAG_NAMES</code>. Nothing system-prompt-related, settings-related, MCP-related, or provider/base-URL-related is ever allowlisted, because those are the flags that change <em>what the agent trusts</em> or <em>where it talks to</em>. And the args, once validated, go to <code>node-pty</code> as an <strong>argv array</strong> — never concatenated into a shell string.</p>
+<p>The general principle is worth stating plainly: <strong>for attacker-controlled input, an allowlist beats a denylist.</strong> A denylist is a bet that you enumerated every <em>bad</em> value — and that bet loses every time the world adds a new bad value you didn’t anticipate. An allowlist is a bet that you enumerated every <em>safe</em> value — and the safe set is small, well-understood, and changes slowly. When the input is hostile and the surface keeps growing, you want to be betting on the small stable set, not the unbounded one.</p>
+<h2 id="ssrf-safe-bounded-fetch" tabindex="-1">SSRF-safe, bounded fetch <a class="anchor" href="#ssrf-safe-bounded-fetch" aria-hidden="true">#</a></h2>
+<p>The deep link <code>munderdifflin://hire?src=&lt;url&gt;</code> hands the app a URL it will fetch from the <strong>main</strong> process — which has the network and the OS at its disposal. A naive fetch here is a classic server-side request forgery (SSRF) primitive: a remote page tells <em>your</em> app to make a request <em>you</em> didn’t intend. The transport (<code>src/main/hire.ts</code>) is hardened on three axes, each of which started out wrong in the first cut.</p>
+<h3 id="https-only-with-a-loopback-carve-out" tabindex="-1">https-only, with a loopback carve-out <a class="anchor" href="#https-only-with-a-loopback-carve-out" aria-hidden="true">#</a></h3>
+<p>The fetch is <strong>https-only</strong>. Plain <code>http</code> is allowed <em>only</em> for loopback, so the local hire-gallery dev server works over <code>http://127.0.0.1</code>. The carve-out is deliberately narrow: a remote, public page can never point the app at an <code>http://</code> target, so it can’t downgrade you onto an internal plaintext service.</p>
+<h3 id="redirect-ssrf-closed" tabindex="-1">Redirect SSRF, closed <a class="anchor" href="#redirect-ssrf-closed" aria-hidden="true">#</a></h3>
+<p>The first version used <code>fetch(url, { redirect: 'follow' })</code>. That validates only the <strong>initial</strong> URL — the final hop after a redirect is never re-checked. So an attacker hosts <code>https://evil.example/m.json</code>, the app validates <em>that</em> (it’s https, it’s public, fine), and then the server answers <code>302 Location: http://127.0.0.1:PORT/...</code> or <code>→ http://169.254.169.254/...</code> (the cloud-metadata endpoint). <code>fetch</code> follows the redirect, and the app has now made a request to an internal address it would never have accepted directly.</p>
+<p>The fix is to take over redirect handling:</p>
+<pre class="language-text"><code class="language-text">redirect: 'manual' // don't auto-follow
+for hop in 0..5: // cap at 5 hops
+ if status is 3xx:
+ loc = response Location header
+ next = new URL(loc, current)
+ if next.protocol !== 'https:' → reject // a hop may not drop into http/loopback
+ if !isPublicAddress(next.host) → reject // re-validate the resolved address
+ current = next; continue
+ else: this is the real response</code></pre>
+<p>Every <code>Location</code> is re-validated against the <strong>same</strong> https/public-address allowlist as the initial request, with a hard cap of ≤5 hops. <code>https → https</code> redirects (link shorteners, CDNs) still work; <code>https → http://127.0.0.1</code> and <code>https → 169.254.169.254</code> are dead. The same pass also closed an <strong>IPv6-bracket bypass</strong> in the host check — the host parser strips <code>[</code>/<code>]</code> before resolving, so <code>https://[::1]/</code> and friends can’t sneak a loopback address past a string comparison.</p>
+<h3 id="streamed-byte-cap" tabindex="-1">Streamed byte cap <a class="anchor" href="#streamed-byte-cap" aria-hidden="true">#</a></h3>
+<p>The first version trusted the <code>content-length</code> header, then did <code>await res.text()</code>. Two bugs in one line. First, it buffered the <strong>entire</strong> body before checking length — so a hostile host could just <em>not send</em> a <code>content-length</code> (or lie about it) and stream gigabytes, OOM-ing the main process. Second, <code>.length</code> on the resulting string counts UTF-16 code units, not bytes, so the cap it <em>did</em> apply was measuring the wrong thing.</p>
+<p>The fix is a bounded reader (<code>readBounded</code>) that streams the response and <strong>aborts the moment the accumulated byte count exceeds 64 KB</strong>, never trusting <code>content-length</code> as anything but a hint. A 10-second timeout bounds the time axis too. A manifest is a few hundred bytes of JSON; anything claiming to be megabytes is, by definition, not a hire.</p>
+<h2 id="one-validator-four-copies-in-sync" tabindex="-1">One validator, four copies in sync <a class="anchor" href="#one-validator-four-copies-in-sync" aria-hidden="true">#</a></h2>
+<p>A security boundary is only as good as its consistency. The validator in <code>src/shared/hire.ts</code> is <strong>dependency-free and pure</strong> — no I/O, no imports beyond the language — which is exactly what lets it run in three places at once: the Electron <strong>main</strong> process (for the deep-link path) and the <strong>renderer</strong> (for file import and modal pre-fill). The hire <strong>gallery</strong> mirrors the same rules in a client-side validator (<code>docs/hires/validator.js</code>), and a JSON schema (<code>docs/hires/spec/hire.schema.json</code>) encodes them once more for tooling. Same charset rules, same allowlist, same provider constraint, everywhere — so a manifest that the gallery says is valid is the manifest the app will accept, and there’s no soft spot where one copy is laxer than another.</p>
+<h2 id="whats-still-on-the-human" tabindex="-1">What’s still on the human <a class="anchor" href="#whats-still-on-the-human" aria-hidden="true">#</a></h2>
+<p>The honest caveat. Two fields — <code>goal</code> and <code>description</code> — are free text, and they pre-fill the <strong>prompt</strong> the agent will run on. That’s a prompt-injection surface: a manifest can suggest a task, and the words of that task are attacker-influenced. v1 accepts this deliberately, on two grounds. First, the human <strong>reviews every field</strong> in the modal before clicking spawn — the goal text is right there to read. Second, the things that would turn a poisoned prompt into real damage are locked down upstream: the binary is your own provider, the flags are allowlisted, no settings or system-prompt overrides get through. The prompt can ask the agent to do something dubious, but the agent runs inside the same <a href="/blog/agent-security-and-sandboxing/">permission and sandboxing model</a> as any other, and the <a href="/blog/human-in-the-loop-ai-agents/">human is in the loop</a> on the actions that matter. The manifest never gets to be the spawn gate. A person does.</p>
+<p>That’s the line we hold for v1, and we’re candid that it <em>is</em> a line and not a wall: free text into a prompt is, fundamentally, part of the <a href="/blog/the-lethal-trifecta-for-coding-agents/">lethal trifecta</a> story, and the durable answer there is architectural, not a regex. Locking the binary and flags is how we keep a poisoned goal a <em>nuisance</em> rather than a <em>breach</em>.</p>
+<h2 id="the-transferable-lessons" tabindex="-1">The transferable lessons <a class="anchor" href="#the-transferable-lessons" aria-hidden="true">#</a></h2>
+<p>Strip away the specifics and the hire pipeline is a small catalog of rules for any “import an untrusted config” feature:</p>
+<ul>
+<li><strong>Make import inert.</strong> Importing data should never be an action. Pre-fill, then make a human commit. The spawn gate is a person, by construction.</li>
+<li><strong>Don’t let data name the executable.</strong> Configs select among <em>your</em> trusted programs; they never introduce one. Reject the custom-provider escape hatch.</li>
+<li><strong>Validate at the boundary <em>and</em> quote at the sink.</strong> A charset check on each field and a hardened quoter on the command line catch different mistakes; defense in depth wants both.</li>
+<li><strong>Allowlist, don’t denylist, hostile input.</strong> A denylist bets you enumerated every bad value against a growing surface; an allowlist bets you enumerated the small, stable safe set. The latter doesn’t rot.</li>
+<li><strong>Re-validate every redirect hop, and never trust <code>content-length</code>.</strong> SSRF lives in the <em>final</em> hop and in <em>unbounded</em> bodies. Follow redirects manually, re-check each target’s protocol and resolved address, cap the hops, and stream the body to a hard byte limit with a timeout.</li>
+</ul>
+<p>A shareable hire is a link you click. The whole point of the import pipeline is that clicking it stays as boring as it looks.</p>
+<hr>
+<p>Shareable hires shipped in <strong>v0.2.8</strong> — see the <a href="/blog/launching-munder-difflin-v0-2-8/">launch notes</a> and the <a href="/blog/shareable-agent-roles/">concept companion on shareable agent roles</a> for the feature side, and the <a href="https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md">CHANGELOG</a> for the full diff. The security posture here is the same one that runs through the rest of the harness: <a href="/blog/agent-security-and-sandboxing/">permission modes and sandboxing</a>, the <a href="/blog/the-lethal-trifecta-for-coding-agents/">lethal trifecta</a>, and <a href="/blog/human-in-the-loop-ai-agents/">human-in-the-loop on the actions that matter</a>.</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">Why is a shareable agent-config file a security problem?</p>
+ <p class="a">Because importing one is the same trust event as opening any link or downloading any file: the bytes are attacker-controlled. A &#39;hire&#39; manifest is a JSON document you get by clicking a munderdifflin:// link or saving a file someone sent you. If any field in it can influence what process runs, what flags get passed, or what URL the app fetches, then a manifest is no longer data — it&#39;s an action an attacker triggers on your machine. So the import pipeline is built as a security boundary, not a convenience.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Can importing a hire manifest spawn an agent on its own?</p>
+ <p class="a">No. Import only pre-fills the Add-Agent modal behind an &#39;imported&#39; banner. The agent spawns solely when the human clicks submit in that modal. There is no code path that spawns on import — the manifest is data that proposes a configuration; the human is always the spawn gate.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Can a manifest choose what program runs?</p>
+ <p class="a">No. There is no command or executable field in the schema. The binary always comes from the user&#39;s locally configured provider preset — claude, antigravity, or codex. provider: &quot;custom&quot; is rejected outright. A manifest can only select among providers you already installed; it can never name a new program to run.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Why an allowlist for command flags instead of blocking the dangerous ones?</p>
+ <p class="a">Because the manifest&#39;s provider is attacker-chosen and each CLI keeps adding flags, a denylist is a bet that you enumerated every dangerous value — and it drifts and leaks as the tools evolve (ours leaked across three review rounds). A default-deny allowlist (SAFE_FLAG_NAMES) is a bet that you enumerated every safe value, and the safe set is small and stable. For attacker-controlled input, allowlist beats denylist.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How does the deep-link fetch avoid SSRF?</p>
+ <p class="a">The fetch is https-only (plain http allowed only for loopback, for local gallery dev), follows redirects manually and re-validates every Location hop against the same https/loopback allowlist (capped at 5 hops), resolves and blocks private/loopback/link-local addresses including the 169.254.169.254 cloud-metadata endpoint, and streams the body through a bounded reader that aborts past 64 KB with a 10s timeout. A remote page can never redirect the app into http://127.0.0.1 or a metadata IP, and a hostile host can&#39;t OOM the main process by streaming an unbounded body.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What risk is still left after all this?</p>
+ <p class="a">Free-text fields — goal and description — pre-fill the prompt the agent will run on, which is a prompt-injection surface. v1 accepts this because the human reviews every field before spawning and the binary and flags are locked down. The human remains the spawn gate; the manifest can suggest a task, but a person decides to run it.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/security/">Security</a><a class="tag" href="/blog/tags/internals/">Internals</a><a class="tag" href="/blog/tags/electron/">Electron</a><a class="tag" href="/blog/tags/command-injection/">Command Injection</a><a class="tag" href="/blog/tags/ssrf/">SSRF</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-of-the-feature">The shape of the feature</a></li><li class="lvl-2"><a href="#trust-boundary-1-import-never-spawns">Trust boundary #1: import never spawns</a></li><li class="lvl-2"><a href="#no-executable-field">No executable field</a></li><li class="lvl-2"><a href="#the-high-severity-bug-windows-command-injection-via-model">The HIGH-severity bug: Windows command injection via model</a></li><li class="lvl-2"><a href="#the-two-layer-fix-do-both">The two-layer fix (do both)</a></li><li class="lvl-2"><a href="#default-deny-the-flag-allowlist">Default-deny: the flag allowlist</a></li><li class="lvl-2"><a href="#ssrf-safe-bounded-fetch">SSRF-safe, bounded fetch</a></li><li class="lvl-3"><a href="#https-only-with-a-loopback-carve-out">https-only, with a loopback carve-out</a></li><li class="lvl-3"><a href="#redirect-ssrf-closed">Redirect SSRF, closed</a></li><li class="lvl-3"><a href="#streamed-byte-cap">Streamed byte cap</a></li><li class="lvl-2"><a href="#one-validator-four-copies-in-sync">One validator, four copies in sync</a></li><li class="lvl-2"><a href="#whats-still-on-the-human">What’s still on the human</a></li><li class="lvl-2"><a href="#the-transferable-lessons">The transferable lessons</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/launching-munder-difflin-v0-2-8/"><span class="k">← Older</span><span class="t">Launching Munder Difflin v0.2.8: Shareable Hires</span></a>
+ <span></span>
+ </div>
+ <section class="related">
+ <h2>Related in Internals</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-05">Jun 5, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>5 min</span>
+ </div>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <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/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-04">Jun 4, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>4 min</span>
+ </div>
+ <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
+ <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+ </section>
+
+ </footer>
+</article>
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &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-ai-agents-verify-their-own-work/index.html b/docs/blog/how-ai-agents-verify-their-own-work/index.html
index c17a8006..ba4d4746 100644
--- a/docs/blog/how-ai-agents-verify-their-own-work/index.html
+++ b/docs/blog/how-ai-agents-verify-their-own-work/index.html
@@ -274,25 +274,25 @@ and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -301,29 +301,29 @@ and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/index.html b/docs/blog/index.html
index a2fc3e6a..bf7b4248 100644
--- a/docs/blog/index.html
+++ b/docs/blog/index.html
@@ -85,29 +85,89 @@
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">91</span></a>
+ <a class="chip" aria-current="page">All<span class="ct">94</span></a>
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
<div class="wrap featured"><article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
+ </div>
+ </div>
+</article>
+
+</div>
+
+
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>8 min</span>
+ </div>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
@@ -125,13 +185,7 @@
</div>
</div>
</article>
-
-</div>
-
-
-<section class="wrap">
- <div class="post-grid">
- <article class="card">
+<article class="card">
<a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1">
<span>ORCHESTRATION</span>
</a>
diff --git a/docs/blog/launching-munder-difflin-v0-2-0/index.html b/docs/blog/launching-munder-difflin-v0-2-0/index.html
index c2a48c77..073e9743 100644
--- a/docs/blog/launching-munder-difflin-v0-2-0/index.html
+++ b/docs/blog/launching-munder-difflin-v0-2-0/index.html
@@ -315,56 +315,56 @@ the next release is built the same way this one was.</p>
<h2>Related in Story</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
- <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-07">Jun 7, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>6 min</span>
</div>
- <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
- <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
+ <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-07">Jun 7, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>
- <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>
+ <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
+ <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>
+ <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/launching-munder-difflin-v0-2-4/index.html b/docs/blog/launching-munder-difflin-v0-2-4/index.html
index 0619301d..97c8dc71 100644
--- a/docs/blog/launching-munder-difflin-v0-2-4/index.html
+++ b/docs/blog/launching-munder-difflin-v0-2-4/index.html
@@ -267,56 +267,56 @@
<h2>Related in Story</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-07">Jun 7, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
- <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-07">Jun 7, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
- <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
+ <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-07">Jun 7, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>
- <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>
+ <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
+ <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>
+ <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/launching-munder-difflin-v0-2-8/index.html b/docs/blog/launching-munder-difflin-v0-2-8/index.html
new file mode 100644
index 00000000..28b80096
--- /dev/null
+++ b/docs/blog/launching-munder-difflin-v0-2-8/index.html
@@ -0,0 +1,376 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Launching Munder Difflin v0.2.8: Shareable Hires — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself." />
+<link rel="canonical" href="https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/" />
+
+<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="Launching Munder Difflin v0.2.8: Shareable Hires — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself." />
+<meta property="og:url" content="https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/" />
+<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-15T00:00:00.000Z" />
+<meta property="article:author" content="Chaitanya Giri" />
+<meta property="article:tag" content="Story" />
+<meta property="article:tag" content="Release" />
+<meta property="article:tag" content="Multi-Agent" />
+<meta property="article:tag" content="Claude Code" />
+<meta property="article:tag" content="Open Source" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Launching Munder Difflin v0.2.8: Shareable Hires — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself." />
+<meta name="twitter:image" content="https://munderdiffl.in/media/og.png" />
+
+<link rel="alternate" type="application/atom+xml" title="Munder Difflin Blog" href="https://munderdiffl.in/blog/feed.xml" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="/blog/assets/blog.css" />
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "BlogPosting",
+ "headline": "Launching Munder Difflin v0.2.8: Shareable Hires",
+ "description": "Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-15T00:00:00.000Z",
+ "dateModified": "2026-06-15T00: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/launching-munder-difflin-v0-2-8/" },
+ "keywords": "munder difflin v0.2.8, shareable agent roles, the hiring fair, one-click ai agent hire, munderdifflin deep link, ai agent role manifest",
+ "articleSection": "Story",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/"
+}
+</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": "Launching Munder Difflin v0.2.8: Shareable Hires", "item": "https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What's new in Munder Difflin v0.2.8?", "acceptedAnswer": { "@type": "Answer", "text": "The headline is Shareable Hires. A hire is a portable JSON manifest (format id munder-difflin/hire@1) that captures a fully role-configured agent — name, avatar, provider, model, command flags, a goal, capability tags, and a token budget. You can share it as a link or a file, and the recipient gets the Add-Agent modal pre-filled, ready to review and spawn. It ships alongside a community gallery called The Hiring Fair at munderdiffl.in/hires." } },
+ { "@type": "Question", "name": "What exactly is a 'hire'?", "acceptedAnswer": { "@type": "Answer", "text": "Think of it as a job description for an AI coworker. It's a single JSON manifest that describes a role-configured agent: which provider runs it (Claude Code, Antigravity, or Codex), the model, the command flags, a goal/role description, capability tags, and a token budget. Hand it to anyone's office and they can spin up that exact role." } },
+ { "@type": "Question", "name": "Does importing a hire automatically run an agent?", "acceptedAnswer": { "@type": "Answer", "text": "No — and this is the whole point. Importing a hire (by link or by file) only pre-fills the Add-Agent modal, with an explicit 'imported' banner. Nothing spawns until you review every field and click spawn yourself. A hire you got from the internet can't run itself. The human is always the trigger." } },
+ { "@type": "Question", "name": "What is The Hiring Fair?", "acceptedAnswer": { "@type": "Answer", "text": "It's a community gallery at munderdiffl.in/hires — static, no login. It's full of ready-made roles from the cast: Pam writes docs, Dwight enforces QA, Jim reviews PRs, Creed audits security, Angela audits the office's own token spend, and Stanley does the migrations nobody wants. Each card has a Claude Code / Antigravity / Codex toggle and function filters. Browse, click the ⚡hire button, review, spawn." } },
+ { "@type": "Question", "name": "How are the two ways to hire different?", "acceptedAnswer": { "@type": "Answer", "text": "There are two front doors, one pipeline. A deep link (munderdifflin://hire?src=<https-url>) makes the app fetch and validate a manifest, then open the Add-Agent modal pre-filled — that's what the gallery's ⚡hire button uses. A file import is the 'import hire…' button in the Add-Agent modal, which reads a local .hire.json file. Both end at the same review-and-spawn step." } },
+ { "@type": "Question", "name": "Is it safe to import a hire from someone else?", "acceptedAnswer": { "@type": "Answer", "text": "A manifest is treated as untrusted input: there's no executable field, no auto-spawn, and the fetch is validated and bounded. It can only pre-fill a form you review by hand. We go deep on the trust model in a separate post — see the hire manifest security deep-dive." } },
+ { "@type": "Question", "name": "Do I still get everything from v0.2.7?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. v0.2.8 includes everything from v0.2.7 (voice dictation, the Knowledge Graph, multi-window floors, the rich composer, session resume) and earlier. Shareable Hires is purely additive." } }
+
+ ]
+}
+</script>
+
+
+</head>
+<body>
+<a class="skip-link" href="#main">Skip to content</a>
+<nav id="nav">
+ <a class="brand" href="/blog/" aria-label="Munder Difflin Blog home">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <span class="spacer"></span>
+ <div class="links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in">↗ Product</a>
+ </div>
+ <div class="nav-actions">
+ <a class="btn sm" href="https://munderdiffl.in/blog/feed.xml" aria-label="RSS feed">⤵ RSS</a>
+ <a class="btn sm primary" href="https://munderdiffl.in/#install">⤓ Download</a>
+ </div>
+</nav>
+
+<main id="main">
+
+<article>
+ <header class="post-head wrap">
+ <nav class="crumbs" aria-label="Breadcrumb">
+ <a href="/blog/">Blog</a>
+ <span>/</span>
+ <a href="/blog/topics/story/">Story</a>
+ </nav>
+ <h1>Launching Munder Difflin v0.2.8: Shareable Hires</h1>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="byline">
+ <span class="av" aria-hidden="true">CG</span>
+ <strong>Chaitanya Giri</strong>
+ <span class="dot" aria-hidden="true">·</span>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>6 min read</span>
+ <span class="tag kind">Story</span>
+ </div>
+ </header>
+
+ <div class="post-wrap wrap">
+ <div class="prose">
+ <div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Munder Difflin v0.2.8</strong> ships <strong>Shareable Hires</strong>. A <strong>hire</strong> is a portable JSON manifest — a job description for an AI coworker (provider, model, flags, goal, capability tags, token budget) — that you can share as a <strong>link</strong> or a <strong>file</strong>. Click a hire, and the Add-Agent modal opens <em>pre-filled</em>. It never spawns anything on its own: <strong>you</strong> review every field and hit spawn. Plus <strong>The Hiring Fair</strong> at <a href="https://munderdiffl.in/hires">munderdiffl.in/hires</a> — a no-login gallery of ready-made roles (Pam writes docs, Dwight does QA, Creed audits security…). Browse → ⚡hire → review → spawn. Free, open source, local-first.</p></div>
+<p>ok so picture this. you’ve got a whole floor of pixel coworkers — Claude Code agents, Antigravity (Gemini) workers, Codex CLIs — all run by Michael, the GOD orchestrator who routes work like a slightly unhinged regional manager. it’s great. but here’s the part nobody tells you about a fresh, empty office:</p>
+<p><strong>the first hire is the hard one.</strong></p>
+<p>a blank floor is intimidating. what model? what provider? what flags? what should this thing’s <em>job</em> even be? for a newcomer, that’s a lot of staring at an empty Add-Agent dialog before anything fun happens. you basically have to know how to write an orchestrator brief before you can watch a single agent do a single thing.</p>
+<p><strong>v0.2.8 fixes the cold start.</strong> meet <strong>Shareable Hires</strong>.</p>
+<h2 id="whats-a-hire" tabindex="-1">what’s a “hire”? <a class="anchor" href="#whats-a-hire" aria-hidden="true">#</a></h2>
+<p>a hire is a tiny, portable <strong>JSON manifest</strong> — format id <code>munder-difflin/hire@1</code> — that captures a <em>fully role-configured agent</em>. not just “an agent,” but a coworker with a job already figured out:</p>
+<ul>
+<li>🏷️ a <strong>name</strong> and an <strong>avatar/sprite</strong> (yes, the little pixel face)</li>
+<li>🤖 a <strong>provider</strong> — Claude Code, Antigravity, or Codex</li>
+<li>🧠 a <strong>model</strong> and the <strong>command flags</strong> it should run with</li>
+<li>🎯 a <strong>goal / role description</strong> — what this coworker is actually here to do</li>
+<li>🏆 <strong>capability tags</strong> — what it’s good at, so it’s filterable</li>
+<li>📊 a <strong>token budget</strong> — so it can’t quietly torch your bill</li>
+</ul>
+<p>think of it as a <strong>job description you can hand to anyone’s office</strong>. someone figured out a great “PR reviewer” setup once? they export it as a hire, you drop it into your floor, and now you’ve got that exact coworker — without reverse-engineering anyone’s prompt.</p>
+<p>the neat trick: a manifest maps <strong>1:1</strong> onto what the Add-Agent modal already sends. it’s not a new system bolted on the side — it’s just a portable snapshot of the per-agent config you’ve always had. “hire Pam” is a <em>way</em> easier first step than writing an orchestrator prompt from a cold start.</p>
+<h2 id="two-ways-to-hire-one-pipeline" tabindex="-1">two ways to hire, one pipeline <a class="anchor" href="#two-ways-to-hire-one-pipeline" aria-hidden="true">#</a></h2>
+<p>there are two front doors, but they both end at the same place: a modal you review and a spawn button <strong>you</strong> press.</p>
+<h3 id="-the-deep-link" tabindex="-1">🔗 the deep link <a class="anchor" href="#-the-deep-link" aria-hidden="true">#</a></h3>
+<p>click a <code>munderdifflin://hire?src=&lt;https-url&gt;</code> link — say, from the gallery — and the app does the legwork: it <strong>fetches</strong> the manifest, <strong>validates</strong> it, and pops open the Add-Agent modal <strong>pre-filled</strong> with everything that hire describes. one click from “ooh, that’s a nice role” to “let me look this over.”</p>
+<h3 id="-the-file-import" tabindex="-1">📁 the file import <a class="anchor" href="#-the-file-import" aria-hidden="true">#</a></h3>
+<p>prefer files? there’s an <strong>import hire…</strong> button right inside the Add-Agent modal. point it at a local <code>.hire.json</code> file and it reads it in. same destination: the modal, pre-filled.</p>
+<p>both paths converge. link or file, you land in the same review screen.</p>
+<h2 id="the-part-that-matters-import-never-spawns-anything" tabindex="-1">the part that matters: import never spawns anything <a class="anchor" href="#the-part-that-matters-import-never-spawns-anything" aria-hidden="true">#</a></h2>
+<p>read this twice, because it’s the whole trust promise:</p>
+<blockquote>
+<p><strong>importing a hire does not start an agent. ever.</strong></p>
+</blockquote>
+<p>all it does is <strong>pre-fill the modal</strong> — and it slaps an explicit <em>“imported”</em> banner on it so you’re never confused about where these values came from. then <strong>you</strong> read every field. you check the goal. you eyeball the provider and the budget. and then <strong>you</strong> click spawn. yourself. on purpose.</p>
+<p><strong>a hire you got off the internet can’t run itself.</strong> the human is always the trigger. that’s not a setting you can flip off; it’s how the feature is built. it’s the difference between “here’s a job description, want to hire this person?” and “this résumé is now a manager.” we are firmly the former.</p>
+<p>🔒 on the security of it: a manifest is treated as <strong>untrusted input</strong> — there’s no executable field, no auto-spawn, and the fetch is validated and bounded. that’s the short version. we wrote a whole post on the trust model so this one can stay fun — go read the <a href="/blog/hire-manifest-untrusted-input/">hire manifest security deep-dive</a> if you want the bolts and the threat model.</p>
+<h2 id="the-hiring-fair-" tabindex="-1">The Hiring Fair 🎪 <a class="anchor" href="#the-hiring-fair-" aria-hidden="true">#</a></h2>
+<p>ok, the fun part. all of this would be a neat plumbing feature with nothing to plug into — so we built the thing to plug into.</p>
+<p><strong>The Hiring Fair</strong> is a community gallery at <strong><a href="https://munderdiffl.in/hires">munderdiffl.in/hires</a></strong>. static, no login, no account. just a wall of ready-made coworkers you can hire in one click. and because the floor looks like <em>The Office</em>, of course the cast showed up to apply:</p>
+<ul>
+<li>📝 <strong>Pam</strong> writes the docs (the README nobody wants to write? Pam wants to write it.)</li>
+<li>🥋 <strong>Dwight</strong> enforces QA. Dwight does not negotiate with bugs. <em>FACT.</em></li>
+<li>🔍 <strong>Jim</strong> reviews your PRs (calm, reasonable, occasionally pranks the diff)</li>
+<li>🕵️ <strong>Creed</strong> audits security (look, who <em>better</em> to think like an attacker)</li>
+<li>💰 <strong>Angela</strong> audits the office’s <strong>own</strong> token spend — she runs the numbers on your other agents and judges them for it. perfect casting.</li>
+<li>🗄️ <strong>Stanley</strong> does the migrations nobody else will touch. he’s not thrilled. he does them anyway.</li>
+</ul>
+<p>each card has a <strong>Claude Code / Antigravity / Codex</strong> toggle and <strong>function filters</strong> — the same ones from the main landing page, so it all feels like one place. pick the provider you actually have installed, filter by what you need, then hit the <strong>⚡hire</strong> button.</p>
+<p>the loop is dead simple:</p>
+<blockquote>
+<p><strong>browse → click ⚡hire → review → spawn.</strong></p>
+</blockquote>
+<p>that’s it. that’s the whole onboarding. instead of “here’s an empty floor, good luck,” it’s “here’s Pam, want her to write your docs? yes? she’s at her desk now.”</p>
+<h2 id="why-this-is-secretly-a-growth-thing" tabindex="-1">why this is secretly a growth thing <a class="anchor" href="#why-this-is-secretly-a-growth-thing" aria-hidden="true">#</a></h2>
+<p>here’s the bit we’re genuinely excited about. the hardest moment in any tool like this is the <strong>first five minutes</strong>. an empty office asks too much of a newcomer.</p>
+<p>a hire collapses that. somebody who already runs a great floor can package up their best role and <strong>share the link</strong>. the recipient clicks it, reviews it, spawns it — and now they’ve got a working agent on their <em>first</em> try, before they’ve learned a single thing about orchestrator prompts. then <em>they</em> tweak it, build their own great role, and share <em>that</em>.</p>
+<p>that’s a <strong>community growth loop</strong>: roles people actually use, shared as one-click links, each one a doorway into the floor that doesn’t start with a blank page. The Hiring Fair is the marketplace; the hire manifest is the currency. and none of it costs you an API key — hires drive the CLIs and subscriptions you already pay for.</p>
+<h2 id="everything-from-027-is-still-in-the-box" tabindex="-1">everything from 0.2.7 is still in the box <a class="anchor" href="#everything-from-027-is-still-in-the-box" aria-hidden="true">#</a></h2>
+<p>Shareable Hires is purely <strong>additive</strong>. nothing got taken away. v0.2.8 includes everything from v0.2.7 and earlier:</p>
+<ul>
+<li>🎙️ <strong>voice dictation</strong> — talk to your floor</li>
+<li>🕸️ <strong>the Knowledge Graph</strong> — the office remembers how things connect</li>
+<li>🪟 <strong>multi-window floors</strong> — spread the office across monitors</li>
+<li>✍️ <strong>the rich composer</strong> — attachments + a taller, friendlier input</li>
+<li>⏯️ <strong>session resume</strong> — pick a long-running session back up where it left off</li>
+</ul>
+<p>plus the multi-provider parity (Claude Code + Antigravity + Codex, no second-class citizens), shared memory, the inbox/outbox mailbox, schedules, token budgets, close-the-lid overnight runs, and Slack/webhook triggers. the floor you already love, now with a front door for new coworkers.</p>
+<h2 id="get-v028" tabindex="-1">get v0.2.8 <a class="anchor" href="#get-v028" aria-hidden="true">#</a></h2>
+<p>Munder Difflin is <strong>free, open source, and local-first</strong> on macOS, Windows, and Linux. no account, no cloud — your machine, your subscriptions, your floor.</p>
+<p><a href="https://github.com/chaitanyagiri/munder-difflin/releases/latest"><strong>Download v0.2.8</strong></a>, then head over to <a href="https://munderdiffl.in/hires"><strong>The Hiring Fair</strong></a>, find a coworker, and hit ⚡hire. review the modal. spawn it. watch Pam get to work.</p>
+<p>want the why-it’s-built-this-way story? read the concept companion on <a href="/blog/shareable-agent-roles/">shareable agent roles</a>. want the trust model and threat surface in detail? that’s the <a href="/blog/hire-manifest-untrusted-input/">hire manifest security deep-dive</a>. curious how we even ended up with a Dwight in the first place? the <a href="/blog/the-office-parody-behind-munder-difflin/">Office parody behind Munder Difflin</a> explains the casting. and if you missed the multi-provider launch, <a href="/blog/launching-munder-difflin-v0-2-4/">v0.2.4 is right here</a>.</p>
+<p>full release notes live in the <a href="https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md">CHANGELOG</a>.</p>
+<p>that’s it. go hire someone. (Dwight is already volunteering.)</p>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">What&#39;s new in Munder Difflin v0.2.8?</p>
+ <p class="a">The headline is Shareable Hires. A hire is a portable JSON manifest (format id munder-difflin/hire@1) that captures a fully role-configured agent — name, avatar, provider, model, command flags, a goal, capability tags, and a token budget. You can share it as a link or a file, and the recipient gets the Add-Agent modal pre-filled, ready to review and spawn. It ships alongside a community gallery called The Hiring Fair at munderdiffl.in/hires.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What exactly is a &#39;hire&#39;?</p>
+ <p class="a">Think of it as a job description for an AI coworker. It&#39;s a single JSON manifest that describes a role-configured agent: which provider runs it (Claude Code, Antigravity, or Codex), the model, the command flags, a goal/role description, capability tags, and a token budget. Hand it to anyone&#39;s office and they can spin up that exact role.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Does importing a hire automatically run an agent?</p>
+ <p class="a">No — and this is the whole point. Importing a hire (by link or by file) only pre-fills the Add-Agent modal, with an explicit &#39;imported&#39; banner. Nothing spawns until you review every field and click spawn yourself. A hire you got from the internet can&#39;t run itself. The human is always the trigger.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What is The Hiring Fair?</p>
+ <p class="a">It&#39;s a community gallery at munderdiffl.in/hires — static, no login. It&#39;s full of ready-made roles from the cast: Pam writes docs, Dwight enforces QA, Jim reviews PRs, Creed audits security, Angela audits the office&#39;s own token spend, and Stanley does the migrations nobody wants. Each card has a Claude Code / Antigravity / Codex toggle and function filters. Browse, click the ⚡hire button, review, spawn.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How are the two ways to hire different?</p>
+ <p class="a">There are two front doors, one pipeline. A deep link (munderdifflin://hire?src=&lt;https-url&gt;) makes the app fetch and validate a manifest, then open the Add-Agent modal pre-filled — that&#39;s what the gallery&#39;s ⚡hire button uses. A file import is the &#39;import hire…&#39; button in the Add-Agent modal, which reads a local .hire.json file. Both end at the same review-and-spawn step.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Is it safe to import a hire from someone else?</p>
+ <p class="a">A manifest is treated as untrusted input: there&#39;s no executable field, no auto-spawn, and the fetch is validated and bounded. It can only pre-fill a form you review by hand. We go deep on the trust model in a separate post — see the hire manifest security deep-dive.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Do I still get everything from v0.2.7?</p>
+ <p class="a">Yes. v0.2.8 includes everything from v0.2.7 (voice dictation, the Knowledge Graph, multi-window floors, the rich composer, session resume) and earlier. Shareable Hires is purely additive.</p>
+ </div>
+
+ </section>
+
+
+
+ <hr />
+ <div class="share">
+ <span class="lbl">Tags</span>
+ <a class="tag" href="/blog/tags/story/">Story</a><a class="tag" href="/blog/tags/release/">Release</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/open-source/">Open Source</a>
+ </div>
+
+ </div>
+
+
+ <aside class="toc-rail" aria-label="Table of contents">
+ <div class="tt">On this page</div>
+ <ol>
+ <li class="lvl-2"><a href="#whats-a-hire">what’s a “hire”?</a></li><li class="lvl-2"><a href="#two-ways-to-hire-one-pipeline">two ways to hire, one pipeline</a></li><li class="lvl-3"><a href="#-the-deep-link">🔗 the deep link</a></li><li class="lvl-3"><a href="#-the-file-import">📁 the file import</a></li><li class="lvl-2"><a href="#the-part-that-matters-import-never-spawns-anything">the part that matters: import never spawns anything</a></li><li class="lvl-2"><a href="#the-hiring-fair-">The Hiring Fair 🎪</a></li><li class="lvl-2"><a href="#why-this-is-secretly-a-growth-thing">why this is secretly a growth thing</a></li><li class="lvl-2"><a href="#everything-from-027-is-still-in-the-box">everything from 0.2.7 is still in the box</a></li><li class="lvl-2"><a href="#get-v028">get v0.2.8</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/shareable-agent-roles/"><span class="k">← Older</span><span class="t">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</span></a>
+ <a class="pn next" href="/blog/hire-manifest-untrusted-input/"><span class="k">Newer →</span><span class="t">Treating a Hire Manifest as Untrusted Input</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Story</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-09">Jun 9, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
+ <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-07">Jun 7, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
+ <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-07">Jun 7, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
+ <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">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/long-running-agents-the-2026-shift/index.html b/docs/blog/long-running-agents-the-2026-shift/index.html
index 084d65a7..27c556f3 100644
--- a/docs/blog/long-running-agents-the-2026-shift/index.html
+++ b/docs/blog/long-running-agents-the-2026-shift/index.html
@@ -294,25 +294,25 @@ source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -321,29 +321,29 @@ source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/munder-difflin-faq/index.html b/docs/blog/munder-difflin-faq/index.html
index 03d6f7c4..02a51603 100644
--- a/docs/blog/munder-difflin-faq/index.html
+++ b/docs/blog/munder-difflin-faq/index.html
@@ -266,25 +266,25 @@ 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/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -293,29 +293,29 @@ free, open source, and local-first.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/node-pty-electron-real-terminals/index.html b/docs/blog/node-pty-electron-real-terminals/index.html
index d7759a4c..7f247b2c 100644
--- a/docs/blog/node-pty-electron-real-terminals/index.html
+++ b/docs/blog/node-pty-electron-real-terminals/index.html
@@ -324,56 +324,56 @@ real terminals driving real agents; it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/observability-for-agent-fleets/index.html b/docs/blog/observability-for-agent-fleets/index.html
index 7ac73723..87cae07f 100644
--- a/docs/blog/observability-for-agent-fleets/index.html
+++ b/docs/blog/observability-for-agent-fleets/index.html
@@ -261,56 +261,56 @@ open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/one-prompt-automated-pr-review/index.html b/docs/blog/one-prompt-automated-pr-review/index.html
index 895917ab..7f277804 100644
--- a/docs/blog/one-prompt-automated-pr-review/index.html
+++ b/docs/blog/one-prompt-automated-pr-review/index.html
@@ -196,56 +196,56 @@
<h2>Related in Story</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
- <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-07">Jun 7, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
- <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
+ <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/the-office-parody-behind-munder-difflin/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-07">Jun 7, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/the-office-parody-behind-munder-difflin/">The Office Parody Behind Munder Difflin (and Why It Helps)</a></h3>
- <p class="dek">Why Munder Difflin is a loving parody of The Office — and how the office metaphor makes a hive of AI agents genuinely easier to understand and trust.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
+ <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/the-office-parody-behind-munder-difflin/" aria-label="Read: The Office Parody Behind Munder Difflin (and Why It Helps)">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/open-source-ai-tools-on-purpose/index.html b/docs/blog/open-source-ai-tools-on-purpose/index.html
index 31ae9cb6..eec2a907 100644
--- a/docs/blog/open-source-ai-tools-on-purpose/index.html
+++ b/docs/blog/open-source-ai-tools-on-purpose/index.html
@@ -267,25 +267,25 @@ autonomous. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -294,29 +294,29 @@ autonomous. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/recovering-from-agent-failures/index.html b/docs/blog/recovering-from-agent-failures/index.html
index d1648d77..bbd0e7c0 100644
--- a/docs/blog/recovering-from-agent-failures/index.html
+++ b/docs/blog/recovering-from-agent-failures/index.html
@@ -281,56 +281,56 @@ there to read.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/rendering-many-live-terminals-performance/index.html b/docs/blog/rendering-many-live-terminals-performance/index.html
index 330fc7c1..08e6db4c 100644
--- a/docs/blog/rendering-many-live-terminals-performance/index.html
+++ b/docs/blog/rendering-many-live-terminals-performance/index.html
@@ -284,56 +284,56 @@ to run many real terminals without melting your CPU; it’s free and open source
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/shareable-agent-roles/index.html b/docs/blog/shareable-agent-roles/index.html
new file mode 100644
index 00000000..d6690738
--- /dev/null
+++ b/docs/blog/shareable-agent-roles/index.html
@@ -0,0 +1,368 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Shareable Agent Roles: A Portable Format for Hiring AI Coworkers — Munder Difflin Blog</title>
+<meta name="description" content="Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact." />
+<link rel="canonical" href="https://munderdiffl.in/blog/shareable-agent-roles/" />
+
+<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="Shareable Agent Roles: A Portable Format for Hiring AI Coworkers — Munder Difflin Blog" />
+<meta property="og:description" content="Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact." />
+<meta property="og:url" content="https://munderdiffl.in/blog/shareable-agent-roles/" />
+<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-15T00: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="Open Source" />
+<meta property="article:tag" content="Agent Design" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Shareable Agent Roles: A Portable Format for Hiring AI Coworkers — Munder Difflin Blog" />
+<meta name="twitter:description" content="Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact." />
+<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": "Shareable Agent Roles: A Portable Format for Hiring AI Coworkers",
+ "description": "Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.",
+ "image": ["https://munderdiffl.in/media/og.png"],
+ "datePublished": "2026-06-15T00:00:00.000Z",
+ "dateModified": "2026-06-15T00: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/shareable-agent-roles/" },
+ "keywords": "shareable agent roles, portable agent config, ai agent role manifest, the hiring fair, one-click ai agent, reusable agent personas",
+ "articleSection": "Concepts",
+ "inLanguage": "en-US",
+ "url": "https://munderdiffl.in/blog/shareable-agent-roles/"
+}
+</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": "Shareable Agent Roles: A Portable Format for Hiring AI Coworkers", "item": "https://munderdiffl.in/blog/shareable-agent-roles/" }
+ ]
+}
+</script>
+
+<script type="application/ld+json">
+{
+ "@context": "https://schema.org",
+ "@type": "FAQPage",
+ "mainEntity": [
+ { "@type": "Question", "name": "What is a 'shareable agent role'?", "acceptedAnswer": { "@type": "Answer", "text": "It's an agent role packaged as a portable file — a small JSON manifest (format id munder-difflin/hire@1) that captures everything needed to spin up a role-configured agent: name, avatar, provider, model, command flags, a goal/role description, capability tags, and a token budget. We call one a 'hire.' Instead of explaining your setup in a tutorial, you hand someone the file and they get the same coworker." } },
+ { "@type": "Question", "name": "Why should agent roles be portable at all?", "acceptedAnswer": { "@type": "Answer", "text": "Because a good role is real, hard-won configuration work — the right provider and model, the right flags, a sharp goal prompt, sane capabilities and a token budget — and today that knowledge is trapped in one person's setup or buried in prose. Portability turns that tacit knowledge into an artifact you can share, fork, and improve, the same move package registries made for code libraries." } },
+ { "@type": "Question", "name": "If I import a role from a link, does it start running on its own?", "acceptedAnswer": { "@type": "Answer", "text": "No. Import never spawns anything. It only pre-fills the Add-Agent modal behind an explicit 'imported' banner. You review every field and you click spawn. A role you got from the internet is inert data until a human acts on it — the human is always the spawn gate." } },
+ { "@type": "Question", "name": "How is a role manifest different from just sharing a prompt?", "acceptedAnswer": { "@type": "Answer", "text": "A prompt is one ingredient. A hire manifest is the whole recipe: which provider runs it, the model, the command flags, the goal, the capability tags, and the budget — mapped 1:1 onto the fields the app's Add-Agent flow already uses. It's the difference between a sentence in a README and a job description you can hand to anyone's office." } },
+ { "@type": "Question", "name": "What is The Hiring Fair?", "acceptedAnswer": { "@type": "Answer", "text": "A static community gallery at munderdiffl.in/hires — no login, no trackers, MIT-licensed. It's stocked with ready-made roles from the cast: Pam writes docs, Dwight enforces QA, Jim reviews PRs, Creed audits security, Angela audits the office's own token spend, Stanley does the migrations nobody wants. Each card has a Claude Code / Antigravity / Codex toggle and function filters. Browse, hire, review, spawn." } },
+ { "@type": "Question", "name": "Can I submit my own roles to The Hiring Fair today?", "acceptedAnswer": { "@type": "Answer", "text": "Not yet. Today, curation is a maintainer commit — there is deliberately no public write or submission pipeline. A community submission queue needs its own review-and-trust design, so we scoped it out of this first release rather than ship it half-built." } }
+
+ ]
+}
+</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>Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</h1>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <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-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true">·</span>
+ <span>8 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>A well-configured agent <strong>role</strong> is real work — the right provider, model, flags, goal prompt, capabilities, and budget — and today that knowledge is trapped in one person's setup. Munder Difflin v0.2.8 makes a role a <strong>portable artifact</strong>: a small JSON manifest we call a <strong>hire</strong> (a job description as a file). You hire from a <strong>link</strong> or a <strong>file</strong>, and the Add-Agent modal opens <em>pre-filled</em> — but <strong>import never spawns anything</strong>; you review every field and you press spawn. Browse ready-made roles at <strong>The Hiring Fair</strong> (<a href="https://munderdiffl.in/hires/">munderdiffl.in/hires</a>). The thesis: portable roles create a community growth loop, the way package registries did for libraries.</p></div>
+<p>There’s a moment, the first time you open a fresh agent floor, where the hard part isn’t running an agent — it’s <em>configuring</em> one. Which provider? Which model? What flags? And the question that actually stalls people: what is this thing’s <em>job</em>? Writing a role from a blank box is a steep first step, and it’s the step that stands between a curious newcomer and watching a single agent do a single useful thing.</p>
+<p>This post is about a small idea with an outsized payoff: <strong>make an agent role a portable artifact</strong> — something you can hand to someone, the way you’d hand them a file. In v0.2.8 we shipped that idea as <strong>Shareable Hires</strong>, and a gallery to share them in, called <strong>The Hiring Fair</strong>. Here’s why portable roles matter, what the format encodes, and the trust design that makes “hire from a link” both easy and safe.</p>
+<h2 id="the-problem-a-good-role-is-tacit-knowledge" tabindex="-1">The problem: a good role is tacit knowledge <a class="anchor" href="#the-problem-a-good-role-is-tacit-knowledge" aria-hidden="true">#</a></h2>
+<p>Spin up an agent that’s genuinely good at one job — say, reviewing pull requests — and notice how much of the value is <em>configuration</em>, not code. You picked a provider. You picked a model that’s strong enough for the task but not wastefully expensive (<a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">the clone army trap</a> is what happens when you skip this). You set command flags. You wrote a goal prompt sharp enough that the agent doesn’t need a follow-up question. You gave it the right capabilities and a token budget so it can’t quietly torch your bill.</p>
+<p>That’s a real, hard-won bundle of decisions. And right now, it lives in exactly one place: your setup. If a teammate wants the same PR reviewer, your options are bad. You can write a tutorial — paragraphs of “set the model to X, add these flags, here’s the prompt I use” — and hope they transcribe it correctly. Or you can screen-share and walk them through the dialog field by field.</p>
+<p>Either way, <strong>you can’t just hand someone a role.</strong> The knowledge is tacit: trapped in one person’s head, or buried in prose that goes stale the moment a default changes. For a newcomer, “write an orchestrator prompt from scratch” is the worst possible first task — it asks for expertise before they’ve earned any. The thing that should be a starting point is instead a wall.</p>
+<h2 id="the-idea-a-role-as-a-file-you-can-pass-around" tabindex="-1">The idea: a role as a file you can pass around <a class="anchor" href="#the-idea-a-role-as-a-file-you-can-pass-around" aria-hidden="true">#</a></h2>
+<p>The fix is to stop describing roles and start <em>packaging</em> them. A <strong>hire</strong> is a small JSON manifest — format id <code>munder-difflin/hire@1</code> — that captures a role-configured agent in full:</p>
+<ul>
+<li>a <strong>name</strong> and an <strong>avatar/sprite</strong> (the pixel face on the floor),</li>
+<li>a <strong>provider</strong> — Claude Code, Antigravity (Gemini, <code>agy</code>), or Codex,</li>
+<li>a <strong>model</strong> and the <strong>command flags</strong> it runs with,</li>
+<li>a <strong>goal / role description</strong> — what this coworker is here to do,</li>
+<li><strong>capability tags</strong> — what it’s good at, so it’s filterable,</li>
+<li>and a <strong>token budget</strong> — a spend ceiling baked in.</li>
+</ul>
+<p>Think of it as a <strong>job description as a file.</strong> The manifest isn’t a new runtime or a clever new way to start agents — it maps <strong>1:1 onto what the app’s Add-Agent flow already does</strong>. Every field above is a field the dialog already has. So a hire is, very precisely, a <em>pre-filled version of the form you’ve always used</em>. Nothing new spawns it; it’s just a portable starting point for the same flow.</p>
+<h3 id="what-one-looks-like" tabindex="-1">What one looks like <a class="anchor" href="#what-one-looks-like" aria-hidden="true">#</a></h3>
+<p>Here’s an <em>illustrative</em> manifest (realistic fields, but don’t copy-paste it as gospel — it’s a teaching example, not a spec):</p>
+<pre class="language-json"><code class="language-json"><span class="token punctuation">{</span>
+ <span class="token property">"format"</span><span class="token operator">:</span> <span class="token string">"munder-difflin/hire@1"</span><span class="token punctuation">,</span>
+ <span class="token property">"name"</span><span class="token operator">:</span> <span class="token string">"Jim"</span><span class="token punctuation">,</span>
+ <span class="token property">"sprite"</span><span class="token operator">:</span> <span class="token string">"jim"</span><span class="token punctuation">,</span>
+ <span class="token property">"provider"</span><span class="token operator">:</span> <span class="token string">"claude-code"</span><span class="token punctuation">,</span>
+ <span class="token property">"model"</span><span class="token operator">:</span> <span class="token string">"claude-sonnet"</span><span class="token punctuation">,</span>
+ <span class="token property">"flags"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token string">"--permission-mode"</span><span class="token punctuation">,</span> <span class="token string">"plan"</span><span class="token punctuation">]</span><span class="token punctuation">,</span>
+ <span class="token property">"goal"</span><span class="token operator">:</span> <span class="token string">"Review open pull requests. Read the diff against the base branch, flag correctness bugs, risky side effects, and missing tests. Comment with specifics; do not merge."</span><span class="token punctuation">,</span>
+ <span class="token property">"capabilities"</span><span class="token operator">:</span> <span class="token punctuation">[</span><span class="token string">"code-review"</span><span class="token punctuation">,</span> <span class="token string">"testing"</span><span class="token punctuation">,</span> <span class="token string">"git"</span><span class="token punctuation">]</span><span class="token punctuation">,</span>
+ <span class="token property">"tokenBudget"</span><span class="token operator">:</span> <span class="token number">200000</span>
+<span class="token punctuation">}</span></code></pre>
+<p>Read it top to bottom and it tells you everything: <em>who</em> (Jim, the PR reviewer), <em>what runs it</em> (Claude Code on a mid-tier model), <em>how it behaves</em> (plan mode, so it proposes before acting), <em>what it’s for</em> (the goal), <em>what it’s good at</em> (the tags), and <em>how much it’s allowed to spend</em> (the budget). That’s the entire role, and it fits in a screenshot. The point of the format is exactly that legibility: a role you can read, diff, and reason about — not a black box.</p>
+<h2 id="two-ways-to-hire-one-pipeline" tabindex="-1">Two ways to hire, one pipeline <a class="anchor" href="#two-ways-to-hire-one-pipeline" aria-hidden="true">#</a></h2>
+<p>There are two front doors, and they both lead to the same place.</p>
+<ul>
+<li><strong>Deep link.</strong> A <code>munderdifflin://hire?src=&lt;https-url&gt;</code> link — the kind behind a ⚡hire button in the gallery — opens the app and fetches the manifest, then opens the <strong>Add-Agent modal pre-filled</strong>. One click from a web page to a populated form.</li>
+<li><strong>File import.</strong> An <em>import hire…</em> button in the Add-Agent modal reads a local <code>.hire.json</code> file. Same destination: the form, pre-filled.</li>
+</ul>
+<p>The two doors exist because the two situations are different — clicking a button in a browser versus opening a file someone sent you — but they converge immediately. Both end at one modal, one review, one spawn button. There’s deliberately not a second mechanism to maintain.</p>
+<h2 id="the-trust-design-import-never-spawns" tabindex="-1">The trust design: import never spawns <a class="anchor" href="#the-trust-design-import-never-spawns" aria-hidden="true">#</a></h2>
+<p>This is the heart of the UX, and it’s a single, load-bearing rule: <strong>importing a hire never spawns anything.</strong> Whether it arrives by deep link or file, an imported manifest only ever <em>pre-fills the Add-Agent modal</em>, behind an explicit “imported” banner so you always know this config came from outside. You review every field — the goal, the flags, the budget — and <strong>you</strong> click spawn. A role you got from the internet is inert data until a human acts on it. The human is the spawn gate, every time.</p>
+<p>A few properties make that guarantee real rather than aspirational: there’s <strong>no executable in the format</strong> — a manifest names a provider preset, and the actual binary always comes from your own local install, never the file (<code>provider: &quot;custom&quot;</code> is rejected outright). The import is <strong>validated and bounded</strong>, so a malformed or oversized manifest is refused, not trusted. The mechanics of treating a downloaded manifest as untrusted input — the validation, the bounds, the threat model — get their own <a href="/blog/hire-manifest-untrusted-input/">security deep-dive</a>; here the takeaway is the principle. <strong>Portability and safety aren’t in tension</strong> as long as import is data-only and a human owns the spawn. You can share a role freely <em>because</em> sharing it can’t, by construction, run anything.</p>
+<h2 id="the-hiring-fair-a-gallery-of-ready-made-roles" tabindex="-1">The Hiring Fair: a gallery of ready-made roles <a class="anchor" href="#the-hiring-fair-a-gallery-of-ready-made-roles" aria-hidden="true">#</a></h2>
+<p>Portable roles are more fun when there’s somewhere to get them. <strong>The Hiring Fair</strong> is a static community gallery at <a href="https://munderdiffl.in/hires/">munderdiffl.in/hires</a> — no login, no trackers, MIT-licensed — stocked with roles from the cast:</p>
+<ul>
+<li><strong>Pam</strong> writes docs.</li>
+<li><strong>Dwight</strong> enforces QA (relentlessly).</li>
+<li><strong>Jim</strong> reviews PRs.</li>
+<li><strong>Creed</strong> audits security.</li>
+<li><strong>Angela</strong> audits the office’s <em>own</em> token spend — the accountant for your agents.</li>
+<li><strong>Stanley</strong> does the migrations nobody wants to touch.</li>
+</ul>
+<p>Each card carries one <strong>base manifest per role</strong>, with <strong>per-provider variants generated</strong> so you can flip a Claude Code / Antigravity / Codex toggle and get the same role configured for whichever CLI you run. <strong>Function filters</strong> let you find roles by what they do — review, docs, security, ops — instead of scrolling. Browse, hit ⚡hire, land in the pre-filled modal, review, spawn.</p>
+<p>One honest scope note: <strong>today, curation is a maintainer commit.</strong> There is deliberately <em>no public write or submission pipeline yet</em>. You can browse and hire, but you can’t push your own role into the gallery — that has to come through a maintainer. That’s a real cut, and an intentional one: a community submission queue is its own design problem (who reviews, what’s trusted, how you keep a public gallery from becoming an attack surface), and it deserves its own treatment rather than being bolted on half-built. The format is portable today; the <em>open submission loop</em> is the next conversation, not this one.</p>
+<h2 id="why-it-matters-a-registry-for-roles" tabindex="-1">Why it matters: a registry for roles <a class="anchor" href="#why-it-matters-a-registry-for-roles" aria-hidden="true">#</a></h2>
+<p>Here’s the thesis. Once a role is a portable artifact, something compounding happens — a <strong>community growth loop</strong>. The best-tuned roles can be shared, then forked, then improved, then shared again. The person who finally nails the “security auditor” prompt doesn’t keep that win to themselves and doesn’t bury it in a blog post; they export a hire, and everyone downstream starts from their best version instead of from a blank box. Good configuration stops being a thing each person rediscovers and becomes a thing the community <em>accumulates</em>.</p>
+<p>This is the same move package registries made for code. Before npm or PyPI, reusing a library meant copying files and re-reading install instructions; the registry turned “here’s how you set it up” into “here’s the artifact, take it.” Shareable Hires does that for agent <em>roles</em>. “Hire Pam” becomes the easy on-ramp that “write a system prompt” never was — and the floor that the <a href="/blog/how-the-god-orchestrator-works/">GOD orchestrator</a> coordinates can fill up with proven coworkers instead of guesses.</p>
+<p>It also fits the broader bet behind Munder Difflin: <strong>local-first, open-source, you own your floor.</strong> The roles are MIT, the gallery has no login or trackers, the binary that runs an agent is always your own, and the human is always the one who hits spawn. Portability here doesn’t mean handing control to a cloud — it means handing a <em>file</em> to a person, who stays in charge of what they do with it. (For why we <a href="/blog/why-we-built-munder-difflin/">built it this way</a> in the first place, the origin story has the rest.)</p>
+<h2 id="go-browse-the-hiring-fair" tabindex="-1">Go browse The Hiring Fair <a class="anchor" href="#go-browse-the-hiring-fair" aria-hidden="true">#</a></h2>
+<p>The fastest way to feel the idea is to use it. Open <a href="https://munderdiffl.in/hires/">The Hiring Fair</a>, pick a role that matches something on your plate, flip it to your provider, and hire it — then read every field in the modal before you spawn, because that review step is the whole point.</p>
+<ul>
+<li><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a> — the release.</li>
+<li><a href="/blog/hire-manifest-untrusted-input/">The hire manifest as untrusted input</a> — the security deep-dive on the trust model.</li>
+<li><a href="/blog/how-the-god-orchestrator-works/">Inside the GOD orchestrator</a> — who coordinates the roles you hire.</li>
+<li><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The clone army trap</a> — why a <em>mix</em> of well-chosen roles beats ten identical agents.</li>
+<li><a href="/blog/why-we-built-munder-difflin/">Why we built Munder Difflin</a> — the origin story.</li>
+<li><a href="https://github.com/chaitanyagiri/munder-difflin/blob/main/CHANGELOG.md">CHANGELOG</a> — everything that shipped.</li>
+</ul>
+
+
+
+ <section class="faq" aria-label="Frequently asked questions">
+ <h2 id="faq">FAQ</h2>
+
+ <div class="qa">
+ <p class="q">What is a &#39;shareable agent role&#39;?</p>
+ <p class="a">It&#39;s an agent role packaged as a portable file — a small JSON manifest (format id munder-difflin/hire@1) that captures everything needed to spin up a role-configured agent: name, avatar, provider, model, command flags, a goal/role description, capability tags, and a token budget. We call one a &#39;hire.&#39; Instead of explaining your setup in a tutorial, you hand someone the file and they get the same coworker.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Why should agent roles be portable at all?</p>
+ <p class="a">Because a good role is real, hard-won configuration work — the right provider and model, the right flags, a sharp goal prompt, sane capabilities and a token budget — and today that knowledge is trapped in one person&#39;s setup or buried in prose. Portability turns that tacit knowledge into an artifact you can share, fork, and improve, the same move package registries made for code libraries.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">If I import a role from a link, does it start running on its own?</p>
+ <p class="a">No. Import never spawns anything. It only pre-fills the Add-Agent modal behind an explicit &#39;imported&#39; banner. You review every field and you click spawn. A role you got from the internet is inert data until a human acts on it — the human is always the spawn gate.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">How is a role manifest different from just sharing a prompt?</p>
+ <p class="a">A prompt is one ingredient. A hire manifest is the whole recipe: which provider runs it, the model, the command flags, the goal, the capability tags, and the budget — mapped 1:1 onto the fields the app&#39;s Add-Agent flow already uses. It&#39;s the difference between a sentence in a README and a job description you can hand to anyone&#39;s office.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">What is The Hiring Fair?</p>
+ <p class="a">A static community gallery at munderdiffl.in/hires — no login, no trackers, MIT-licensed. It&#39;s stocked with ready-made roles from the cast: Pam writes docs, Dwight enforces QA, Jim reviews PRs, Creed audits security, Angela audits the office&#39;s own token spend, Stanley does the migrations nobody wants. Each card has a Claude Code / Antigravity / Codex toggle and function filters. Browse, hire, review, spawn.</p>
+ </div>
+
+ <div class="qa">
+ <p class="q">Can I submit my own roles to The Hiring Fair today?</p>
+ <p class="a">Not yet. Today, curation is a maintainer commit — there is deliberately no public write or submission pipeline. A community submission queue needs its own review-and-trust design, so we scoped it out of this first release rather than ship it half-built.</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/open-source/">Open Source</a><a class="tag" href="/blog/tags/agent-design/">Agent Design</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-problem-a-good-role-is-tacit-knowledge">The problem: a good role is tacit knowledge</a></li><li class="lvl-2"><a href="#the-idea-a-role-as-a-file-you-can-pass-around">The idea: a role as a file you can pass around</a></li><li class="lvl-3"><a href="#what-one-looks-like">What one looks like</a></li><li class="lvl-2"><a href="#two-ways-to-hire-one-pipeline">Two ways to hire, one pipeline</a></li><li class="lvl-2"><a href="#the-trust-design-import-never-spawns">The trust design: import never spawns</a></li><li class="lvl-2"><a href="#the-hiring-fair-a-gallery-of-ready-made-roles">The Hiring Fair: a gallery of ready-made roles</a></li><li class="lvl-2"><a href="#why-it-matters-a-registry-for-roles">Why it matters: a registry for roles</a></li><li class="lvl-2"><a href="#go-browse-the-hiring-fair">Go browse The Hiring Fair</a></li>
+ </ol>
+ </aside>
+
+ </div>
+
+ <footer class="post-foot wrap"><div class="prevnext">
+ <a class="pn prev" href="/blog/deploy-a-blog-writer-agent/"><span class="k">← Older</span><span class="t">Deploy a Blog-Writer Agent: The One That Wrote This Post</span></a>
+ <a class="pn next" href="/blog/launching-munder-difflin-v0-2-8/"><span class="k">Newer →</span><span class="t">Launching Munder Difflin v0.2.8: Shareable Hires</span></a>
+ </div>
+ <section class="related">
+ <h2>Related in Concepts</h2>
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-10">Jun 10, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>7 min</span>
+ </div>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-05">Jun 5, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>4 min</span>
+ </div>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </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/single-committer-git-pattern/index.html b/docs/blog/single-committer-git-pattern/index.html
index 49ff3d38..9bb74f32 100644
--- a/docs/blog/single-committer-git-pattern/index.html
+++ b/docs/blog/single-committer-git-pattern/index.html
@@ -291,56 +291,56 @@ never corrupt their own state; it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/tags/agent-design/index.html b/docs/blog/tags/agent-design/index.html
new file mode 100644
index 00000000..273a10ed
--- /dev/null
+++ b/docs/blog/tags/agent-design/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>Agent Design — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Agent Design." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/agent-design/" />
+
+<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="Agent Design — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Agent Design." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/agent-design/" />
+<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="Agent Design — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Agent Design." />
+<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>#Agent Design</h1>
+ <p class="lead">1 post tagged <strong>Agent Design</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>8 min</span>
+ </div>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
+ </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/claude-code/index.html b/docs/blog/tags/claude-code/index.html
index 8c85ec5c..0d173efb 100644
--- a/docs/blog/tags/claude-code/index.html
+++ b/docs/blog/tags/claude-code/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Claude Code</h1>
- <p class="lead">40 posts tagged <strong>Claude Code</strong>.</p>
+ <p class="lead">41 posts tagged <strong>Claude Code</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/tags/command-injection/index.html b/docs/blog/tags/command-injection/index.html
new file mode 100644
index 00000000..55bd0387
--- /dev/null
+++ b/docs/blog/tags/command-injection/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>Command Injection — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged Command Injection." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/command-injection/" />
+
+<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
+<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
+<meta name="theme-color" content="#F5F2E8" />
+
+<!-- Open Graph -->
+<meta property="og:site_name" content="Munder Difflin Blog" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Command Injection — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged Command Injection." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/command-injection/" />
+<meta property="og:image" content="https://munderdiffl.in/media/og.png" />
+<meta property="og:locale" content="en_US" />
+
+
+<!-- Twitter -->
+<meta name="twitter:card" content="summary_large_image" />
+<meta name="twitter:title" content="Command Injection — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged Command Injection." />
+<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>#Command Injection</h1>
+ <p class="lead">1 post tagged <strong>Command Injection</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
+ </div>
+ </div>
+</article>
+
+ </div>
+</section>
+
+
+</main>
+<footer>
+ <div class="wrap">
+ <div class="foot-top">
+ <a class="foot-brand brand" href="/blog/">
+ <span class="brand-mark">MD</span>
+ <span class="brand-word">MUNDER DIFFLIN<span class="sep">/</span><span class="blog">BLOG</span></span>
+ </a>
+ <div class="foot-links">
+ <a href="/blog/">Latest</a>
+ <a href="/blog/topics/">Topics</a>
+ <a href="/blog/about/">About</a>
+ <a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
+ <a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
+ <a href="https://munderdiffl.in">munderdiffl.in ↗</a>
+ </div>
+ </div>
+ <div class="foot-meta">
+ © 2026 Munder Difflin · Local-first · MIT-licensed ·
+ Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js &amp; node-pty</a>.
+ Run an office of agents while you sleep.
+ </div>
+ </div>
+</footer>
+
+<script>
+ // sticky-nav border on scroll
+ (function () {
+ var nav = document.getElementById('nav');
+ if (!nav) return;
+ var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
+ onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
+ })();
+</script>
+
+</body>
+</html>
diff --git a/docs/blog/tags/concepts/index.html b/docs/blog/tags/concepts/index.html
index 6975c111..0704581d 100644
--- a/docs/blog/tags/concepts/index.html
+++ b/docs/blog/tags/concepts/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Concepts</h1>
- <p class="lead">12 posts tagged <strong>Concepts</strong>.</p>
+ <p class="lead">13 posts tagged <strong>Concepts</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>8 min</span>
+ </div>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
diff --git a/docs/blog/tags/electron/index.html b/docs/blog/tags/electron/index.html
index efa5417d..b1208dd5 100644
--- a/docs/blog/tags/electron/index.html
+++ b/docs/blog/tags/electron/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Electron</h1>
- <p class="lead">3 posts tagged <strong>Electron</strong>.</p>
+ <p class="lead">4 posts tagged <strong>Electron</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
diff --git a/docs/blog/tags/internals/index.html b/docs/blog/tags/internals/index.html
index 4f445821..efc10c58 100644
--- a/docs/blog/tags/internals/index.html
+++ b/docs/blog/tags/internals/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Internals</h1>
- <p class="lead">22 posts tagged <strong>Internals</strong>.</p>
+ <p class="lead">23 posts tagged <strong>Internals</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/munder-difflin-v0-2-4-feature-walkthrough/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/multi-agent/index.html b/docs/blog/tags/multi-agent/index.html
index eedc53a5..883b250b 100644
--- a/docs/blog/tags/multi-agent/index.html
+++ b/docs/blog/tags/multi-agent/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Multi-Agent</h1>
- <p class="lead">61 posts tagged <strong>Multi-Agent</strong>.</p>
+ <p class="lead">63 posts tagged <strong>Multi-Agent</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>8 min</span>
+ </div>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
diff --git a/docs/blog/tags/open-source/index.html b/docs/blog/tags/open-source/index.html
index 56f10c8d..93a7d69a 100644
--- a/docs/blog/tags/open-source/index.html
+++ b/docs/blog/tags/open-source/index.html
@@ -58,11 +58,47 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Open Source</h1>
- <p class="lead">7 posts tagged <strong>Open Source</strong>.</p>
+ <p class="lead">9 posts tagged <strong>Open Source</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>8 min</span>
+ </div>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-use-cases" href="/blog/deploy-a-blog-writer-agent/" aria-hidden="true" tabindex="-1">
<span>USE CASES</span>
</a>
diff --git a/docs/blog/tags/release/index.html b/docs/blog/tags/release/index.html
index 21e9d040..2da6d0cf 100644
--- a/docs/blog/tags/release/index.html
+++ b/docs/blog/tags/release/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Release</h1>
- <p class="lead">3 posts tagged <strong>Release</strong>.</p>
+ <p class="lead">4 posts tagged <strong>Release</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/tags/security/index.html b/docs/blog/tags/security/index.html
index a5be29aa..ade53a29 100644
--- a/docs/blog/tags/security/index.html
+++ b/docs/blog/tags/security/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Security</h1>
- <p class="lead">5 posts tagged <strong>Security</strong>.</p>
+ <p class="lead">6 posts tagged <strong>Security</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-guides" href="/blog/mcp-security-tool-poisoning/" aria-hidden="true" tabindex="-1">
<span>GUIDES</span>
</a>
diff --git a/docs/blog/tags/ssrf/index.html b/docs/blog/tags/ssrf/index.html
new file mode 100644
index 00000000..15b5b55c
--- /dev/null
+++ b/docs/blog/tags/ssrf/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>SSRF — Munder Difflin Blog</title>
+<meta name="description" content="Munder Difflin blog posts tagged SSRF." />
+<link rel="canonical" href="https://munderdiffl.in/blog/tags/ssrf/" />
+
+<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="SSRF — Munder Difflin Blog" />
+<meta property="og:description" content="Munder Difflin blog posts tagged SSRF." />
+<meta property="og:url" content="https://munderdiffl.in/blog/tags/ssrf/" />
+<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="SSRF — Munder Difflin Blog" />
+<meta name="twitter:description" content="Munder Difflin blog posts tagged SSRF." />
+<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>#SSRF</h1>
+ <p class="lead">1 post tagged <strong>SSRF</strong>.</p>
+</header>
+<section class="wrap">
+ <div class="post-grid">
+ <article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">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/story/index.html b/docs/blog/tags/story/index.html
index a64e7aba..5e37ee48 100644
--- a/docs/blog/tags/story/index.html
+++ b/docs/blog/tags/story/index.html
@@ -58,11 +58,29 @@
<header class="page-head wrap">
<p class="eyebrow">Tag</p>
<h1>#Story</h1>
- <p class="lead">6 posts tagged <strong>Story</strong>.</p>
+ <p class="lead">7 posts tagged <strong>Story</strong>.</p>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html b/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html
index 1c02527e..8f39753b 100644
--- a/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html
+++ b/docs/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/index.html
@@ -303,56 +303,56 @@ source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/the-hook-shim-pattern/index.html b/docs/blog/the-hook-shim-pattern/index.html
index a22d1089..1980c733 100644
--- a/docs/blog/the-hook-shim-pattern/index.html
+++ b/docs/blog/the-hook-shim-pattern/index.html
@@ -280,56 +280,56 @@ at the mercy of the bridge.
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/the-office-parody-behind-munder-difflin/index.html b/docs/blog/the-office-parody-behind-munder-difflin/index.html
index 333c6833..dbe33b61 100644
--- a/docs/blog/the-office-parody-behind-munder-difflin/index.html
+++ b/docs/blog/the-office-parody-behind-munder-difflin/index.html
@@ -269,56 +269,56 @@ Michael’s already at his desk. Free and open source.</p>
<h2>Related in Story</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
- <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-07">Jun 7, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
- <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
+ <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-07">Jun 7, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
- <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
+ <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/topics/comparisons/index.html b/docs/blog/topics/comparisons/index.html
index 15630643..081796a8 100644
--- a/docs/blog/topics/comparisons/index.html
+++ b/docs/blog/topics/comparisons/index.html
@@ -70,20 +70,20 @@
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/" aria-current="page">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
diff --git a/docs/blog/topics/concepts/index.html b/docs/blog/topics/concepts/index.html
index 40042af5..8b4fd347 100644
--- a/docs/blog/topics/concepts/index.html
+++ b/docs/blog/topics/concepts/index.html
@@ -63,33 +63,51 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>concepts</h1>
- <p class="lead">15 posts in this cluster.</p>
+ <p class="lead">16 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/" aria-current="page">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
+ <span>CONCEPTS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>8 min</span>
+ </div>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
+ <div class="foot">
+ <span class="tag kind">Concepts</span>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
diff --git a/docs/blog/topics/guides/index.html b/docs/blog/topics/guides/index.html
index c86e88ee..33ac3cbb 100644
--- a/docs/blog/topics/guides/index.html
+++ b/docs/blog/topics/guides/index.html
@@ -70,20 +70,20 @@
<a class="chip" href="/blog/topics/guides/" aria-current="page">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
diff --git a/docs/blog/topics/index.html b/docs/blog/topics/index.html
index 2c228c4e..c1cc4d9b 100644
--- a/docs/blog/topics/index.html
+++ b/docs/blog/topics/index.html
@@ -79,7 +79,7 @@
<span class="thumb t-concepts" aria-hidden="true">CONCEPTS</span>
<div class="body">
<h3 style="color:var(--ink)">concepts</h3>
- <p class="dek">15 posts.</p>
+ <p class="dek">16 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -88,7 +88,7 @@
<span class="thumb t-internals" aria-hidden="true">INTERNALS</span>
<div class="body">
<h3 style="color:var(--ink)">internals</h3>
- <p class="dek">15 posts.</p>
+ <p class="dek">16 posts.</p>
<div class="foot"><span class="more">View topic →</span></div>
</div>
</a>
@@ -111,6 +111,15 @@
</div>
</a>
+ <a class="card" href="/blog/topics/story/" style="text-decoration:none">
+ <span class="thumb t-story" aria-hidden="true">STORY</span>
+ <div class="body">
+ <h3 style="color:var(--ink)">story</h3>
+ <p class="dek">6 posts.</p>
+ <div class="foot"><span class="more">View topic →</span></div>
+ </div>
+ </a>
+
<a class="card" href="/blog/topics/memory/" style="text-decoration:none">
<span class="thumb t-memory" aria-hidden="true">MEMORY</span>
<div class="body">
@@ -129,32 +138,23 @@
</div>
</a>
- <a class="card" href="/blog/topics/story/" style="text-decoration:none">
- <span class="thumb t-story" aria-hidden="true">STORY</span>
- <div class="body">
- <h3 style="color:var(--ink)">story</h3>
- <p class="dek">5 posts.</p>
- <div class="foot"><span class="more">View topic →</span></div>
- </div>
- </a>
-
</div>
<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">61</span></a>
+ <a class="chip" href="/blog/tags/multi-agent/">Multi-Agent<span class="ct">63</span></a>
- <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">40</span></a>
+ <a class="chip" href="/blog/tags/claude-code/">Claude Code<span class="ct">41</span></a>
- <a class="chip" href="/blog/tags/internals/">Internals<span class="ct">22</span></a>
+ <a class="chip" href="/blog/tags/internals/">Internals<span class="ct">23</span></a>
<a class="chip" href="/blog/tags/orchestration/">Orchestration<span class="ct">16</span></a>
<a class="chip" href="/blog/tags/guides/">Guides<span class="ct">14</span></a>
- <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">12</span></a>
+ <a class="chip" href="/blog/tags/concepts/">Concepts<span class="ct">13</span></a>
<a class="chip" href="/blog/tags/comparisons/">Comparisons<span class="ct">12</span></a>
@@ -162,24 +162,24 @@
<a class="chip" href="/blog/tags/tools/">Tools<span class="ct">9</span></a>
+ <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">9</span></a>
+
<a class="chip" href="/blog/tags/memory/">Memory<span class="ct">8</span></a>
<a class="chip" href="/blog/tags/getting-started/">Getting Started<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">7</span></a>
+ <a class="chip" href="/blog/tags/story/">Story<span class="ct">7</span></a>
- <a class="chip" href="/blog/tags/open-source/">Open Source<span class="ct">7</span></a>
+ <a class="chip" href="/blog/tags/local-first/">Local-First<span class="ct">7</span></a>
<a class="chip" href="/blog/tags/mempalace/">MemPalace<span class="ct">6</span></a>
<a class="chip" href="/blog/tags/use-cases/">Use Cases<span class="ct">6</span></a>
- <a class="chip" href="/blog/tags/story/">Story<span class="ct">6</span></a>
+ <a class="chip" href="/blog/tags/security/">Security<span class="ct">6</span></a>
<a class="chip" href="/blog/tags/hive/">Hive<span class="ct">6</span></a>
- <a class="chip" href="/blog/tags/security/">Security<span class="ct">5</span></a>
-
<a class="chip" href="/blog/tags/autonomous/">Autonomous<span class="ct">5</span></a>
<a class="chip" href="/blog/tags/cost/">Cost<span class="ct">5</span></a>
@@ -188,14 +188,16 @@
<a class="chip" href="/blog/tags/guardrails/">Guardrails<span class="ct">4</span></a>
+ <a class="chip" href="/blog/tags/electron/">Electron<span class="ct">4</span></a>
+
+ <a class="chip" href="/blog/tags/release/">Release<span class="ct">4</span></a>
+
<a class="chip" href="/blog/tags/workflow/">Workflow<span class="ct">3</span></a>
<a class="chip" href="/blog/tags/human-in-the-loop/">Human-in-the-Loop<span class="ct">3</span></a>
<a class="chip" href="/blog/tags/terminals/">Terminals<span class="ct">3</span></a>
- <a class="chip" href="/blog/tags/electron/">Electron<span class="ct">3</span></a>
-
<a class="chip" href="/blog/tags/mcp/">MCP<span class="ct">3</span></a>
<a class="chip" href="/blog/tags/architecture/">Architecture<span class="ct">3</span></a>
@@ -208,8 +210,6 @@
<a class="chip" href="/blog/tags/seo/">SEO<span class="ct">3</span></a>
- <a class="chip" href="/blog/tags/release/">Release<span class="ct">3</span></a>
-
<a class="chip" href="/blog/tags/god/">GOD<span class="ct">2</span></a>
<a class="chip" href="/blog/tags/messaging/">Messaging<span class="ct">2</span></a>
@@ -314,6 +314,12 @@
<a class="chip" href="/blog/tags/cli-agents/">CLI Agents<span class="ct">1</span></a>
+ <a class="chip" href="/blog/tags/command-injection/">Command Injection<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/ssrf/">SSRF<span class="ct">1</span></a>
+
+ <a class="chip" href="/blog/tags/agent-design/">Agent Design<span class="ct">1</span></a>
+
</div>
</section>
diff --git a/docs/blog/topics/internals/index.html b/docs/blog/topics/internals/index.html
index c3c0ea3e..014d9137 100644
--- a/docs/blog/topics/internals/index.html
+++ b/docs/blog/topics/internals/index.html
@@ -63,33 +63,51 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>internals</h1>
- <p class="lead">15 posts in this cluster.</p>
+ <p class="lead">16 posts in this cluster.</p>
<div class="filters" role="navigation" aria-label="Topics">
<a class="chip" href="/blog/">All</a>
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/" aria-current="page">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
+ <span>INTERNALS</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>12 min</span>
+ </div>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
+ <div class="foot">
+ <span class="tag kind">Internals</span>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
diff --git a/docs/blog/topics/memory/index.html b/docs/blog/topics/memory/index.html
index 526ea227..391aaeb3 100644
--- a/docs/blog/topics/memory/index.html
+++ b/docs/blog/topics/memory/index.html
@@ -70,20 +70,20 @@
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
diff --git a/docs/blog/topics/orchestration/index.html b/docs/blog/topics/orchestration/index.html
index ea01c9a0..3b7bf8ad 100644
--- a/docs/blog/topics/orchestration/index.html
+++ b/docs/blog/topics/orchestration/index.html
@@ -70,20 +70,20 @@
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/" aria-current="page">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
diff --git a/docs/blog/topics/story/index.html b/docs/blog/topics/story/index.html
index 7a77e6f7..a1ba3f51 100644
--- a/docs/blog/topics/story/index.html
+++ b/docs/blog/topics/story/index.html
@@ -63,33 +63,51 @@
</nav>
<p class="eyebrow">Topic</p>
<h1>story</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/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/" aria-current="page">story<span class="ct">5</span></a>
-
</div>
</header>
<section class="wrap">
<div class="post-grid">
<article class="card">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
+ <span>STORY</span>
+ </a>
+ <div class="body">
+ <div class="meta">
+ <time datetime="2026-06-15">Jun 15, 2026</time>
+ <span class="dot" aria-hidden="true"></span>
+ <span>6 min</span>
+ </div>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
+ <div class="foot">
+ <span class="tag kind">Story</span>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
+ </div>
+ </div>
+</article>
+<article class="card">
<a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
diff --git a/docs/blog/topics/use-cases/index.html b/docs/blog/topics/use-cases/index.html
index afa83f01..3ab37b9d 100644
--- a/docs/blog/topics/use-cases/index.html
+++ b/docs/blog/topics/use-cases/index.html
@@ -70,20 +70,20 @@
<a class="chip" href="/blog/topics/guides/">guides<span class="ct">25</span></a>
- <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/concepts/">concepts<span class="ct">16</span></a>
- <a class="chip" href="/blog/topics/internals/">internals<span class="ct">15</span></a>
+ <a class="chip" href="/blog/topics/internals/">internals<span class="ct">16</span></a>
<a class="chip" href="/blog/topics/comparisons/">comparisons<span class="ct">12</span></a>
<a class="chip" href="/blog/topics/orchestration/">orchestration<span class="ct">9</span></a>
+ <a class="chip" href="/blog/topics/story/">story<span class="ct">6</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">5</span></a>
- <a class="chip" href="/blog/topics/story/">story<span class="ct">5</span></a>
-
</div>
</header>
diff --git a/docs/blog/visualizing-ai-agents-pixijs/index.html b/docs/blog/visualizing-ai-agents-pixijs/index.html
index 13d9ebad..f3c214c7 100644
--- a/docs/blog/visualizing-ai-agents-pixijs/index.html
+++ b/docs/blog/visualizing-ai-agents-pixijs/index.html
@@ -281,56 +281,56 @@ to see your agents at work; it’s free and open source.</p>
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/hire-manifest-untrusted-input/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>12 min</span>
</div>
- <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
- <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
+ <h3><a href="/blog/hire-manifest-untrusted-input/">Treating a Hire Manifest as Untrusted Input</a></h3>
+ <p class="dek">A shareable agent-config manifest is attacker input. How Munder Difflin&#39;s import pipeline stays inert: no auto-spawn, default-deny flags, and an SSRF-safe bounded fetch.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
+ <a class="more" href="/blog/hire-manifest-untrusted-input/" aria-label="Read: Treating a Hire Manifest as Untrusted Input">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/compressing-agent-memory/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
- <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
- <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
+ <h3><a href="/blog/compressing-agent-memory/">Compressing Agent Memory Without Losing the Original</a></h3>
+ <p class="dek">How and why to compress an agent&#39;s long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
+ <a class="more" href="/blog/compressing-agent-memory/" aria-label="Read: Compressing Agent Memory Without Losing the Original">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-internals" href="/blog/file-based-coordination-vs-message-queues/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-internals" href="/blog/architecture-two-planes-one-renderer/" aria-hidden="true" tabindex="-1">
<span>INTERNALS</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-04">Jun 4, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>5 min</span>
</div>
- <h3><a href="/blog/file-based-coordination-vs-message-queues/">File-Based Coordination vs Message Queues for AI Agents</a></h3>
- <p class="dek">Why a local agent hive coordinates through plain files, not Redis or RabbitMQ: the zero-ops wins, the real tradeoffs, and where files hit a ceiling.</p>
+ <h3><a href="/blog/architecture-two-planes-one-renderer/">Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer</a></h3>
+ <p class="dek">A walkthrough of the multi-agent harness architecture: a node-pty terminal plane and a hooks/hive event plane feeding one React + Pixi.js renderer.</p>
<div class="foot">
<span class="tag kind">Internals</span>
- <a class="more" href="/blog/file-based-coordination-vs-message-queues/" aria-label="Read: File-Based Coordination vs Message Queues for AI Agents">Read →</a>
+ <a class="more" href="/blog/architecture-two-planes-one-renderer/" aria-label="Read: Munder Difflin&#39;s Architecture: Two Data Planes, One Renderer">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/what-are-claude-code-agents/index.html b/docs/blog/what-are-claude-code-agents/index.html
index d03e248b..716fef4c 100644
--- a/docs/blog/what-are-claude-code-agents/index.html
+++ b/docs/blog/what-are-claude-code-agents/index.html
@@ -247,25 +247,25 @@ 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/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -274,29 +274,29 @@ into an office; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
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 2b40783e..f92f26c4 100644
--- a/docs/blog/what-is-a-multi-agent-harness/index.html
+++ b/docs/blog/what-is-a-multi-agent-harness/index.html
@@ -234,25 +234,25 @@ 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/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -261,29 +261,29 @@ want to watch a coordinated team of agents work an office floor,
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/what-is-aeo-for-dev-tools/index.html b/docs/blog/what-is-aeo-for-dev-tools/index.html
index da631362..67779485 100644
--- a/docs/blog/what-is-aeo-for-dev-tools/index.html
+++ b/docs/blog/what-is-aeo-for-dev-tools/index.html
@@ -367,25 +367,25 @@ harness actually is</a>. Free and MIT-licensed.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -394,29 +394,29 @@ harness actually is</a>. Free and MIT-licensed.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/when-do-agents-need-an-agent-protocol/index.html b/docs/blog/when-do-agents-need-an-agent-protocol/index.html
index 6a2b7580..4128b200 100644
--- a/docs/blog/when-do-agents-need-an-agent-protocol/index.html
+++ b/docs/blog/when-do-agents-need-an-agent-protocol/index.html
@@ -277,25 +277,25 @@ of agents without protocol ceremony; it’s free and open source.</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
@@ -304,29 +304,29 @@ of agents without protocol ceremony; it’s free and open source.</p>
<span class="dot" aria-hidden="true"></span>
<span>7 min</span>
</div>
- <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
- <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/why-cli-agents-are-powerful/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/why-cli-agents-are-powerful/">Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work</a></h3>
+ <p class="dek">CLI agents are powerful because they have terminal-level access: they run builds, tests, and git, and verify their own work by executing it. Here&#39;s why that matters — and the concrete ways Munder Difflin cuts token consumption while doing it.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/why-cli-agents-are-powerful/" aria-label="Read: Why CLI Agents Are So Powerful — and How Munder Difflin Spends Fewer Tokens Doing the Same Work">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/why-cli-agents-are-powerful/index.html b/docs/blog/why-cli-agents-are-powerful/index.html
index 2815f62d..7d35d82d 100644
--- a/docs/blog/why-cli-agents-are-powerful/index.html
+++ b/docs/blog/why-cli-agents-are-powerful/index.html
@@ -315,56 +315,56 @@ capability routing (right agent, not the priciest one).</p>
<h2>Related in Concepts</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/shareable-agent-roles/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-10">Jun 10, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>8 min</span>
</div>
- <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
- <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
+ <h3><a href="/blog/shareable-agent-roles/">Shareable Agent Roles: A Portable Format for Hiring AI Coworkers</a></h3>
+ <p class="dek">Why agent roles should be portable: what a hire manifest encodes, how one-click hiring stays safe, and how The Hiring Fair turns tacit setup into a shareable artifact.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
+ <a class="more" href="/blog/shareable-agent-roles/" aria-label="Read: Shareable Agent Roles: A Portable Format for Hiring AI Coworkers">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-05">Jun 5, 2026</time>
+ <time datetime="2026-06-10">Jun 10, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>4 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
- <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
+ <h3><a href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/">The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents</a></h3>
+ <p class="dek">Spinning up tens of identical top-tier CLI agents feels powerful and burns tokens on work a cheaper agent could do. A mixed-capability swarm with shared memory wins on cost — and often on quality.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
+ <a class="more" href="/blog/the-clone-army-trap-mixed-swarm-vs-identical-agents/" aria-label="Read: The Clone Army Is a Trap: Why a Mixed Swarm Beats Ten Identical Agents">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-concepts" href="/blog/agents-rule-of-two/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-concepts" href="/blog/generative-engine-optimization-techniques/" aria-hidden="true" tabindex="-1">
<span>CONCEPTS</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-04">Jun 4, 2026</time>
+ <time datetime="2026-06-05">Jun 5, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>5 min</span>
+ <span>4 min</span>
</div>
- <h3><a href="/blog/agents-rule-of-two/">The Agents Rule of Two: A Simple Safety Rule for Coding Agents</a></h3>
- <p class="dek">Meta&#39;s Agents Rule of Two for coding agents: don&#39;t let one session combine untrusted input, private data, and external reach at once — or supervise.</p>
+ <h3><a href="/blog/generative-engine-optimization-techniques/">Generative Engine Optimization: The Techniques the Research Backs</a></h3>
+ <p class="dek">What the first peer-reviewed GEO study found works to get content cited by AI — statistics, source citations, quotes — and why keyword stuffing backfires.</p>
<div class="foot">
<span class="tag kind">Concepts</span>
- <a class="more" href="/blog/agents-rule-of-two/" aria-label="Read: The Agents Rule of Two: A Simple Safety Rule for Coding Agents">Read →</a>
+ <a class="more" href="/blog/generative-engine-optimization-techniques/" aria-label="Read: Generative Engine Optimization: The Techniques the Research Backs">Read →</a>
</div>
</div>
</article>
diff --git a/docs/blog/why-we-built-munder-difflin/index.html b/docs/blog/why-we-built-munder-difflin/index.html
index e82f3fe8..0eaf7f78 100644
--- a/docs/blog/why-we-built-munder-difflin/index.html
+++ b/docs/blog/why-we-built-munder-difflin/index.html
@@ -211,56 +211,56 @@ Munder Difflin</a> — it’s open source and local-first, on macOS, Windows, an
<h2>Related in Story</h2>
<div class="post-grid">
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-8/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-09">Jun 9, 2026</time>
+ <time datetime="2026-06-15">Jun 15, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
- <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-8/">Launching Munder Difflin v0.2.8: Shareable Hires</a></h3>
+ <p class="dek">Munder Difflin v0.2.8 ships Shareable Hires: a one-click, portable agent role manifest + The Hiring Fair gallery. Click a hire link, review every field, then spawn it yourself.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-8/" aria-label="Read: Launching Munder Difflin v0.2.8: Shareable Hires">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-4/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
- <time datetime="2026-06-07">Jun 7, 2026</time>
+ <time datetime="2026-06-09">Jun 9, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>7 min</span>
+ <span>6 min</span>
</div>
- <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
- <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-4/">Launching Munder Difflin v0.2.4</a></h3>
+ <p class="dek">Munder Difflin v0.2.4 is here: Claude Code, OpenAI Codex, and Antigravity (Gemini) agents now run as one hive with full parity — no API keys, no setup. Brief a GOD orchestrator, automate basically anything in one prompt, and close the lid while it keeps working.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-4/" aria-label="Read: Launching Munder Difflin v0.2.4">Read →</a>
</div>
</div>
</article>
<article class="card">
- <a class="thumb t-story" href="/blog/one-prompt-automated-pr-review/" aria-hidden="true" tabindex="-1">
+ <a class="thumb t-story" href="/blog/launching-munder-difflin-v0-2-0/" aria-hidden="true" tabindex="-1">
<span>STORY</span>
</a>
<div class="body">
<div class="meta">
<time datetime="2026-06-07">Jun 7, 2026</time>
<span class="dot" aria-hidden="true"></span>
- <span>6 min</span>
+ <span>7 min</span>
</div>
- <h3><a href="/blog/one-prompt-automated-pr-review/">One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story</a></h3>
- <p class="dek">How a single prompt to the Munder Difflin god agent reviewed all open PRs and set up a recurring hourly PR reviewer — while the repo was blowing up with 400+ stars.</p>
+ <h3><a href="/blog/launching-munder-difflin-v0-2-0/">Launching Munder Difflin v0.2.0</a></h3>
+ <p class="dek">Munder Difflin v0.2.0 is here: a Command Center overhaul, per-agent token budgets, live OpenTelemetry observability, a circuit breaker, durable SQLite persistence, and a big round of community fixes.</p>
<div class="foot">
<span class="tag kind">Story</span>
- <a class="more" href="/blog/one-prompt-automated-pr-review/" aria-label="Read: One Prompt, Five PR Reviews, and an Hourly Automation — A Dogfooding Story">Read →</a>
+ <a class="more" href="/blog/launching-munder-difflin-v0-2-0/" aria-label="Read: Launching Munder Difflin v0.2.0">Read →</a>
</div>
</div>
</article>
diff --git a/docs/index.html b/docs/index.html
index 315ac671..98257665 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -688,6 +688,7 @@
<a href="#support">Support</a>
</div>
<div class="nav-actions">
+ <a class="btn ghost sm" href="/hires/">Hires</a>
<a class="btn ghost sm" href="/blog/">Blog</a>
<a class="btn ghost sm nav-ghost" data-gh-stars href="https://github.com/chaitanyagiri/munder-difflin">★ Star<span class="star-count"></span></a>
<a class="btn primary sm" data-download data-align="right" href="https://github.com/chaitanyagiri/munder-difflin/releases/latest"><span class="ic">⤓</span> Download</a>
@@ -863,6 +864,21 @@
</div>
</div>
+ <!-- WIDE: Shareable hires (new in v0.2.8) -->
+ <div class="fb-wide reveal">
+ <div class="fb-ic">🤝</div>
+ <div class="fb-content">
+ <div class="fb-tag">Shareable hires · New in v0.2.8</div>
+ <div class="fb-head">Hire a ready-made role in one click</div>
+ <div class="fb-desc">Browse <a href="/hires/">The Hiring Fair</a> and bring a tuned agent straight into your office — Pam on docs, Dwight on QA, Jim on PR review, Creed on security. A portable hire manifest pre-fills the Add-Agent form; you review every field and spawn it yourself. Import never runs anything on its own.</div>
+ <div class="fb-badges">
+ <span class="fb-badge"><span class="dot" style="background:var(--sky);"></span>Deep-link or file</span>
+ <span class="fb-badge"><span class="dot" style="background:var(--mint);"></span>Human-reviewed</span>
+ <span class="fb-badge"><span class="dot" style="background:var(--peach);"></span>Untrusted-input safe</span>
+ </div>
+ </div>
+ </div>
+
</div>
</div>
</section>
diff --git a/docs/sitemap.xml b/docs/sitemap.xml
index c11c9b30..25134c69 100644
--- a/docs/sitemap.xml
+++ b/docs/sitemap.xml
@@ -10,13 +10,31 @@
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https://munderdiffl.in/</loc>
- <lastmod>2026-06-09</lastmod>
+ <lastmod>2026-06-14</lastmod>
<changefreq>weekly</changefreq>
<priority>1.0</priority>
</url>
<url><loc>https://munderdiffl.in/blog/</loc><changefreq>daily</changefreq><priority>0.9</priority></url>
<url><loc>https://munderdiffl.in/blog/topics/</loc><changefreq>weekly</changefreq><priority>0.6</priority></url>
<url><loc>https://munderdiffl.in/blog/about/</loc><changefreq>monthly</changefreq><priority>0.4</priority></url>
+ <url>
+ <loc>https://munderdiffl.in/blog/hire-manifest-untrusted-input/</loc>
+ <lastmod>2026-06-15</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/launching-munder-difflin-v0-2-8/</loc>
+ <lastmod>2026-06-15</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
+ <url>
+ <loc>https://munderdiffl.in/blog/shareable-agent-roles/</loc>
+ <lastmod>2026-06-15</lastmod>
+ <changefreq>monthly</changefreq>
+ <priority>0.8</priority>
+ </url>
<url>
<loc>https://munderdiffl.in/blog/deploy-a-blog-writer-agent/</loc>
<lastmod>2026-06-10</lastmod>
@@ -568,9 +586,9 @@
<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/story/</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>
@@ -580,30 +598,30 @@
<url><loc>https://munderdiffl.in/blog/tags/comparisons/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/automation/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/tools/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/open-source/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/memory/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/getting-started/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/story/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/local-first/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/open-source/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/mempalace/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/use-cases/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/story/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/hive/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/security/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/hive/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/autonomous/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/cost/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/observability/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/guardrails/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/electron/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/release/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/workflow/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/human-in-the-loop/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/terminals/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/electron/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/mcp/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/architecture/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/model-routing/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/agentic-ai/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/aeo/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/seo/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
- <url><loc>https://munderdiffl.in/blog/tags/release/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/god/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/messaging/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/faq/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
@@ -656,4 +674,7 @@
<url><loc>https://munderdiffl.in/blog/tags/github/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/webhooks/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
<url><loc>https://munderdiffl.in/blog/tags/cli-agents/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/command-injection/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/ssrf/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
+ <url><loc>https://munderdiffl.in/blog/tags/agent-design/</loc><changefreq>weekly</changefreq><priority>0.3</priority></url>
</urlset>