<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Leonid Bakaleynik</title>
    <description>The latest articles on DEV Community by Leonid Bakaleynik (@leonidb).</description>
    <link>https://dev.to/leonidb</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4249291%2F58a67436-54b1-4b34-819c-ce1acdd23731.jpg</url>
      <title>DEV Community: Leonid Bakaleynik</title>
      <link>https://dev.to/leonidb</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/leonidb"/>
    <language>en</language>
    <item>
      <title>Building shared memory for a team of agents</title>
      <dc:creator>Leonid Bakaleynik</dc:creator>
      <pubDate>Tue, 17 Nov 2026 14:58:39 +0000</pubDate>
      <link>https://dev.to/leonidb/building-shared-memory-for-a-team-of-agents-3km6</link>
      <guid>https://dev.to/leonidb/building-shared-memory-for-a-team-of-agents-3km6</guid>
      <description>&lt;p&gt;Have you ever felt like you need to reintroduce a fresh Claude Code to the same details about your project? Copy a context summary from one session into another? Wished you could just tell Claude Code to dispatch a separate task to another session, and have that session immediately pick up both the task context and a collective memory of all previous sessions in that project?&lt;/p&gt;

&lt;p&gt;I have, and this was my motivation behind building &lt;a href="https://github.com/leonidb/jean" rel="noopener noreferrer"&gt;Jean&lt;/a&gt;, an unopinionated framework for managing a group of agents that work in coordination on tasks and accumulate collective knowledge of the project, the way you like to work, and how to function as a team of agents, refining it as they go.&lt;/p&gt;

&lt;p&gt;This post focuses on my experience and lessons I’ve learned from building Jean’s shared memory. I’ve been running 6 projects over about 6 months on this infra, from a personal assistant to work projects, and it’s interesting to see how a general infra for shared memory gets a personality and evolves in real life in different projects.&lt;/p&gt;

&lt;h2&gt;
  
  
  How I built it
&lt;/h2&gt;

&lt;p&gt;A shared memory for several sessions was on my mind at the very beginning, when I first set out to build Jean.&lt;/p&gt;

&lt;p&gt;I wanted a project-level memory that is both shared between all the agents that work on a project, so I don’t need to retell the same thing to a new agent, and focused on the project, not general to everything I do in Claude Code.&lt;/p&gt;

&lt;p&gt;My initial inspiration came from Andrej Karpathy’s &lt;a href="https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f" rel="noopener noreferrer"&gt;idea of a fully LLM-managed wiki&lt;/a&gt;, which got quite popular. At the time quite a few people noted that self-organized Markdown really does work and maybe that’s all you need. I took that idea but adapted it in a more structural, frameworky way, because the original was about managing documents.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0h1qx1eu0987v2lcgxq1.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0h1qx1eu0987v2lcgxq1.png" alt="Agents memorize and their task threads go into the event log; the nightly librarian (draft, review, commit) turns new events into the wiki; one-stop search reads the wiki pages and what is not consolidated yet, and agents read from it; the sensei runs a weekly staleness sweep into the event log." width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Jean is built on an event log: what agents memorize and their task threads are appended to it and never edited. No agent edits the wiki directly: it changes only through the log. Once a day a headless agent, the librarian, consolidates the new events into a Markdown wiki. One search covers the wiki and what isn’t consolidated yet. Once a week the sensei, the orchestrating agent, sweeps the wiki for stale facts and sends corrections back through the log.&lt;/p&gt;

&lt;h3&gt;
  
  
  Memorizing
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F30ims8h4e5gmv55lhvk2.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F30ims8h4e5gmv55lhvk2.png" alt="Memorizing, in the loop: agents write to the event log." width="799" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Memories come into Jean from two sources: tasks and explicit &lt;code&gt;memorize&lt;/code&gt; calls. Work is dispatched to worker agents in a structured way, through tasks, and every task is basically a thread with progress and findings. That makes tasks a natural and easy source to distill general knowledge from: the librarian reads every finished task’s thread and keeps what’s durable, so a finding reaches the wiki even when no agent memorized it explicitly.&lt;/p&gt;

&lt;p&gt;Memorizing is a different animal, because it depends on the agent deciding to do it. That turned out not to be straightforward. At first &lt;code&gt;memorize&lt;/code&gt; was just an endpoint on the infra, and a skill told agents to call it. Skills are often not loaded, and an endpoint described in Markdown is easy to miss, so I made it a dedicated &lt;code&gt;memorize&lt;/code&gt; method on the MCP server. A tool shows up in the agent’s tool list in every session, and its schema is the instruction.&lt;/p&gt;

&lt;p&gt;Even then agents fell back to Claude Code’s own memory. Its instructions are in the system prompt of every session, and when there are a lot of instructions in the context, sometimes the instruction that wins is not yours. What fixed it almost completely was a blunt rule in the skill: “in a Jean project you never write to Claude Code’s memory”.&lt;/p&gt;

&lt;h3&gt;
  
  
  Consolidation
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdj3x5slx5kdytn9oqjf6.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdj3x5slx5kdytn9oqjf6.png" alt="Consolidation, in the loop: the librarian turns new events into wiki pages." width="799" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The core of Karpathy’s wiki is letting LLMs manage and organize the knowledge. Because Jean is based on event sourcing there is no special process for reading new memories: start from the last consolidated position and cover all the relevant new events.&lt;/p&gt;

&lt;p&gt;Consolidation is done by a headless agent, the librarian, run on a scheduler, usually once a day. Sonnet is used by default. It goes over all new events and looks at the current Markdown library, an index and articles, with instructions on where and when to split articles and how to consolidate. The wiki is committed, so consolidated changes are not lost.&lt;/p&gt;

&lt;p&gt;Sounds simple, yet this part also did not work on the first try. A day of events turned out to be a heavy job and it sometimes missed the timeout I had set. The fix was to split the job into more manageable and better-defined steps: a draft, a review and a commit. This seemingly naive change was enough to take the consolidation from 30 minutes to 3.&lt;/p&gt;

&lt;h3&gt;
  
  
  Reading
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fufw4syia4a5gl8lu9xyk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fufw4syia4a5gl8lu9xyk.png" alt="Reading, in the loop: one search over the wiki and what is not consolidated yet." width="799" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We have a wiki, consolidated from relevant events. There is a context skill, agents look at the index, they know how to find the relevant article. Problem solved, right?&lt;/p&gt;

&lt;p&gt;Not quite. In practice agents, when they are not constrained, access the knowledge in very inconsistent ways. They read a certain page but miss the more relevant one. They look at the summary of a page and decide it’s not worth reading the whole article. Sometimes they don’t use the wiki at all and grep over the memorize events.&lt;/p&gt;

&lt;p&gt;I wanted to make the search more structural, so I added an MCP method for the table of contents: the headers and a short summary of each page. One call to this, another to a specific article, and you’re set.&lt;/p&gt;

&lt;p&gt;The agents kept grepping the event log instead of using my seemingly very useful memory fetching method. Very disappointing, right? I did a bit of a therapy session. I sat down with an agent I caught red-handed and said, “When you have such a great tool, why do you use grep?” The agent said, “Well, the tool takes several calls, first the table of contents and then the page, and grep is just one call.” Additionally, the wiki didn’t cover events that weren’t consolidated yet, so the agent always decided the wiki wasn’t enough.&lt;/p&gt;

&lt;p&gt;That was an important understanding in building an end-to-end system. A dedicated one-stop search wasn’t just nice to have, it was required to make agents call it consistently. It gave the agents what they asked for: a single tool giving an overview of where to look, not a summary they could skip, not an additional index call. At that point it just clicked and started working consistently.&lt;/p&gt;

&lt;p&gt;That’s another advantage of one-stop search: it can search both the wiki pages and the recent events that aren’t consolidated yet, so nothing memorized falls in between.&lt;/p&gt;

&lt;p&gt;Markdown instructions are soft. When you need three of them to make something work, you will feel it breaking quite a lot. In my experience, MCP works better when you need something strict and consistent.&lt;/p&gt;

&lt;h3&gt;
  
  
  Handling stale data
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft2vee32xki5pbbmoxnv5.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft2vee32xki5pbbmoxnv5.png" alt="Handling stale data, in the loop: the sensei sweeps the wiki and writes corrections to the event log." width="799" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;So there we go, a working system, right? Still one thing is missing. When the librarian’s input is only what’s new, it has no authority to understand which data is stale. It is good at finding conflicts and resolving them, but there’s always some older data which becomes stale, unused and unneeded over time, and it will stay there if you don’t address it explicitly.&lt;/p&gt;

&lt;p&gt;So I added another triggered call, this time for the main agent, the orchestrator, the sensei, who has the best context on the project. Once a week it audits the wiki and looks for stale parts. It can’t edit the wiki either, no agent can, so for each stale part it memorizes a correction: an ordinary memory that says what is stale, which the librarian applies on the next consolidation.&lt;/p&gt;

&lt;p&gt;How much does it matter? I turned the sweep on a work project after it ran for 3.5 months without one. Its first pass over 74 pages flagged 157 corrections, which is about as many as all the corrections in the months before. Almost all of them fix staleness: things that were true once and stop being true. Following the staleness path, 66 pages were updated and the wiki became slightly shorter than before.&lt;/p&gt;

&lt;h3&gt;
  
  
  Librarian feedback
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F13lkmrvglqwbuit0eop9.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F13lkmrvglqwbuit0eop9.png" alt="Librarian questions, in the loop: the librarian raises questions in the log, the sensei reads them and memorizes answers." width="799" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;But what if the librarian has questions? The flow is one-directional, so when something doesn’t add up, it has to guess. Sometimes it needs feedback to resolve it, and there’s a mechanism for that, also based on events. At the end of each consolidation the librarian emits a dedicated event listing what it couldn’t resolve, like a contradiction it couldn’t settle or a link to a page that no longer exists, and the sensei consumes it.&lt;/p&gt;

&lt;p&gt;In practice it’s not rare: about 2 in 3 consolidations raise at least one question. The sensei reads them and either settles them or brings them to me. Either way, the answer goes back in as a memory that the next consolidation folds in.&lt;/p&gt;

&lt;h2&gt;
  
  
  Results
&lt;/h2&gt;

&lt;p&gt;One of the advantages of using event sourcing is that anything that happened in the past is naturally logged and can be investigated later. I ran an analysis on how the parts of the system work, and some of it was not what I expected.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Volume.&lt;/strong&gt; About 4,500 memories across 6 projects in about 6 months, and alongside them about 700 finished task threads went into consolidation. I was mostly surprised by how often it is used.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;By kind of project.&lt;/strong&gt; The personal assistant writes the most: about 17 memories on a day I use it, against about 7 in the work projects and about 5 in my own coding projects. I also talk to it the most, about 55 messages a day, and more of what I say there gets memorized: about 31 memories per 100 messages, against 19-23 in the coding projects. Measured against the work itself, though, the messages and task events in the log together, all three memorize at about the same rate: 12-15 memories per 100 events.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;One in five.&lt;/strong&gt; A little under one in five memories opens with CORRECTION, often fixing the memory just before it. I expected most corrections to come from different agents memorizing conflicting things. In practice it’s usually one agent that memorized too quickly, before it fully understood, and a few minutes later memorizes the fix. It can’t change an event that’s already memorized, so that’s how a memory gets fixed, and the next consolidation folds in both.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foim7sfpdhc306k9a4h3u.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foim7sfpdhc306k9a4h3u.png" alt="Bar chart: corrections as a share of all memories by month, May to October 2026: 21%, 23%, 15%, 16%, 17%, 25%; 18.6% across all months." width="799" height="387"&gt;&lt;/a&gt;&lt;br&gt;
&lt;em&gt;Event logs of six projects, May to October 2026. April, with 24 memories and no corrections, is left out.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Same share everywhere.&lt;/strong&gt; The share doesn’t follow the kind of project: about 18-19% in the personal assistant, in my own coding projects and in the work ones.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Who corrects.&lt;/strong&gt; Where the staleness sweep runs,&lt;sup id="fnref:1"&gt;1&lt;/sup&gt; it made about 4 in 10 of the corrections. Agents made the rest while they worked. The sweep is the sensei auditing the wiki and sending a batch of corrections at once. Month to month its share swung from a quarter to two thirds, highest in October, after two large sweeps&lt;sup id="fnref:2"&gt;2&lt;/sup&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What agents correct.&lt;/strong&gt; Agents correct two kinds of things. More than half of their corrections fix something the same agent had just memorized.&lt;sup id="fnref:3"&gt;3&lt;/sup&gt; Those come fast: when such a correction points at the memory it fixes, 80% come within the hour and 99% within the day, before any consolidation, so the mistake never reaches the wiki. About a third fix a page already in the wiki, something the agent ran into while working. That correction is a new memory, and the next consolidation uses it to fix the page. Only about 1% fix another agent’s memory.&lt;/p&gt;

&lt;p&gt;For that to happen, the memory has to be caught before it’s consolidated: once it’s in the wiki, the fix goes to the page instead. Still, it was nice to see agents correct each other while a memory was fresh, or while the work it describes was still in progress.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvqvfpx4nada9y12mjl8d.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvqvfpx4nada9y12mjl8d.png" alt="Bar chart of 551 corrections agents made while working: 58% fix what the same agent had just memorized, 32% fix a wiki page they name, 9% point at nothing, 1% fix another agent's memory." width="800" height="295"&gt;&lt;/a&gt;&lt;br&gt;
&lt;em&gt;Event logs of five projects. Sorting rules in note 3.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fshvgua2acz7ikriyeiak.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fshvgua2acz7ikriyeiak.png" alt="Bar chart of 177 corrections that cite the memory they fix, by the time between the two: 80% within the hour, 99% within a day." width="799" height="387"&gt;&lt;/a&gt;&lt;br&gt;
&lt;em&gt;Event logs of five projects. The sweep’s 16 such corrections are left out: they fix what went stale, not a fresh mistake.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Often it’s me.&lt;/strong&gt; In about 28% of the agents’ corrections, the agent says it’s fixing something I caught&lt;sup id="fnref:3:1"&gt;3&lt;/sup&gt;. For quick fixes of something just memorized, it’s about a third: the agent memorizes, I say it’s wrong, and the agent memorizes the fix. Either way, it’s still the agent that decides to write the correction.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Layers.&lt;/strong&gt; So the agents’ own corrections are mostly in flight: a fresh mistake, fixed by the same agent. About a third fix the wiki itself, wherever the day’s work runs into a page that’s wrong. Consolidation resolves conflicts between new memories and the pages they land on, which nothing counts as a correction. The sweep is the one layer that looks at every page, including the ones no work touches, and about two thirds of what it corrects has gone stale, while the agents more often fix facts that were never true. Correcting during work is necessary, and it isn’t enough on its own.&lt;/p&gt;

&lt;h3&gt;
  
  
  Consolidation
&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Corrections take effect.&lt;/strong&gt; When a correction names a page, the next consolidation changes that page 96-99% of the time&lt;sup id="fnref:4"&gt;4&lt;/sup&gt;. So a correction memorized during the day reaches the wiki that night, which closes the loop from memorizing to reading.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Mostly rewriting.&lt;/strong&gt; A typical consolidation changes 15-33% of a wiki’s pages, and most of those changes rewrite a page that’s already there: for every new page, about 8 existing ones get updated, 13-16 in the two oldest wikis. The wiki as a whole keeps growing, but interestingly the average page got longer until August and has been getting shorter since: new pages are now added faster than new lines.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frg78cymxmjsqco7byem7.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frg78cymxmjsqco7byem7.png" alt="Line chart of average lines per page at each month's end: 100 in July, 148 in August, 143 in September, 123 in October." width="800" height="379"&gt;&lt;/a&gt;&lt;br&gt;
&lt;em&gt;Wiki git history, July to October 2026. Index and log pages left out.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Reading
&lt;/h3&gt;

&lt;p&gt;Reads aren’t events, so the event log has no record of them. The main source is the agents’ session logs, which Claude Code keeps for 30 days by default. I’m adding read logging, so from now on it’s recorded. In that month, about 800 searches and about 1,100 page reads, against about 1,250 memories. Workers read about 3.6 times what they write, and the sensei reads about as much as it writes. The difference between the sensei and the workers is interesting. It probably comes with orchestrating: the sensei sees the wider context and memorizes at a higher level, while workers mostly memorize what they ran into on a specific task. The sensei also reads more and writes much more than the workers, which I guess comes with the responsibility.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frbrqgschmwdxt8u8ikd6.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frbrqgschmwdxt8u8ikd6.png" alt="Bar chart of reads and writes by role: the sensei made 1,179 reads and 1,061 writes, 1.1 reads per write; workers made 688 reads and 189 writes, 3.6 reads per write." width="800" height="316"&gt;&lt;/a&gt;&lt;br&gt;
&lt;em&gt;Agents’ session logs, 23 Sep to 25 Oct. The librarian, which reads pages to write the wiki and never memorizes, is left out.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing thoughts
&lt;/h2&gt;

&lt;p&gt;In my experience it works: agents use it, and I don’t feel they miss important information. The main lesson for me is that getting agents to remember things is the easy part, and keeping what they remember true is where the real work is. Agents fix mistakes as they work, the librarian asks when something doesn’t add up, and a weekly sweep catches what has quietly gone stale.&lt;/p&gt;

&lt;p&gt;Jean is open source at &lt;a href="https://github.com/leonidb/jean" rel="noopener noreferrer"&gt;github.com/leonidb/jean&lt;/a&gt;, and the memory system as built is written up in &lt;a href="https://github.com/leonidb/jean/blob/main/docs/wiki.md" rel="noopener noreferrer"&gt;docs/wiki.md&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Notes
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;The weekly sweep wasn’t part of every project from the start. Jean shipped it as a skill that each project’s orchestrator had to schedule, and 3 of the 6 did, from May. The sweep numbers come from those three, counted from the day each sweep started. Every active project runs it now. ↑&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Both large October sweeps were the regular weekly sweep in the personal-assistant project, with 37 and 62 corrections. Almost all fixed something that had gone stale: a decision reversed, an open item since done, a plan that moved on. About one in five instead toned down a rule the wiki stated too strongly. ↑&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Corrections were sorted by what each one points at: a memory it cites, a wiki page it names, or neither. “Just memorized” also counts corrections that point at nothing when the same agent memorized something in the hour before, so it’s likely rather than certain. Credit to me is read from each correction’s own wording, and it’s a floor, because terminal conversations aren’t logged. ↑ ↑&lt;sup&gt;2&lt;/sup&gt;&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;A correction counts as taking effect when the page it names changed in the consolidation that read it. ↑&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>llm</category>
      <category>claude</category>
    </item>
  </channel>
</rss>
