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

33.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>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions — Munder Difflin Blog</title>
<meta name="description" content="How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free." />
<link rel="canonical" href="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />

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

<!-- Open Graph -->
<meta property="og:site_name" content="Munder Difflin Blog" />
<meta property="og:type" content="article" />
<meta property="og:title" content="Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions — Munder Difflin Blog" />
<meta property="og:description" content="How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free." />
<meta property="og:url" content="https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" />
<meta property="og:image" content="https://munderdiffl.in/blog/assets/media/scheduling-autonomous-agent-missions/hero.png" />
<meta property="og:image:width" content="1600" />
<meta property="og:image:height" content="900" />
<meta property="og:image:alt" content="Illustration: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions" />
<meta property="og:locale" content="en_US" />
<meta property="article:published_time" content="2026-06-04T00:00:00.000Z" />
<meta property="article:author" content="Chaitanya Giri" />
<meta property="article:tag" content="Orchestration" />
<meta property="article:tag" content="Automation" />
<meta property="article:tag" content="Autonomous" />
<meta property="article:tag" content="Hive" />


<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions — Munder Difflin Blog" />
<meta name="twitter:description" content="How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free." />
<meta name="twitter:image" content="https://munderdiffl.in/blog/assets/media/scheduling-autonomous-agent-missions/hero.png" />
<meta name="twitter:image:alt" content="Illustration: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions" />

<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": "Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions",
  "description": "How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent's queue, hands-free.",
  "image": ["https://munderdiffl.in/blog/assets/media/scheduling-autonomous-agent-missions/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/scheduling-autonomous-agent-missions/" },
  "keywords": "scheduled agent missions, recurring autonomous tasks, schedule ai agents, cron for ai agents",
  "articleSection": "Orchestration",
  "inLanguage": "en-US",
  "url": "https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/"
}
</script>
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://munderdiffl.in/" },
    { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://munderdiffl.in/blog/" },
    { "@type": "ListItem", "position": 3, "name": "Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions", "item": "https://munderdiffl.in/blog/scheduling-autonomous-agent-missions/" }
  ]
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    { "@type": "Question", "name": "What is a scheduled mission in a multi-agent harness?", "acceptedAnswer": { "@type": "Answer", "text": "A scheduled mission is a recurring instruction the harness fires on a fixed interval. Each tick it sends a request message to a target agent — a specific one or the whole hive — so work happens on a cadence without anyone typing a prompt. Think cron, but the job is an agent task." } },
    { "@type": "Question", "name": "How is a scheduled mission different from an autonomous loop?", "acceptedAnswer": { "@type": "Answer", "text": "An autonomous loop keeps one agent going until its queue is empty. A scheduled mission refills that queue on a timer. The loop is the engine; the schedule is the alarm clock. Together they let a hive pick up fresh, recurring work on its own and then run each piece to completion." } },
    { "@type": "Question", "name": "Do scheduled missions run when the app is closed?", "acceptedAnswer": { "@type": "Answer", "text": "No. The timers live in the desktop app's process, so missions only fire while it's open — this is local-first, not a cloud cron. But each mission remembers when it last fired, so on the next launch an overdue mission fires right away and the cadence resumes instead of resetting." } }
    
  ]
}
</script>


<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>Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions</h1>
    <p class="dek">How scheduled missions make a Claude Code hive work on a cadence — recurring requests that fire on an interval and land in an agent&#39;s queue, hands-free.</p>
    <div class="byline">
      <span class="av" aria-hidden="true">CG</span>
      <strong>Chaitanya Giri</strong>
      <span class="dot" aria-hidden="true">·</span>
      <time datetime="2026-06-04">Jun 4, 2026</time>
      <span class="dot" aria-hidden="true">·</span>
      <span>6 min read</span>
      <span class="tag kind">Orchestration</span>
    </div>
  </header>

  <div class="hero-wrap wrap"><figure class="fig fig-hero"><img src="/blog/assets/media/scheduling-autonomous-agent-missions/hero.png" alt="Illustration: Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions" 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>A <strong>scheduled mission</strong> is a
recurring instruction the harness fires on an interval: each tick it drops a <code>request</code> into
a target agent's queue, so a hive does standups, audits, or nightly reports <strong>without you typing
a prompt</strong>. It pairs with the <a href="/blog/claude-code-automation-while-you-sleep/">autonomous
loop</a> — the loop keeps an agent working until its queue is empty, the schedule refills the queue on
a cadence. Missions remember when they last fired, so restarts resume the rhythm instead of resetting
it.</p></div>
<p>There’s a difference between an agent that works <em>when you ask</em> and a hive that works <em>on a schedule</em>.
The first still needs you at the keyboard. The second wakes itself up — runs a standup every hour,
audits the build every night, summarizes new issues every morning — and only pulls you in when
something actually needs a human. Munder Difflin ships this as <strong>scheduled missions</strong>, and this guide
walks through how they work, grounded in the real code, plus the patterns that keep them useful instead
of noisy.</p>
<h2 id="what-a-mission-actually-is" tabindex="-1">What a mission actually is <a class="anchor" href="#what-a-mission-actually-is" aria-hidden="true">#</a></h2>
<p>A mission is a small, persisted record. In <code>src/main/config.ts</code> it’s a <code>ScheduledMission</code>:</p>
<pre class="language-ts"><code class="language-ts"><span class="token keyword">interface</span> <span class="token class-name">ScheduledMission</span> <span class="token punctuation">{</span>
  id<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span>
  label<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span>       <span class="token comment">// shows up as the message subject</span>
  intervalMs<span class="token operator">:</span> <span class="token builtin">number</span><span class="token punctuation">;</span>  <span class="token comment">// the cadence</span>
  to<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span>          <span class="token comment">// target: an agent id, or 'broadcast'</span>
  body<span class="token operator">:</span> <span class="token builtin">string</span><span class="token punctuation">;</span>        <span class="token comment">// the instruction the agent receives</span>
  enabled<span class="token operator">:</span> <span class="token builtin">boolean</span><span class="token punctuation">;</span>
  lastFiredAt<span class="token operator">?</span><span class="token operator">:</span> <span class="token builtin">number</span><span class="token punctuation">;</span> <span class="token comment">// scheduler-owned; when it last ran</span>
<span class="token punctuation">}</span></code></pre>
<p>Missions live in the harness config under a <code>missions[]</code> array, so they survive restarts. That’s the
whole data model — no DAG, no external job store. A mission is “send <em>this</em> instruction to <em>this</em>
target, every <em>this often</em>.”</p>
<h2 id="how-the-scheduler-fires" tabindex="-1">How the scheduler fires <a class="anchor" href="#how-the-scheduler-fires" aria-hidden="true">#</a></h2>
<p>The engine is <code>syncMissions()</code> in <code>src/main/index.ts</code>. It runs on boot (right after the message router
starts) and again after any change to your missions. Each run it does two things: clear every existing
timer, then arm a fresh timer for each enabled mission. Clearing first is what makes editing one
mission safe — nothing gets double-armed.</p>
<p>When a mission’s timer fires, the <code>fire()</code> callback does exactly two things:</p>
<pre class="language-ts"><code class="language-ts"><span class="token keyword">if</span> <span class="token punctuation">(</span>hive<span class="token punctuation">.</span><span class="token function">enabled</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  hive<span class="token punctuation">.</span><span class="token function">send</span><span class="token punctuation">(</span><span class="token punctuation">{</span> to<span class="token operator">:</span> m<span class="token punctuation">.</span>to<span class="token punctuation">,</span> act<span class="token operator">:</span> <span class="token string">'request'</span><span class="token punctuation">,</span> subject<span class="token operator">:</span> m<span class="token punctuation">.</span>label<span class="token punctuation">,</span> body<span class="token operator">:</span> m<span class="token punctuation">.</span>body <span class="token punctuation">}</span><span class="token punctuation">,</span> <span class="token string">'scheduler'</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">// then stamp lastFiredAt = Date.now() back into config</span></code></pre>
<p>That’s the heart of it. A mission tick is just a <code>request</code> message, sent <strong>from <code>scheduler</code></strong>, that
lands in the target agent’s inbox like any other message. The agent reads it at the start of its next
turn and acts. There’s nothing special about a scheduled task once it’s in the queue — which is exactly
why it composes so cleanly with the rest of the hive.</p>
<p>This very post is proof. It exists because an <strong>“Hourly Standup” mission</strong> fired: a request, from
<code>scheduler</code>, broadcast to every agent, asking each to report status and pick up work. No one typed that
prompt this hour. The schedule did.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/scheduling-autonomous-agent-missions/note-1.png" alt="Hand-drawn sketch from “Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions”" loading="lazy" decoding="async" /></figure>
<h2 id="why-lastfiredat-matters" tabindex="-1">Why <code>lastFiredAt</code> matters <a class="anchor" href="#why-lastfiredat-matters" aria-hidden="true">#</a></h2>
<p>The one piece of cleverness worth understanding is <code>lastFiredAt</code>. A naive scheduler would restart every
interval from zero whenever the app reboots or you edit an unrelated mission — so an hourly job could
drift, double-fire, or never fire if you kept tweaking things. Instead, the harness computes how much
time is actually left:</p>
<pre class="language-ts"><code class="language-ts"><span class="token keyword">const</span> remaining <span class="token operator">=</span> Math<span class="token punctuation">.</span><span class="token function">max</span><span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">,</span> m<span class="token punctuation">.</span>intervalMs <span class="token operator">-</span> <span class="token punctuation">(</span>Date<span class="token punctuation">.</span><span class="token function">now</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">-</span> <span class="token punctuation">(</span>m<span class="token punctuation">.</span>lastFiredAt <span class="token operator">??</span> <span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token function">setTimeout</span><span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">=></span> <span class="token punctuation">{</span> <span class="token function">fire</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token function">setInterval</span><span class="token punctuation">(</span>fire<span class="token punctuation">,</span> m<span class="token punctuation">.</span>intervalMs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span><span class="token punctuation">,</span> remaining<span class="token punctuation">)</span><span class="token punctuation">;</span></code></pre>
<p>It waits only the time <em>remaining</em> until the next due fire, then settles into a steady interval. If a
mission is overdue (you closed the app over lunch), <code>remaining</code> is <code>0</code> and it fires right away on the
next launch. The cadence resumes; it doesn’t reset. And because the renderer can never overwrite the
scheduler’s <code>lastFiredAt</code> — <code>missions:save</code> merges by id and keeps the newer value — editing a
mission’s text in the UI won’t accidentally rewind its clock.</p>
<p>On shutdown, <code>clearMissionTimers()</code> tears down every pending <code>setTimeout</code> and <code>setInterval</code>, so a tick
can never fire into half-torn-down services during quit. The result is a scheduler that’s boring in the
best way: it survives restarts, edits, and quits without surprising you.</p>
<h2 id="good-patterns" tabindex="-1">Good patterns <a class="anchor" href="#good-patterns" aria-hidden="true">#</a></h2>
<p>A scheduler that fires the same instruction forever rewards a particular style of mission.</p>
<ul>
<li><strong>Write idempotent bodies.</strong> Because a mission runs again and again, its instruction should be safe to
repeat. “Post a standup,” “audit the latest build,” “summarize new issues since the last run” are
great. “Create the project” is not — it’d duplicate every tick. Phrase the body as a recurring verb,
not a one-time setup.</li>
<li><strong>Match cadence to how fast reality changes.</strong> <code>intervalMs</code> is your rhythm. An hourly standup, a
nightly report, a weekly retro — pick the interval from the underlying state, not from a vague sense
that “more often is better.”</li>
<li><strong>Target a coordinator for fan-out work.</strong> Sending a “gather status and assign tasks” mission to
<a href="https://munderdiffl.in/#how">the orchestrator</a> lets one coordinator decide and delegate, instead of
blasting an identical instruction at every agent. The orchestrator is built for exactly this routing.</li>
<li><strong>Pause with <code>enabled</code>, don’t delete.</strong> Flip <code>enabled: false</code> to stop a mission while keeping its
history and <code>lastFiredAt</code>. You can switch it back on later and the cadence picks up cleanly.</li>
</ul>
<figure class="fig fig-inline"><img src="/blog/assets/media/scheduling-autonomous-agent-missions/note-2.png" alt="Hand-drawn sketch from “Make a Hive Work While You Sleep: Scheduling Autonomous Agent Missions”" loading="lazy" decoding="async" /></figure>
<h2 id="pitfalls-to-avoid" tabindex="-1">Pitfalls to avoid <a class="anchor" href="#pitfalls-to-avoid" aria-hidden="true">#</a></h2>
<ul>
<li><strong>Flooding the hive.</strong> The scheduler will fire as often as you tell it to — restraint is on you. A
one-minute mission to <code>broadcast</code> will bury every agent’s inbox and burn tokens fast. If agents can’t
finish before the next tick, the interval is too short.</li>
<li><strong>Non-idempotent instructions.</strong> A body that assumes it’s running for the first time will create
duplicates on every fire. Always read a mission body as “what should happen <em>each time</em>.”</li>
<li><strong>Expecting an interrupt.</strong> A mission is a queued <code>request</code>, not a signal that stops what an agent is
doing. If the target is mid-task, the mission waits its turn — usually fine, but know it isn’t
instant.</li>
<li><strong>Forgetting it’s local-first.</strong> Timers live in the app’s process, so missions only fire while the
desktop app is open. That’s a deliberate trade for a tool you run on your own machine — and
<code>lastFiredAt</code> softens it by firing overdue missions on the next launch. If you need firing while the
laptop is shut, that’s a cloud cron’s job, not this one.</li>
</ul>
<h2 id="where-it-fits" tabindex="-1">Where it fits <a class="anchor" href="#where-it-fits" aria-hidden="true">#</a></h2>
<p>Scheduled missions are the alarm clock; the <a href="/blog/claude-code-automation-while-you-sleep/">autonomous
loop</a> is the engine that keeps an agent running until
its queue is empty; the <a href="/blog/coordinating-ai-coding-agents/">message router</a> is the nervous system
that delivers each tick. Put them together and a hive becomes genuinely self-driving on the recurring
work: it wakes up on schedule, routes the task through <a href="/blog/how-the-god-orchestrator-works/">the orchestrator</a>,
runs it to completion, and escalates to you only when a decision is genuinely yours to make.</p>
<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
<p><strong>What is a scheduled mission?</strong> A recurring instruction the harness fires on a fixed interval. Each
tick it sends a <code>request</code> message to a target agent (or the whole hive via <code>broadcast</code>), so work
happens on a cadence with no prompt from you.</p>
<p><strong>How is it different from an autonomous loop?</strong> The loop keeps a single agent working until its queue
is empty; the schedule refills that queue on a timer. The loop is the engine, the mission is the alarm
clock — they’re complementary, not competing.</p>
<p><strong>Do missions fire when the app is closed?</strong> No — the timers run inside the desktop app’s process, so
it’s local-first, not a cloud cron. But each mission records <code>lastFiredAt</code>, so an overdue mission fires
immediately on the next launch and the cadence resumes instead of resetting.</p>
<p><strong>How do I stop a mission without losing it?</strong> Set <code>enabled: false</code>. It stays in your config with its
history intact, and you can re-enable it later without rewinding the clock.</p>
<hr>
<p>Munder Difflin runs exactly this: a local hive of Claude Code agents that picks up recurring work on a
schedule, routes it through <a href="https://munderdiffl.in/#how">a GOD orchestrator</a>, and pings you only for
the calls that matter. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a> to set your first
mission and watch the floor wake itself up; it’s free and open source.</p>


      
      <section class="faq" aria-label="Frequently asked questions">
        <h2 id="faq">FAQ</h2>
        
        <div class="qa">
          <p class="q">What is a scheduled mission in a multi-agent harness?</p>
          <p class="a">A scheduled mission is a recurring instruction the harness fires on a fixed interval. Each tick it sends a request message to a target agent — a specific one or the whole hive — so work happens on a cadence without anyone typing a prompt. Think cron, but the job is an agent task.</p>
        </div>
        
        <div class="qa">
          <p class="q">How is a scheduled mission different from an autonomous loop?</p>
          <p class="a">An autonomous loop keeps one agent going until its queue is empty. A scheduled mission refills that queue on a timer. The loop is the engine; the schedule is the alarm clock. Together they let a hive pick up fresh, recurring work on its own and then run each piece to completion.</p>
        </div>
        
        <div class="qa">
          <p class="q">Do scheduled missions run when the app is closed?</p>
          <p class="a">No. The timers live in the desktop app&#39;s process, so missions only fire while it&#39;s open — this is local-first, not a cloud cron. But each mission remembers when it last fired, so on the next launch an overdue mission fires right away and the cadence resumes instead of resetting.</p>
        </div>
        
      </section>
      

      
      <hr />
      <div class="share">
        <span class="lbl">Tags</span>
        <a class="tag" href="/blog/tags/orchestration/">Orchestration</a><a class="tag" href="/blog/tags/automation/">Automation</a><a class="tag" href="/blog/tags/autonomous/">Autonomous</a><a class="tag" href="/blog/tags/hive/">Hive</a>
      </div>
      
    </div>

    
    <aside class="toc-rail" aria-label="Table of contents">
      <div class="tt">On this page</div>
      <ol>
        <li class="lvl-2"><a href="#what-a-mission-actually-is">What a mission actually is</a></li><li class="lvl-2"><a href="#how-the-scheduler-fires">How the scheduler fires</a></li><li class="lvl-2"><a href="#why-lastfiredat-matters">Why lastFiredAt matters</a></li><li class="lvl-2"><a href="#good-patterns">Good patterns</a></li><li class="lvl-2"><a href="#pitfalls-to-avoid">Pitfalls to avoid</a></li><li class="lvl-2"><a href="#where-it-fits">Where it fits</a></li><li class="lvl-2"><a href="#faq">FAQ</a></li>
      </ol>
    </aside>
    
  </div>

  <footer class="post-foot wrap"><div class="prevnext">
      <a class="pn prev" href="/blog/security-for-ai-coding-agents/"><span class="k">← Older</span><span class="t">Security for AI Coding Agents: A Practical Guide</span></a>
      <a class="pn next" href="/blog/recovering-from-agent-failures/"><span class="k">Newer →</span><span class="t">Recovering From Agent Failures: Resilience Patterns for a Hive</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/claude-code-git-worktrees-vs-hive/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/claude-code-git-worktrees-vs-hive/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/claude-code-git-worktrees-vs-hive/">Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code</a></h3>
    <p class="dek">Claude Code git worktrees vs a hive: when isolated worktrees suffice for parallel agents, and when you need memory, messaging, and an orchestrator on top.</p>
    <div class="foot">
      <span class="tag kind">Orchestration</span>
      <a class="more" href="/blog/claude-code-git-worktrees-vs-hive/" aria-label="Read: Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code">Read →</a>
    </div>
  </div>
</article>

      </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>