an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions
HTML agent-harnessagent-orchestrationagentsai-agentsautonomous-agentsclaude-codecodexcoding-agentsdesktop-appdeveloper-toolselectrongemini-cliharnessharness-engineeringlocal-firstmemorymulti-agentopencodeorchestrationtypescript
<!doctype html>
<html lang="en">
<head>
<!-- Google tag (gtag.js), Google Ads AW-18388216863. Loaded only when Do Not Track is
off, so it follows the same rule as the PostHog block on this site. -->
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){ dataLayer.push(arguments); }
if (navigator.doNotTrack !== '1') {
var gtagScript = document.createElement('script');
gtagScript.async = true;
gtagScript.src = 'https://www.googletagmanager.com/gtag/js?id=AW-18388216863';
document.head.appendChild(gtagScript);
gtag('js', new Date());
gtag('config', 'AW-18388216863');
}
</script>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>An Append-Only Event Log for a Hive of Agents — Munder Difflin Blog</title>
<meta name="description" content="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." />
<link rel="canonical" href="https://munderdiffl.in/blog/append-only-event-log-agents/" />
<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
<meta name="theme-color" content="#F5F2E8" />
<!-- Open Graph -->
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="An Append-Only Event Log for a Hive of Agents — Munder Difflin Blog" />
<meta property="og:description" content="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." />
<meta property="og:url" content="https://munderdiffl.in/blog/append-only-event-log-agents/" />
<meta property="og:image" content="https://munderdiffl.in/blog/assets/media/append-only-event-log-agents/hero.png" />
<meta property="og:image:width" content="1600" />
<meta property="og:image:height" content="900" />
<meta property="og:image:alt" content="Illustration: An Append-Only Event Log for a Hive of Agents" />
<meta property="og:locale" content="en_US" />
<meta property="article:published_time" content="2026-06-01T00:00:00.000Z" />
<meta property="article:author" content="Chaitanya Giri" />
<meta property="article:tag" content="Internals" />
<meta property="article:tag" content="Observability" />
<meta property="article:tag" content="Multi-Agent" />
<meta property="article:tag" content="Event Log" />
<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="An Append-Only Event Log for a Hive of Agents — Munder Difflin Blog" />
<meta name="twitter:description" content="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." />
<meta name="twitter:image" content="https://munderdiffl.in/blog/assets/media/append-only-event-log-agents/hero.png" />
<meta name="twitter:image:alt" content="Illustration: An Append-Only Event Log for a Hive of Agents" />
<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=Fraunces:opsz,[email protected],500;9..144,600;9..144,700;9..144,900&family=Source+Serif+4:opsz,[email protected],400;8..60,600;8..60,700&family=Space+Grotesk:wght@500;600;700&family=JetBrains+Mono:wght@400;600&display=swap" rel="stylesheet" />
<link rel="stylesheet" href="/blog/assets/blog-press.css" />
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "An Append-Only Event Log for a Hive of Agents",
"description": "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.",
"image": ["https://munderdiffl.in/blog/assets/media/append-only-event-log-agents/hero.png"],
"datePublished": "2026-06-01T00:00:00.000Z",
"dateModified": "2026-06-01T00: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/append-only-event-log-agents/" },
"keywords": "ai agent event log, event sourcing, append-only log, agent observability",
"articleSection": "Internals",
"inLanguage": "en-US",
"url": "https://munderdiffl.in/blog/append-only-event-log-agents/"
}
</script>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{ "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
{ "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
{ "@type": "ListItem", "position": 3, "name": "An Append-Only Event Log for a Hive of Agents", "item": "https://munderdiffl.in/blog/append-only-event-log-agents/" }
]
}
</script>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{ "@type": "Question", "name": "What is an append-only event log in a multi-agent system?", "acceptedAnswer": { "@type": "Answer", "text": "It's a file that only ever grows: every meaningful thing that happens — an agent spawns, a message routes, an item escalates — is recorded as one timestamped line, never edited or deleted. It becomes the system's ground-truth history for debugging and replay." } },
{ "@type": "Question", "name": "Why one JSON object per line instead of a database?", "acceptedAnswer": { "@type": "Answer", "text": "Line-delimited JSON (JSONL) is append-cheap, crash-safe, human-readable, and trivially tailable. Appending a line is a single, atomic-enough write; readers parse line by line and track their own position. You get observability with no schema migrations and no server." } },
{ "@type": "Question", "name": "What should each event record?", "acceptedAnswer": { "@type": "Answer", "text": "A timestamp plus a small, typed payload: the kind of event and the few fields that matter for it — who spawned, who messaged whom, what was escalated. Keep events small and factual; the value is in the sequence, not in any one fat record." } }
]
}
</script>
<script>
// Anonymous blog analytics (PostHog) — same posture as the main site and the
// app's TELEMETRY.md: public write-only token ('' = inert), anonymous-only
// (person_profiles 'never'), no autocapture/recording, DNT respected.
(function () {
var PH_KEY = 'phc_qJzsokwcbtTGHemnvywR3nSqivNNgMjHeNVEWkZNydFB';
if (!PH_KEY || navigator.doNotTrack === '1') return;
var s = document.createElement('script');
s.async = true;
s.src = 'https://us-assets.i.posthog.com/static/array.js';
s.onload = function () {
if (!window.posthog) return;
window.posthog.init(PH_KEY, {
api_host: 'https://us.i.posthog.com',
person_profiles: 'never',
autocapture: false,
before_send: function (event) {
// PostHog fills $ip from the connection unless the event carries one.
// Null it here and disable the GeoIP lookup so no IP, city, postal
// code or lat/long is ever derived or stored for this page view.
if (event && event.properties) {
event.properties.$ip = null;
event.properties.$geoip_disable = true;
}
return event;
},
disable_session_recording: true,
respect_dnt: true
});
};
document.head.appendChild(s);
})();
</script>
</head>
<body class="theme-press">
<a class="skip-link" href="#main">Skip to content</a>
<nav id="nav">
<a class="brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">
<img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />
</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 class="t-internals">
<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>An Append-Only Event Log for a Hive of Agents</h1>
<p class="dek">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.</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-01">Jun 1, 2026</time>
<span class="dot" aria-hidden="true">·</span>
<span>5 min read</span>
<span class="tag kind">Internals</span>
</div>
</header>
<div class="hero-wrap wrap"><figure class="fig fig-hero"><img src="/blog/assets/media/append-only-event-log-agents/hero.png" alt="Illustration: An Append-Only Event Log for a Hive of Agents" loading="lazy" decoding="async" /></figure></div>
<div class="post-wrap wrap">
<div class="prose">
<div class="callout tldr"><span class="ic">TL;DR</span><p>An <strong>append-only event log</strong>
records every meaningful thing a hive does as one timestamped JSON line that's never edited or
deleted. It turns a multi-agent system from a black box into something
<strong>debuggable and replayable</strong>: you read the sequence back to see exactly what happened.
One JSONL file, written by the single committer, beats a database for this job — cheap to append,
crash-safe, and human-readable.</p></div>
<p>When a hive of agents does something surprising, the first question is always “what actually
happened?” Without a record, you’re guessing from terminal scrollback and vibes. The fix is the
oldest trick in distributed systems: write down everything, in order, and never change it. This post
covers what an append-only event log is, what to put in it, and why it’s the backbone of multi-agent
observability.</p>
<h2 id="append-only-in-one-sentence" tabindex="-1">Append-only, in one sentence <a class="anchor" href="#append-only-in-one-sentence" aria-hidden="true">#</a></h2>
<p>An append-only log is a file you only ever add to. Each line is one event — a small, timestamped,
typed record of something that happened. You never go back and edit or delete a line. The log grows
forever (or until you rotate it), and its <em>order</em> is the truth: event N happened before event N+1,
always.</p>
<p>That immutability is the whole value. A mutable status table tells you the <em>current</em> state; an
append-only log tells you the <em>story</em> — how you got to the current state, step by step. For debugging
a system where many agents act concurrently, the story is what you need.</p>
<h2 id="one-json-object-per-line" tabindex="-1">One JSON object per line <a class="anchor" href="#one-json-object-per-line" aria-hidden="true">#</a></h2>
<p>The format that makes this practical is <strong>JSONL</strong> — one JSON object per line:</p>
<pre class="language-jsonl"><code class="language-jsonl">{"ts":1717286400123,"kind":"spawn","agentId":"researcher","name":"Researcher","isGod":false}
{"ts":1717286400456,"kind":"message","from":"researcher","to":"coder","act":"request","subject":"Need the schema","id":"…-a1b2"}
{"ts":1717286401789,"kind":"drain","agentId":"coder","count":1}
{"ts":1717286402111,"kind":"escalate","from":"coder","to":"human","subject":"Drop the users table?","id":"…-c3d4"}
{"ts":1717286402999,"kind":"approval","id":"…-c3d4","approve":false}</code></pre>
<p>Why JSONL specifically:</p>
<ul>
<li><strong>Appending is cheap and safe.</strong> Adding a line is a single write to the end of the file. There’s no
index to update, no row to lock, no migration to run.</li>
<li><strong>It’s tailable.</strong> <code>tail -f</code> the file and you have a live activity feed. The same stream drives a UI
activity panel in real time.</li>
<li><strong>It’s human-readable.</strong> When something breaks, you <code>cat</code> the log and read it. No query language, no
admin tool.</li>
<li><strong>Readers track their own position.</strong> Each consumer remembers how far it has read (a cursor) and
picks up new lines from there. Multiple consumers, no coordination.</li>
</ul>
<p>A database would give you indexes and queries you mostly don’t need here, at the cost of a schema and a
server. For an audit/observability log, plain JSONL is the right amount of technology.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/append-only-event-log-agents/note-1.png" alt="Hand-drawn sketch from “An Append-Only Event Log for a Hive of Agents”" loading="lazy" decoding="async" /></figure>
<h2 id="what-to-record-per-event" tabindex="-1">What to record per event <a class="anchor" href="#what-to-record-per-event" aria-hidden="true">#</a></h2>
<p>The art is choosing events that are <strong>small, typed, and factual.</strong> Each line carries a <code>ts</code>
(timestamp) and a <code>kind</code>, plus only the fields that matter for that kind. In a hive, the events worth
logging are the coordination milestones:</p>
<ul>
<li><strong><code>spawn</code></strong> — an agent was created (id, name, whether it’s the orchestrator).</li>
<li><strong><code>message</code></strong> — a message routed between agents (from, to, act, subject, id).</li>
<li><strong><code>drain</code></strong> — an agent’s inbox was drained at a lifecycle point (who, how many).</li>
<li><strong><code>escalate</code></strong> — an item was routed to the human-approval queue (from, subject, id).</li>
<li><strong><code>approval</code></strong> — a human resolved an escalation (id, approved or rejected).</li>
</ul>
<p>Notice what’s <em>not</em> there: no giant payloads, no full message bodies, no model outputs. The log is an
index of <em>what happened and when</em>, with ids that point at the fuller artifacts (the message files,
the memory). Keep each event a few fields wide and the log stays fast to write, cheap to store, and
easy to read. The value is in the sequence, not in any single fat record.</p>
<h2 id="who-writes-it-and-why-that-matters" tabindex="-1">Who writes it (and why that matters) <a class="anchor" href="#who-writes-it-and-why-that-matters" aria-hidden="true">#</a></h2>
<p>In a multi-agent system, the log is shared state — so the same discipline that protects every other
shared file applies: <strong>one writer.</strong> The agents don’t append to the log directly. The coordinating
process (the harness’s main process) records each event as it routes messages, spawns agents, and
resolves approvals, and it’s the only thing that writes the file. That keeps the log free of
interleaved, half-written lines, and it pairs with the
<a href="/blog/single-committer-git-pattern/">single-committer git pattern</a>: each batch of coordination is
both appended to the log <em>and</em> committed, so the log’s history and git’s history line up.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/append-only-event-log-agents/note-2.png" alt="Hand-drawn sketch from “An Append-Only Event Log for a Hive of Agents”" loading="lazy" decoding="async" /></figure>
<h2 id="replay-and-debugging" tabindex="-1">Replay and debugging <a class="anchor" href="#replay-and-debugging" aria-hidden="true">#</a></h2>
<p>Here’s where the log earns its keep. Because it’s an ordered, immutable record, you can <strong>replay</strong> the
system’s history:</p>
<ul>
<li><strong>Reconstruct any moment.</strong> Walk the log up to event N and you know exactly what the hive knew at
that point — who existed, what had been said, what was pending.</li>
<li><strong>Find the divergence.</strong> When the team did something wrong, you scan the log for the event where it
went sideways — the misrouted message, the escalation that should have fired and didn’t.</li>
<li><strong>Audit decisions.</strong> Every escalation and every human approval is in the log, so “who approved
deleting that?” has a precise, timestamped answer.</li>
</ul>
<p>This is the foundation of <a href="/blog/debugging-multi-agent-systems/">debugging a multi-agent system</a>: the
event log is the timeline you read first, before you dig into individual agents’ terminals or message
trails. It’s also what lets the office-floor visualization stay honest — the activity stream the UI
shows is the same event stream, not a separate, drift-prone narrative.</p>
<h2 id="practical-notes" tabindex="-1">Practical notes <a class="anchor" href="#practical-notes" aria-hidden="true">#</a></h2>
<p>A few things that keep an event log healthy:</p>
<ul>
<li><strong>Make events idempotent to read.</strong> A consumer that re-reads a line it already processed should do
nothing. Cursors plus immutable lines make this automatic.</li>
<li><strong>Don’t log secrets or huge blobs.</strong> The log is plain text you’ll read often and commit. Reference
big artifacts by id; don’t inline them.</li>
<li><strong>Rotate if it grows unbounded.</strong> For a long-running hive, cap the file (or roll it) so it stays
readable — but never <em>edit</em> old entries; archive them.</li>
<li><strong>Tail the end for “now.”</strong> Reading the last N lines is the cheap way to answer “what’s happening
right now?” without parsing the whole history.</li>
</ul>
<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
<p><strong>Is this event sourcing?</strong> It’s the same family of idea — derive state from an ordered log of events
— applied pragmatically. A full event-sourcing system rebuilds all state from the log; here the log is
primarily for observability and audit, with live state also held in files like the registry. You get
the debuggability benefit without committing to rebuild-everything-from-events.</p>
<p><strong>How is this different from logging to stdout?</strong> Stdout is unstructured and ephemeral. A structured,
append-only JSONL file is queryable, replayable, and durable — you can read it weeks later and
reconstruct exactly what the hive did.</p>
<hr>
<p>Munder Difflin records every coordination step to an append-only event log that drives
<a href="https://munderdiffl.in/#how">the live activity feed</a> and makes a hive replayable — committed
alongside the rest of its state.
<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to watch a hive you can actually audit;
it’s free and open source.</p>
<section class="faq" aria-label="Frequently asked questions">
<h2 id="faq">FAQ</h2>
<div class="qa">
<p class="q">What is an append-only event log in a multi-agent system?</p>
<p class="a">It's a file that only ever grows: every meaningful thing that happens — an agent spawns, a message routes, an item escalates — is recorded as one timestamped line, never edited or deleted. It becomes the system's ground-truth history for debugging and replay.</p>
</div>
<div class="qa">
<p class="q">Why one JSON object per line instead of a database?</p>
<p class="a">Line-delimited JSON (JSONL) is append-cheap, crash-safe, human-readable, and trivially tailable. Appending a line is a single, atomic-enough write; readers parse line by line and track their own position. You get observability with no schema migrations and no server.</p>
</div>
<div class="qa">
<p class="q">What should each event record?</p>
<p class="a">A timestamp plus a small, typed payload: the kind of event and the few fields that matter for it — who spawned, who messaged whom, what was escalated. Keep events small and factual; the value is in the sequence, not in any one fat record.</p>
</div>
</section>
<hr />
<div class="share">
<span class="lbl">Tags</span>
<a class="tag" href="/blog/tags/internals/">Internals</a><a class="tag" href="/blog/tags/observability/">Observability</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/event-log/">Event Log</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="#append-only-in-one-sentence">Append-only, in one sentence</a></li><li class="lvl-2"><a href="#one-json-object-per-line">One JSON object per line</a></li><li class="lvl-2"><a href="#what-to-record-per-event">What to record per event</a></li><li class="lvl-2"><a href="#who-writes-it-and-why-that-matters">Who writes it (and why that matters)</a></li><li class="lvl-2"><a href="#replay-and-debugging">Replay and debugging</a></li><li class="lvl-2"><a href="#practical-notes">Practical notes</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
</ol>
</aside>
</div>
<footer class="post-foot wrap"><div class="prevnext">
<a class="pn prev" href="/blog/how-to-run-multiple-claude-code-agents/"><span class="k">← Older</span><span class="t">How to Run Multiple Claude Code Agents (Without Losing Track)</span></a>
<a class="pn next" href="/blog/why-we-built-munder-difflin/"><span class="k">Newer →</span><span class="t">Why We Built Munder Difflin</span></a>
</div>
<section class="related">
<h2>Related in Internals</h2>
<div class="post-grid">
<article class="card t-internals">
<a class="thumb t-internals" href="/blog/the-spend-counter-that-went-back-to-zero/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/the-spend-counter-that-went-back-to-zero/hero.png" alt="" loading="lazy" decoding="async" /></a>
<div class="body">
<div class="meta">
<time datetime="2026-08-22">Aug 22, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>10 min</span>
</div>
<h3><a href="/blog/the-spend-counter-that-went-back-to-zero/">The Spend Counter That Went Back to Zero</a></h3>
<p class="dek">Our own floor was under reporting what it cost by 59 percent. The counter was cumulative since process start, the app restarts, and the session id stayed the same. Here is how a monotonic invariant let us recover the real number from an append-only log.</p>
<div class="foot">
<span class="tag kind">Internals</span>
<a class="more" href="/blog/the-spend-counter-that-went-back-to-zero/" aria-label="Read: The Spend Counter That Went Back to Zero">Read →</a>
</div>
</div>
</article>
<article class="card t-internals">
<a class="thumb t-internals" href="/blog/the-newline-that-silenced-windows-agents/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/the-newline-that-silenced-windows-agents/hero.png" alt="" loading="lazy" decoding="async" /></a>
<div class="body">
<div class="meta">
<time datetime="2026-08-19">Aug 19, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>4 min</span>
</div>
<h3><a href="/blog/the-newline-that-silenced-windows-agents/">The Newline That Silenced Every Windows Agent</a></h3>
<p class="dek">A cmd.exe parsing rule from the 1980s meant Windows agents received exactly one line of their multi-line startup protocol — and nothing errored. The anatomy of our worst silent failure, and the fix.</p>
<div class="foot">
<span class="tag kind">Internals</span>
<a class="more" href="/blog/the-newline-that-silenced-windows-agents/" aria-label="Read: The Newline That Silenced Every Windows Agent">Read →</a>
</div>
</div>
</article>
<article class="card t-internals">
<a class="thumb t-internals" href="/blog/why-our-auto-update-never-ran/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/why-our-auto-update-never-ran/hero.png" alt="" loading="lazy" decoding="async" /></a>
<div class="body">
<div class="meta">
<time datetime="2026-08-08">Aug 8, 2026</time>
<span class="dot" aria-hidden="true"></span>
<span>5 min</span>
</div>
<h3><a href="/blog/why-our-auto-update-never-ran/">Our Auto-Update Never Ran Once: A CommonJS Export That Vanished Into an ESM Namespace</a></h3>
<p class="dek">Munder Difflin shipped auto-update in v0.3.4 and it silently never worked in a single packaged build. The cause was one destructuring assignment across the CommonJS/ESM boundary — and a catch block that threw the evidence away. Here's how we found it, and what v0.3.7 changes.</p>
<div class="foot">
<span class="tag kind">Internals</span>
<a class="more" href="/blog/why-our-auto-update-never-ran/" aria-label="Read: Our Auto-Update Never Ran Once: A CommonJS Export That Vanished Into an ESM Namespace">Read →</a>
</div>
</div>
</article>
</div>
</section>
</footer>
</article>
</main>
<footer class="site-foot">
<div class="wrap">
<div class="foot-top">
<a class="foot-brand brand" href="https://munderdiffl.in" aria-label="Munder Difflin home">
<img class="brand-logo" src="https://munderdiffl.in/logo.png" width="1318" height="840" alt="Munder Difflin, Inc. — Multi-Agent Harness" />
</a>
<div class="foot-links">
<a href="/blog/">Latest</a>
<a href="/blog/topics/">Topics</a>
<a href="/blog/about/">About</a>
<a href="https://munderdiffl.in/blog/feed.xml">RSS</a>
<a href="https://github.com/chaitanyagiri/munder-difflin">GitHub</a>
<a href="https://munderdiffl.in">munderdiffl.in ↗</a>
</div>
</div>
<div class="foot-meta">
© 2026 Munder Difflin · Local-first · MIT-licensed ·
Built on <a href="https://munderdiffl.in">Electron, React, Pixi.js, xterm.js & node-pty</a>.
Run an office of agents while you sleep.
</div>
</div>
</footer>
<script>
// sticky-nav border on scroll
(function () {
var nav = document.getElementById('nav');
if (!nav) return;
var onScroll = function () { nav.classList.toggle('scrolled', window.scrollY > 8); };
onScroll(); window.addEventListener('scroll', onScroll, { passive: true });
})();
// YouTube click-to-load: thumbnail button → youtube-nocookie iframe
(function () {
document.addEventListener('click', function (e) {
var btn = e.target.closest('.yt-load');
if (!btn) return;
var box = btn.closest('.yt');
var id = box && box.getAttribute('data-yt');
// Only an 11 character YouTube video id may reach the iframe URL.
if (!id || !/^[A-Za-z0-9_-]{11}$/.test(id)) return;
var frame = document.createElement('iframe');
frame.src = 'https://www.youtube-nocookie.com/embed/' + encodeURIComponent(id) + '?autoplay=1';
frame.title = box.getAttribute('data-title') || 'YouTube video';
frame.allow = 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share';
frame.setAttribute('allowfullscreen', '');
box.replaceChildren(frame);
});
})();
</script>
</body>
</html>