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

27.4 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>Why We Built Agent Memory Markdown-First — Munder Difflin Blog</title>
<meta name="description" content="Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully." />
<link rel="canonical" href="https://munderdiffl.in/blog/markdown-first-agent-memory/" />

<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="Why We Built Agent Memory Markdown-First — Munder Difflin Blog" />
<meta property="og:description" content="Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully." />
<meta property="og:url" content="https://munderdiffl.in/blog/markdown-first-agent-memory/" />
<meta property="og:image" content="https://munderdiffl.in/blog/assets/media/markdown-first-agent-memory/hero.png" />
<meta property="og:image:width" content="1600" />
<meta property="og:image:height" content="900" />
<meta property="og:image:alt" content="Illustration: Why We Built Agent Memory Markdown-First" />
<meta property="og:locale" content="en_US" />
<meta property="article:published_time" content="2026-05-27T00:00:00.000Z" />
<meta property="article:author" content="Chaitanya Giri" />
<meta property="article:tag" content="Memory" />
<meta property="article:tag" content="MemPalace" />
<meta property="article:tag" content="Markdown" />
<meta property="article:tag" content="Multi-Agent" />


<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Why We Built Agent Memory Markdown-First — Munder Difflin Blog" />
<meta name="twitter:description" content="Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully." />
<meta name="twitter:image" content="https://munderdiffl.in/blog/assets/media/markdown-first-agent-memory/hero.png" />
<meta name="twitter:image:alt" content="Illustration: Why We Built Agent Memory Markdown-First" />

<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": "Why We Built Agent Memory Markdown-First",
  "description": "Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.",
  "image": ["https://munderdiffl.in/blog/assets/media/markdown-first-agent-memory/hero.png"],
  "datePublished": "2026-05-27T00:00:00.000Z",
  "dateModified": "2026-05-27T00: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/markdown-first-agent-memory/" },
  "keywords": "ai agent long-term memory, markdown memory, agent knowledge base, long-term memory",
  "articleSection": "Memory",
  "inLanguage": "en-US",
  "url": "https://munderdiffl.in/blog/markdown-first-agent-memory/"
}
</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": "Why We Built Agent Memory Markdown-First", "item": "https://munderdiffl.in/blog/markdown-first-agent-memory/" }
  ]
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    { "@type": "Question", "name": "What is markdown-first agent memory?", "acceptedAnswer": { "@type": "Answer", "text": "It's an approach where each agent's durable knowledge lives in plain markdown files it reads on startup and appends to as it learns. A semantic index is built on top of those files for fast recall — but the markdown, not the index, is the source of truth." } },
    { "@type": "Question", "name": "Why not just use a vector database for agent memory?", "acceptedAnswer": { "@type": "Answer", "text": "A vector DB stores opaque embeddings you can't read or diff, and many memory frameworks want to own the agent's runtime. Markdown-first keeps memory human-readable and git-diffable, treats the index as a removable accelerator, and fits agents whose runtime is already Claude Code." } },
    { "@type": "Question", "name": "What happens if the semantic index breaks?", "acceptedAnswer": { "@type": "Answer", "text": "Nothing catastrophic — the agent falls back to reading its markdown directly. Because the files are the source of truth and the index sits on top, a broken or missing index degrades to plain markdown memory instead of losing everything." } }
    
  ]
}
</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-memory">
  <header class="post-head wrap">
    <nav class="crumbs" aria-label="Breadcrumb">
      <a href="/blog/">Blog</a>
      <span>/</span>
      <a href="/blog/topics/memory/">Memory</a>
    </nav>
    <h1>Why We Built Agent Memory Markdown-First</h1>
    <p class="dek">Markdown-first AI agent long-term memory: plain notes a human can read and git can diff, with a semantic index on top that degrades gracefully.</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-05-27">May 27, 2026</time>
      <span class="dot" aria-hidden="true">·</span>
      <span>5 min read</span>
      <span class="tag kind">Memory</span>
    </div>
  </header>

  <div class="hero-wrap wrap"><figure class="fig fig-hero"><img src="/blog/assets/media/markdown-first-agent-memory/hero.png" alt="Illustration: Why We Built Agent Memory Markdown-First" 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>We built
<strong>AI agent long-term memory</strong> markdown-first: each agent writes durable facts to plain
markdown files, and a semantic index sits <em>on top</em> for fast recall. The reason is durability —
markdown is <strong>human-readable</strong>, <strong>git-diffable</strong>, and <strong>degrades
gracefully</strong> (if the index breaks, the files still work). A vector database can't say the same,
and it's the wrong fit when the agent's runtime is already Claude Code.</p></div>
<p>When you add long-term memory to an agent, the tempting first move is to reach for a vector database or
a full memory framework. We went the other way: plain markdown files first, with a semantic index
layered on top. This post is the argument for that ordering — why the <em>source of truth</em> should be
files you can read, and the index should be a removable accelerator.</p>
<h2 id="what-markdown-first-means" tabindex="-1">What “markdown-first” means <a class="anchor" href="#what-markdown-first-means" aria-hidden="true">#</a></h2>
<p>The design is simple. Each agent has a <code>memory.md</code>. The rule it follows:</p>
<ul>
<li><strong>Read it at the start of a task</strong> — recall what you already know before starting.</li>
<li><strong>Append durable facts as you learn them</strong> — a decision, a convention, a gotcha — in small, atomic
entries.</li>
</ul>
<pre class="language-markdown"><code class="language-markdown"><span class="token title important"><span class="token punctuation">##</span> build</span>
<span class="token list punctuation">-</span> The web bundle is built with electron-vite, NOT plain vite. Use <span class="token code-snippet code keyword">`npm run build`</span>.
<span class="token list punctuation">-</span> node-pty needs an electron-rebuild after install (the postinstall handles it).
<span class="token list punctuation">-</span> Never hand-edit docs/index.html during a release — it's the REL fallback source.</code></pre>
<p>A semantic index is built <em>from</em> these files so the agent can recall by meaning instead of re-reading
everything (<a href="/blog/semantic-memory-for-ai-agents/">semantic memory for AI agents</a> covers that layer).
But the markdown is primary. The index is derived, and disposable.</p>
<h2 id="three-reasons-the-ordering-matters" tabindex="-1">Three reasons the ordering matters <a class="anchor" href="#three-reasons-the-ordering-matters" aria-hidden="true">#</a></h2>
<h3 id="1-memory-you-can-read-is-memory-you-can-trust" tabindex="-1">1. Memory you can read is memory you can trust <a class="anchor" href="#1-memory-you-can-read-is-memory-you-can-trust" aria-hidden="true">#</a></h3>
<p>Open an agent’s <code>memory.md</code> and you see exactly what it “knows” — in your language, not as a blob of
floating-point vectors. That’s not a nicety; it’s how you debug an agent that’s acting on a stale or
wrong belief. With markdown, you find the bad note and fix it. With opaque embeddings, you’re guessing
at what the agent remembers and re-indexing to change it. The most important property of a memory
system is that a human can audit it, and plain text wins that outright.</p>
<h3 id="2-memory-that-diffs-is-memory-you-can-review" tabindex="-1">2. Memory that diffs is memory you can review <a class="anchor" href="#2-memory-that-diffs-is-memory-you-can-review" aria-hidden="true">#</a></h3>
<p>Because the notes are files, they live in git. Every change to what an agent knows is a diff you can
read in a commit — memory becomes reviewable like any other artifact. You can watch an agent’s
understanding evolve, catch the moment it learned something wrong, and roll it back. A database of
embeddings has no meaningful diff; “the vectors changed” tells you nothing. Text under version control
turns memory from a black box into a reviewable record, which pairs naturally with the
<a href="/blog/append-only-event-log-agents/">append-only event log</a> for full auditability.</p>
<h3 id="3-memory-that-degrades-gracefully-never-strands-you" tabindex="-1">3. Memory that degrades gracefully never strands you <a class="anchor" href="#3-memory-that-degrades-gracefully-never-strands-you" aria-hidden="true">#</a></h3>
<p>This is the durability clincher. If the semantic index breaks, isn’t installed, or you move to a
machine without it, the markdown files <strong>still work</strong> — the agent reads them directly. The fancy recall
is an upgrade, not a dependency. Contrast a database that won’t open: it takes the memory with it. With
markdown-first, the floor never falls out from under the agent; the worst case is slower recall, not
lost knowledge.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/markdown-first-agent-memory/note-1.png" alt="Hand-drawn sketch from “Why We Built Agent Memory Markdown-First”" loading="lazy" decoding="async" /></figure>
<h2 id="why-not-a-vector-database-or-a-memory-framework" tabindex="-1">Why not a vector database or a memory framework? <a class="anchor" href="#why-not-a-vector-database-or-a-memory-framework" aria-hidden="true">#</a></h2>
<p>Vector DBs and dedicated memory frameworks are real tools with real uses. They’re the wrong default
<em>here</em> for two reasons.</p>
<p><strong>They store what you can’t read.</strong> Their native unit is the embedding — great for similarity search,
useless for human inspection or git review. You end up bolting a “show me the source text” layer back
on, which is just markdown wearing a costume.</p>
<p><strong>They want to own the runtime.</strong> Many agent-memory frameworks assume <em>they</em> are the thing running the
agent loop — they expect to be in charge. But when your agents are real <code>claude</code> sessions, the runtime
is already Claude Code. The memory layer should be a lightweight companion beside it, not a framework
that wants to replace it. Markdown files plus a CLI-driven index fit that shape exactly: the agent
writes notes as a normal part of its work, and a separate process mines those notes into a searchable
store without intruding on the loop.</p>
<p>That mining is the bridge: the index reads each agent’s markdown and makes it recall-able by the whole
team, on a schedule, only re-processing files that changed. You get vector-quality recall <em>and</em>
human-quality source text — because the vectors are derived from the text, not instead of it.</p>
<h2 id="the-single-writer-detail" tabindex="-1">The single-writer detail <a class="anchor" href="#the-single-writer-detail" aria-hidden="true">#</a></h2>
<p>One subtlety that markdown-first gets right almost for free: <strong>one writer per memory file.</strong> Each agent
owns its own <code>memory.md</code> and only it appends there. A shared index aggregates everyone’s notes
read-only, so the whole team can recall across agents without any file being written by two processes.
It’s the same single-writer discipline that keeps
<a href="/blog/single-committer-git-pattern/">multi-agent git safe</a> — applied to memory. Co-edited memory files
would tear; per-agent files plus a read-only shared index don’t.</p>
<figure class="fig fig-inline"><img src="/blog/assets/media/markdown-first-agent-memory/note-2.png" alt="Hand-drawn sketch from “Why We Built Agent Memory Markdown-First”" loading="lazy" decoding="async" /></figure>
<h2 id="when-markdown-first-is-the-right-call" tabindex="-1">When markdown-first is the right call <a class="anchor" href="#when-markdown-first-is-the-right-call" aria-hidden="true">#</a></h2>
<p>This approach shines when:</p>
<ul>
<li>you want to <strong>audit and trust</strong> what your agents remember,</li>
<li>you want memory <strong>under version control</strong> so you can review and revert it,</li>
<li>your agents’ runtime is something you don’t control (a CLI like Claude Code), and</li>
<li>you value <strong>graceful degradation</strong> over maximal indexing sophistication.</li>
</ul>
<p>It’s less compelling if you’re building a system at a scale where you genuinely need a dedicated vector
store’s throughput and you’re willing to give up readability for it. For a hive of a handful to a few
dozen agents, markdown-first is the durable, debuggable default. For the plain-English version of why
agents forget and what shared memory changes, see
<a href="/blog/give-claude-code-long-term-memory/">how to give Claude Code long-term memory</a>.</p>
<h2 id="faq" tabindex="-1">FAQ <a class="anchor" href="#faq" aria-hidden="true">#</a></h2>
<p><strong>Doesn’t markdown get unwieldy at thousands of notes?</strong> The <em>files</em> stay fine; the challenge is recall,
which is exactly what the semantic index on top solves — you recall the few relevant notes by meaning
rather than reading them all. The markdown scales as storage; the index scales as retrieval.</p>
<p><strong>Can I edit an agent’s memory by hand?</strong> Yes — it’s a text file. Fix a wrong note, remove a stale one,
and the next mining pass picks up the change. Try that with a vector store.</p>
<hr>
<p>Munder Difflin gives every agent a plain <code>memory.md</code> plus
<a href="https://munderdiffl.in/#how">a shared semantic palace mined from it</a> — readable, diffable, and
graceful when the index is gone. <a href="https://munderdiffl.in/#install">Download Munder Difflin</a>
to give your agents memory you can actually read; 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 markdown-first agent memory?</p>
          <p class="a">It&#39;s an approach where each agent&#39;s durable knowledge lives in plain markdown files it reads on startup and appends to as it learns. A semantic index is built on top of those files for fast recall — but the markdown, not the index, is the source of truth.</p>
        </div>
        
        <div class="qa">
          <p class="q">Why not just use a vector database for agent memory?</p>
          <p class="a">A vector DB stores opaque embeddings you can&#39;t read or diff, and many memory frameworks want to own the agent&#39;s runtime. Markdown-first keeps memory human-readable and git-diffable, treats the index as a removable accelerator, and fits agents whose runtime is already Claude Code.</p>
        </div>
        
        <div class="qa">
          <p class="q">What happens if the semantic index breaks?</p>
          <p class="a">Nothing catastrophic — the agent falls back to reading its markdown directly. Because the files are the source of truth and the index sits on top, a broken or missing index degrades to plain markdown memory instead of losing everything.</p>
        </div>
        
      </section>
      

      
      <hr />
      <div class="share">
        <span class="lbl">Tags</span>
        <a class="tag" href="/blog/tags/memory/">Memory</a><a class="tag" href="/blog/tags/mempalace/">MemPalace</a><a class="tag" href="/blog/tags/markdown/">Markdown</a><a class="tag" href="/blog/tags/multi-agent/">Multi-Agent</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-markdown-first-means">What “markdown-first” means</a></li><li class="lvl-2"><a href="#three-reasons-the-ordering-matters">Three reasons the ordering matters</a></li><li class="lvl-3"><a href="#1-memory-you-can-read-is-memory-you-can-trust">1. Memory you can read is memory you can trust</a></li><li class="lvl-3"><a href="#2-memory-that-diffs-is-memory-you-can-review">2. Memory that diffs is memory you can review</a></li><li class="lvl-3"><a href="#3-memory-that-degrades-gracefully-never-strands-you">3. Memory that degrades gracefully never strands you</a></li><li class="lvl-2"><a href="#why-not-a-vector-database-or-a-memory-framework">Why not a vector database or a memory framework?</a></li><li class="lvl-2"><a href="#the-single-writer-detail">The single-writer detail</a></li><li class="lvl-2"><a href="#when-markdown-first-is-the-right-call">When markdown-first is the right call</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/semantic-memory-for-ai-agents/"><span class="k">← Older</span><span class="t">Semantic Memory for AI Agents: Recall in Milliseconds</span></a>
      <a class="pn next" href="/blog/give-claude-code-long-term-memory/"><span class="k">Newer →</span><span class="t">How to Give Claude Code Long-Term Memory</span></a>
    </div>
    <section class="related">
      <h2>Related in Memory</h2>
      <div class="post-grid">
        <article class="card t-memory">
  <a class="thumb t-memory" href="/blog/how-agents-remember-semantic-memory/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/how-agents-remember-semantic-memory/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/how-agents-remember-semantic-memory/">How AI Agents Remember: Semantic Memory in a Hive</a></h3>
    <p class="dek">A code-grounded guide to how AI agents remember — the MemPalace mine loop, per-agent wings, and wake-up digest that give a Claude Code hive shared recall.</p>
    <div class="foot">
      <span class="tag kind">Memory</span>
      <a class="more" href="/blog/how-agents-remember-semantic-memory/" aria-label="Read: How AI Agents Remember: Semantic Memory in a Hive">Read →</a>
    </div>
  </div>
</article>
<article class="card t-memory">
  <a class="thumb t-memory" href="/blog/keep-agent-semantic-memory-clean/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/keep-agent-semantic-memory-clean/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>6 min</span>
    </div>
    <h3><a href="/blog/keep-agent-semantic-memory-clean/">Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config</a></h3>
    <p class="dek">A semantic memory layer is only as good as what you feed it — how an agent&#39;s recall got swamped by config and logs, and the .gitignore + prune fix.</p>
    <div class="foot">
      <span class="tag kind">Memory</span>
      <a class="more" href="/blog/keep-agent-semantic-memory-clean/" aria-label="Read: Keep Your Agent&#39;s Semantic Memory Clean: Don&#39;t Index the Config">Read →</a>
    </div>
  </div>
</article>
<article class="card t-memory">
  <a class="thumb t-memory" href="/blog/give-claude-code-long-term-memory/" aria-hidden="true" tabindex="-1"><img src="/blog/assets/media/give-claude-code-long-term-memory/hero.png" alt="" loading="lazy" decoding="async" /></a>
  <div class="body">
    <div class="meta">
      <time datetime="2026-05-27">May 27, 2026</time>
      <span class="dot" aria-hidden="true"></span>
      <span>3 min</span>
    </div>
    <h3><a href="/blog/give-claude-code-long-term-memory/">How to Give Claude Code Long-Term Memory</a></h3>
    <p class="dek">Claude Code forgets between sessions. Here&#39;s how a markdown-first memory layer with semantic recall lets your agents remember across runs.</p>
    <div class="foot">
      <span class="tag kind">Memory</span>
      <a class="more" href="/blog/give-claude-code-long-term-memory/" aria-label="Read: How to Give Claude Code Long-Term Memory">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>