Treating a Hire Manifest as Untrusted Input
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.
Internals
Read →
Tag
#Internals
23 posts tagged Internals.
Munder Difflin v0.2.4 Feature Walkthrough
A comprehensive guide to every change in Munder Difflin v0.2.4 — how the Codex lifecycle-hook bridge achieves full hive parity, what the Schedules tab adds, why tunnelmole replaced localtunnel, and what else shipped.
Guides
Read →
Compressing Agent Memory Without Losing the Original
How and why to compress an agent's long-term memory: the toolbox, the lossy trap, and keeping a lossless original beside a compact copy.
Internals
Read →
Running AI Agents Safely: Permission Modes and Sandboxing
How to run autonomous AI agents safely: permission modes and the bypassPermissions foot-gun, workspace isolation, and what to gate vs. allow.
Guides
Read →
Munder Difflin's Architecture: Two Data Planes, One Renderer
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.
Internals
Read →
Building Reliable AI Agents: Failure Is the Default
Agents fail constantly: tools error, steps stall, output goes wrong. Reliability isn't avoiding failure — it's making each one contained and recoverable.
Guides
Read →
File-Based Coordination vs Message Queues for AI Agents
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.
Internals
Read →
Approving AI Agents: Human-in-the-Loop Without a Queue
How to approve what AI agents do without a parallel approval queue: native permission prompts, routing 'to: human' to the orchestrator, remote approval.
Guides
Read →
Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud
How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.
Orchestration
Read →
Observability for Agent Fleets: Seeing What Your Agents Do
Agent fleet observability: the four questions your dashboard must answer about who's working, what they're doing, what it costs, and what they know.
Internals
Read →
Recovering From Agent Failures: Resilience Patterns for a Hive
How multi-agent systems survive partial failure: retry with stale-lock recovery, poison-message quarantine, hop-cap circuit breaking, idempotent handling.
Internals
Read →
The Hook Shim Pattern: Wiring Agent Hooks to a Live Process
How a tiny shim bridges Claude Code's lifecycle hooks to one live process over a Unix socket, turning per-event hooks into a telemetry and control channel.
Internals
Read →
When Do AI Agents Actually Need an Agent Protocol?
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.
Concepts
Read →
Building a Terminal UI with xterm.js and node-pty
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.
Internals
Read →
Building an AI "Office Floor": Avatars, Pathfinding, Envelopes
The game-dev techniques behind a dev tool's office floor: Tiled maps, BFS pathfinding, sprite recoloring, and flying message envelopes in Pixi.js.
Internals
Read →
Claude Code Hooks, Explained (PreToolUse, PostToolUse, Stop)
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.
Internals
Read →
Real Terminals in Electron with node-pty
How to run byte-for-byte authentic shells inside Electron with node-pty: the native-rebuild gotcha, the macOS PATH trap, and streaming PTY output over IPC.
Internals
Read →
Rendering Many Live Terminals Without Melting the CPU
xterm.js performance for many live PTYs: a terminal pool, render-only-visible, smart scrollback, and accelerated rendering to stream dozens at once.
Internals
Read →
The Single-Committer Pattern: Multi-Agent Git Without Corruption
Parallel agents corrupt a repo with index.lock races. The single-committer pattern — agents write, one process commits — fixes concurrent git writes.
Internals
Read →
Visualizing AI Agents with Pixi.js: An Office You Can Watch
How we render AI agents as avatars on a Pixi.js office floor — driven by real hook and message events, with seat assignment, pathing, and flying envelopes.
Internals
Read →
An Append-Only Event Log for a Hive of Agents
How an append-only event log makes a multi-agent system debuggable and replayable: what to record, and why one JSON line per event beats a database.
Internals
Read →
Atomic File Mailboxes: How Agents Message Each Other
Can Claude Code agents talk to each other? Yes — the outbox-router-inbox design that lets agents message safely using plain files and atomic renames.
Internals
Read →
Inside the GOD Orchestrator: Routing, Adjudication, Escalation
A deep dive into the Claude Code orchestrator: how a GOD agent reads requests, routes work, adjudicates routine traffic, and escalates the critical few.
Orchestration
Read →