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

28.0 KB
Raw Blame
<!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>Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code — Munder Difflin Blog</title>
<meta name="description" content="Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top." />
<link rel="canonical" href="https://munderdiffl.in/blog/claude-code-git-worktrees-vs-hive/" />

<link rel="icon" type="image/png" href="https://munderdiffl.in/logo.png" />
<link rel="apple-touch-icon" href="https://munderdiffl.in/logo.png" />
<meta name="theme-color" content="#F5F2E8" />

<!-- Open Graph -->
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code — Munder Difflin Blog" />
<meta property="og:description" content="Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top." />
<meta property="og:url" content="https://munderdiffl.in/blog/claude-code-git-worktrees-vs-hive/" />
<meta property="og:image" content="https://munderdiffl.in/blog/assets/media/claude-code-git-worktrees-vs-hive/hero.png" />
<meta property="og:image:width" content="1600" />
<meta property="og:image:height" content="900" />
<meta property="og:image:alt" content="Illustration: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code" />
<meta property="og:locale" content="en_US" />
<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />
<meta property="article:author" content="Chaitanya Giri" />
<meta property="article:tag" content="Orchestration" />
<meta property="article:tag" content="Git" />
<meta property="article:tag" content="Multi-Agent" />
<meta property="article:tag" content="Claude Code" />


<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code — Munder Difflin Blog" />
<meta name="twitter:description" content="Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top." />
<meta name="twitter:image" content="https://munderdiffl.in/blog/assets/media/claude-code-git-worktrees-vs-hive/hero.png" />
<meta name="twitter:image:alt" content="Illustration: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code" />

<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&amp;family=Source+Serif+4:opsz,[email protected],400;8..60,600;8..60,700&amp;family=Space+Grotesk:wght@500;600;700&amp;family=JetBrains+Mono:wght@400;600&amp;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": "Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code",
  "description": "Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.",
  "image": ["https://munderdiffl.in/blog/assets/media/claude-code-git-worktrees-vs-hive/hero.png"],
  "datePublished": "2026-06-04T00:00:00.000Z",
  "dateModified": "2026-06-04T00:00:00.000Z",
  "author": { "@type": "Person", "name": "Chaitanya Giri" },
  "publisher": {
    "@type": "Organization",
    "name": "Munder Difflin",
    "logo": { "@type": "ImageObject", "url": "https://munderdiffl.in/logo.png" }
  },
  "mainEntityOfPage": { "@type": "WebPage", "@id": "https://munderdiffl.in/blog/claude-code-git-worktrees-vs-hive/" },
  "keywords": "claude code git worktrees, git worktrees, claude code parallel, isolated agent workspaces",
  "articleSection": "Orchestration",
  "inLanguage": "en-US",
  "url": "https://munderdiffl.in/blog/claude-code-git-worktrees-vs-hive/"
}
</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": "Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code", "item": "https://munderdiffl.in/blog/claude-code-git-worktrees-vs-hive/" }
  ]
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    { "@type": "Question", "name": "What is a git worktree?", "acceptedAnswer": { "@type": "Answer", "text": "A git worktree is an additional working directory attached to one repository. Each worktree has its own checked-out branch and its own index, but they share the same object store and refs — so you can have several branches checked out at once without cloning the repo multiple times." } },
    { "@type": "Question", "name": "Are git worktrees enough to run parallel Claude Code agents?", "acceptedAnswer": { "@type": "Answer", "text": "For independent tasks on separate branches, often yes — worktrees give each agent its own files so they don't collide. What worktrees don't provide is coordination: shared memory, messaging between agents, or an orchestrator that divides one goal across the team." } },
    { "@type": "Question", "name": "Can I use worktrees and a hive together?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Worktrees solve workspace isolation; a hive solves coordination. You can run a coordinated hive where each agent works in its own worktree, getting both isolation and shared memory plus messaging. In Munder Difflin v0.1.6 this is built-in — the Git isolation toggle in Add Agent handles it automatically." } }
    
  ]
}
</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-orchestration">
  <header class="post-head wrap">
    <nav class="crumbs" aria-label="Breadcrumb">
      <a href="/blog/">Blog</a>
      <span>/</span>
      <a href="/blog/topics/orchestration/">Orchestration</a>
    </nav>
    <h1>Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</h1>
    <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
    <div class="byline">
      <span class="av" aria-hidden="true">CG</span>
      <strong>Chaitanya Giri</strong>
      <span class="dot" aria-hidden="true">·</span>
      <time datetime="2026-06-04">Jun 4, 2026</time>
      <span class="dot" aria-hidden="true">·</span>
      <span>5 min read</span>
      <span class="tag kind">Orchestration</span>
    </div>
  </header>

  <div class="hero-wrap wrap"><figure class="fig fig-hero"><img src="/blog/assets/media/claude-code-git-worktrees-vs-hive/hero.png" alt="Illustration: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code" 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><strong>Git worktrees</strong> give each
Claude Code agent its own working directory and branch, so parallel agents don't collide on files —
perfect for <em>independent</em> tasks. A <strong>hive</strong> adds what worktrees don't: shared
memory, agent-to-agent messaging, and an orchestrator that splits one goal across the team. They solve
different problems — isolation vs. coordination — and compose: run a hive whose agents each live in a
worktree.</p></div>
<p>There are two genuinely good answers to “how do I run Claude Code agents in parallel,” and they’re
often pitched as rivals. They aren’t. Git worktrees and a coordinating hive solve different halves of
the problem, and the right choice — or the right <em>combination</em> — depends on whether your parallel work
is independent or interdependent. Here’s the honest comparison.</p>
<h2 id="what-git-worktrees-give-you" tabindex="-1">What git worktrees give you <a class="anchor" href="#what-git-worktrees-give-you" aria-hidden="true">#</a></h2>
<p>A <strong>worktree</strong> is an extra working directory attached to a single repository. Normally a repo has one
checkout; <code>git worktree add ../feature-x feature-x</code> gives you a <em>second</em> directory with the <code>feature-x</code>
branch checked out, sharing the same underlying repo.</p>
<pre class="language-bash"><code class="language-bash"><span class="token function">git</span> worktree <span class="token function">add</span> <span class="token punctuation">..</span>/agent-a <span class="token parameter variable">-b</span> agent-a
<span class="token function">git</span> worktree <span class="token function">add</span> <span class="token punctuation">..</span>/agent-b <span class="token parameter variable">-b</span> agent-b
<span class="token comment"># now agent A and agent B each have their own directory + branch</span></code></pre>
<p>The key properties:</p>
<ul>
<li><strong>Separate working directories.</strong> Each agent edits files in its own folder. They physically cannot
step on each other’s uncommitted changes.</li>
<li><strong>Separate indexes.</strong> Each worktree has its own staging area, so an agent staging and committing in
one doesn’t fight another’s index. (This sidesteps a lot of the
<a href="/blog/single-committer-git-pattern/"><code>index.lock</code> pain</a> you get when many processes share one
index.)</li>
<li><strong>Shared history.</strong> They share the same object store and refs, so branches and commits are visible
across all of them — no duplicate clones, no re-fetching.</li>
</ul>
<p>For <strong>independent</strong> parallel work, this is often all you need. Three agents, three feature branches,
three worktrees: they run side by side, each on its own task, and you merge the branches when they’re
done. Clean and native.</p>
<h2 id="where-worktrees-stop" tabindex="-1">Where worktrees stop <a class="anchor" href="#where-worktrees-stop" aria-hidden="true">#</a></h2>
<p>Worktrees isolate <em>workspaces</em>. They do nothing about <em>coordination</em>. The moment your parallel agents
aren’t fully independent, the gaps show:</p>
<ul>
<li><strong>No shared memory.</strong> Agent A figures out a quirk in the build; agent B, in a different worktree, has
no idea. Each is its own island. Nothing carries knowledge between them or across sessions.</li>
<li><strong>No messaging.</strong> If agent B needs something from agent A — a decision, an interface, a “don’t touch
this module” — there’s no channel. You become the relay, copy-pasting between directories.</li>
<li><strong>No orchestration.</strong> Worktrees don’t divide a <em>goal</em> into tasks or assign them. You still decide, by
hand, who works on what. There’s no coordinator reading “ship feature X with tests and docs” and
routing the pieces.</li>
<li><strong>No shared plan or visibility.</strong> Three worktrees are three black boxes. There’s no shared board, no
roster, no single place to see what the team is collectively doing.</li>
</ul>
<p>In other words, worktrees make parallel agents <em>safe to run</em>, not <em>able to cooperate</em>. That’s a real
and useful guarantee — it’s just not the same as a team.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/claude-code-git-worktrees-vs-hive/note-1.png" alt="Hand-drawn sketch from “Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code”" loading="lazy" decoding="async" /></figure>
<h2 id="what-a-hive-gives-you" tabindex="-1">What a hive gives you <a class="anchor" href="#what-a-hive-gives-you" aria-hidden="true">#</a></h2>
<p>A <strong>hive</strong> is the coordination layer worktrees lack. It wraps several long-lived agents and adds:</p>
<ul>
<li><strong>Shared, durable memory.</strong> Each agent’s notes persist and become recall-able by the whole team, so
knowledge flows between agents and across sessions — <a href="/blog/semantic-memory-for-ai-agents/">semantic memory for agents</a>,
not isolated context.</li>
<li><strong>Direct messaging.</strong> Agents send messages to each other through a router; no human relay. (“I own
the auth module” actually reaches everyone.)</li>
<li><strong>An orchestrator.</strong> A coordinator decomposes your goal, routes work to the right agent, adjudicates
the routine back-and-forth, and escalates only the critical calls — see
<a href="/blog/claude-code-orchestration-guide/">orchestrating Claude Code agents</a>.</li>
<li><strong>A shared plan and a live view.</strong> One board, one roster, one office floor you can watch.</li>
</ul>
<p>What a hive does <em>not</em> inherently solve is file isolation — if its agents share a single working
directory, you need a discipline (single-writer files, single-committer git) to keep them from
colliding. Which is exactly where worktrees come back in.</p>
<h2 id="they-compose" tabindex="-1">They compose <a class="anchor" href="#they-compose" aria-hidden="true">#</a></h2>
<p>Here’s the punchline the “vs.” framing hides: <strong>use both.</strong> Worktrees handle isolation; the hive
handles coordination. Munder Difflin now ships this combination built-in: the <strong>Git isolation</strong> toggle
in Add Agent provisions a dedicated worktree for each agent on spawn and tears it down on kill — so
every agent in a shared repo works on its own branch by default, with no manual <code>git worktree add</code>
needed.</p>
<pre class="language-text"><code class="language-text">            ┌─ worktree: agent-a (branch agent-a) ─┐
hive ───────┼─ worktree: agent-b (branch agent-b) ─┼── shared memory + messaging
(coordination) └─ worktree: agent-c (branch agent-c) ┘   + orchestrator + board</code></pre>
<p>The layers don’t conflict; they stack. Worktrees are a git feature for workspace isolation. A hive is a
coordination feature for teamwork. Asking which to use is like asking whether to use seatbelts or a
steering wheel.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/claude-code-git-worktrees-vs-hive/note-2.png" alt="Hand-drawn sketch from “Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code”" loading="lazy" decoding="async" /></figure>
<h2 id="a-decision-guide" tabindex="-1">A decision guide <a class="anchor" href="#a-decision-guide" aria-hidden="true">#</a></h2>
<p>Pick based on how <em>interdependent</em> your parallel work is:</p>
<p><strong>Just worktrees</strong> are enough when:</p>
<ul>
<li>the tasks are <strong>independent</strong> (separate features, separate branches),</li>
<li>agents don’t need to know what the others learned, and</li>
<li>you’re happy to assign work and merge results by hand.</li>
</ul>
<p><strong>A hive</strong> (optionally over worktrees) is worth it when:</p>
<ul>
<li>the work is <strong>one goal</strong> that needs dividing and recombining,</li>
<li>agents must <strong>share knowledge</strong> or <strong>message</strong> each other, or</li>
<li>you want to state intent once and have a <strong>coordinated team</strong> execute — the leap described in
<a href="/blog/how-to-run-multiple-claude-code-agents/">how to run multiple Claude Code agents</a>.</li>
</ul>
<p>If you’ve ever wondered whether built-in mechanisms are enough versus an external coordination layer,
the same question shows up for <a href="/blog/claude-code-subagents-vs-multi-agent-harness/">subagents vs a harness</a> —
and the answer rhymes: native primitives handle the small scale; a coordination layer handles the team
scale. For a concrete tool-vs-tool take on that coordination layer, see
<a href="/blog/claude-squad-vs-munder-difflin/">Claude Squad vs Munder Difflin</a>.</p>
<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
<p><strong>Do worktrees prevent all git conflicts?</strong> They prevent index and working-directory collisions, which
are the common ones. Shared refs and the object store are still common, so concurrent operations that
touch refs still want care — which is one reason a hive uses a single committer for its <em>coordination</em>
repo even when agents work in separate worktrees.</p>
<p><strong>Is a hive heavier than worktrees?</strong> It’s more capable, so it’s more machinery. If your tasks are
truly independent, worktrees alone are the lighter, correct choice. Add the hive when coordination —
not just isolation — is the thing you’re missing.</p>
<hr>
<p>Munder Difflin is <a href="https://munderdiffl.in/#how">the coordination layer</a>: shared memory, messaging, and a GOD orchestrator for a hive
of Claude Code agents — and it plays nicely with the git workflow you already use.
<a href="https://munderdiffl.in/#install">Download Munder Difflin</a> when isolation isn’t enough and you need a
team; it’s free and open source.</p>


      
      <section class="faq" aria-label="Frequently asked questions">
        <h2 id="faq">FAQ</h2>
        
        <div class="qa">
          <p class="q">What is a git worktree?</p>
          <p class="a">A git worktree is an additional working directory attached to one repository. Each worktree has its own checked-out branch and its own index, but they share the same object store and refs — so you can have several branches checked out at once without cloning the repo multiple times.</p>
        </div>
        
        <div class="qa">
          <p class="q">Are git worktrees enough to run parallel Claude Code agents?</p>
          <p class="a">For independent tasks on separate branches, often yes — worktrees give each agent its own files so they don&#39;t collide. What worktrees don&#39;t provide is coordination: shared memory, messaging between agents, or an orchestrator that divides one goal across the team.</p>
        </div>
        
        <div class="qa">
          <p class="q">Can I use worktrees and a hive together?</p>
          <p class="a">Yes. Worktrees solve workspace isolation; a hive solves coordination. You can run a coordinated hive where each agent works in its own worktree, getting both isolation and shared memory plus messaging. In Munder Difflin v0.1.6 this is built-in — the Git isolation toggle in Add Agent handles it automatically.</p>
        </div>
        
      </section>
      

      
      <hr />
      <div class="share">
        <span class="lbl">Tags</span>
        <a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/git/">Git</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</a><a class="tag" href="/blog/tags/claude-code/">Claude Code</a>
      </div>
      
    </div>

    
    <aside class="toc-rail" aria-label="Table of contents">
      <div class="tt">On this page</div>
      <ol>
        <li class="lvl-2"><a href="#what-git-worktrees-give-you">What git worktrees give you</a></li><li class="lvl-2"><a href="#where-worktrees-stop">Where worktrees stop</a></li><li class="lvl-2"><a href="#what-a-hive-gives-you">What a hive gives you</a></li><li class="lvl-2"><a href="#they-compose">They compose</a></li><li class="lvl-2"><a href="#a-decision-guide">A decision guide</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
      </ol>
    </aside>
    
  </div>

  <footer class="post-foot wrap"><div class="prevnext">
      <a class="pn prev" href="/blog/claude-code-orchestration-tools-compared/"><span class="k">← Older</span><span class="t">Claude Code Orchestration Tools, Compared</span></a>
      <a class="pn next" href="/blog/claude-code-automation-while-you-sleep/"><span class="k">Newer →</span><span class="t">Claude Code Automation: Let Agents Build While You Sleep</span></a>
    </div>
    <section class="related">
      <h2>Related in Orchestration</h2>
      <div class="post-grid">
        <article class="card t-orchestration">
  <a class="thumb t-orchestration" href="/blog/deploy-automated-pr-reviewer-agent/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/deploy-automated-pr-reviewer-agent/hero.png" alt="" loading="lazy" decoding="async" /></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/deploy-automated-pr-reviewer-agent/">Deploy a PR Reviewer That Never Sleeps — In About One Prompt</a></h3>
    <p class="dek">A how-to for standing up a fully automated PR-reviewing agent in Munder Difflin — one that reads your real source (not just the PR description), de-dupes noise, and only escalates what matters. With a real triage run that turned 22 duplicate firings into a clean v0.2.5 patch queue.</p>
    <div class="foot">
      <span class="tag kind">Orchestration</span>
      <a class="more" href="/blog/deploy-automated-pr-reviewer-agent/" aria-label="Read: Deploy a PR Reviewer That Never Sleeps — In About One Prompt">Read →</a>
    </div>
  </div>
</article>
<article class="card t-orchestration">
  <a class="thumb t-orchestration" href="/blog/multi-agent-orchestration-patterns/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/multi-agent-orchestration-patterns/hero.png" alt="" loading="lazy" decoding="async" /></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/multi-agent-orchestration-patterns/">Multi-Agent Orchestration Patterns: Which Topology, and When</a></h3>
    <p class="dek">The multi-agent orchestration patterns — orchestrator-worker, pipeline, fan-out, debate, swarm, blackboard — when to use each, and when one agent wins.</p>
    <div class="foot">
      <span class="tag kind">Orchestration</span>
      <a class="more" href="/blog/multi-agent-orchestration-patterns/" aria-label="Read: Multi-Agent Orchestration Patterns: Which Topology, and When">Read →</a>
    </div>
  </div>
</article>
<article class="card t-orchestration">
  <a class="thumb t-orchestration" href="/blog/local-first-ai-agent-orchestration/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/local-first-ai-agent-orchestration/hero.png" alt="" loading="lazy" decoding="async" /></a>
  <div class="body">
    <div class="meta">
      <time datetime="2026-06-04">Jun 4, 2026</time>
      <span class="dot" aria-hidden="true"></span>
      <span>5 min</span>
    </div>
    <h3><a href="/blog/local-first-ai-agent-orchestration/">Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud</a></h3>
    <p class="dek">How local-first AI agent orchestration works under the hood — the loop, mailboxes, scheduler, and audit log that coordinate a hive on one machine.</p>
    <div class="foot">
      <span class="tag kind">Orchestration</span>
      <a class="more" href="/blog/local-first-ai-agent-orchestration/" aria-label="Read: Local-First AI Agent Orchestration: How a Hive Runs Without a Cloud">Read →</a>
    </div>
  </div>
</article>

      </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 &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 });
  })();
  // 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>