Part 2 of 3. How nine agents share one mind, why some of it lives in a database and the rest in a folder of plain text files, and what happens at two in the morning when the system quietly tidies its own memory.
In part one I introduced the nine-agent system that runs the back office of my consultancy on a refurbished mini PC. I described what each agent does. What I skipped, deliberately, was the hardest and most interesting problem underneath all of it.
Nine agents are easy. Getting nine agents to share a memory is the actual work.
Think about what nine separate agents are without shared memory. They are nine strangers who happen to work in the same building. The Editor suggests an article the Scout already researched last week and neither of them knows. The Entrepreneur pitches an idea it pitched a month ago because it has no recollection of ever having done so. Every agent starts every task from nothing, forgets it the moment it finishes, and never learns that the agent down the hall already solved the same thing. A pile of capable agents with no shared memory is not a team. It is a group of goldfish with good vocabularies.
So the interesting question was never how do I build nine agents. It was how do I give them one mind to share. And the answer has three layers, because it turns out a shared mind needs to do three different jobs, and trying to make one thing do all three is how you get a mess.
Three layers: a bulletin board, a nervous system, and a memory
When I first sketched this, I made the mistake most people make. I reached for a single store to hold everything the agents needed to share. That is wrong, and figuring out why it is wrong taught me most of what I now know about designing these systems. A shared mind is not one thing. It is at least three, and they want to live in different places.
The bulletin board. Some things that happen need to be announced to everyone, right now. The Scout finds a new acquisition in the market. The whole system should know that happened. So the agent posts it as an event, and that event is broadcast to the entire suite. Any agent can see it. This is a public board in the break room: someone pins a notice, and it is visible to all. The catch, and it is an important one, is that a bulletin board is broadcast, not targeted. It announces that a thing happened. It does not know or care which agents actually need to act on it. Everyone can see everything, which means every agent has to do the work of sifting what is posted for what is relevant to them. Broadcast is powerful and it is also noisy. Hold that thought, because later in this article you will meet its exact opposite.
The nervous system. Underneath the announcements is a layer of fast, structured, operational signals. Which messages have already been processed. Whether a source is healthy or has started failing. Whether a scheduled job ran or got missed. The draft history. This is reflex, not thought. It is the stuff that has to be reliable and quick and exact, and it never needs to be poetic or human-readable, it just needs to be right. This layer lives in a small database, SQLite, a single file on disk with no server to run. A database is exactly the correct tool for fast structured facts the system checks constantly. The bulletin board of events lives here too, because broadcasting and checking events is the same kind of fast, structured work.
The memory. And then, separate from all of that, is the part that actually accumulates into knowledge over time. What the system has learned. What each agent has done, in order, forever. The voice profiles, the project history, the durable record. This is not reflex and it is not a momentary announcement. It is memory, and memory has completely different needs from the nervous system. Memory needs to be legible. It needs to be safe to reorganize. It needs to last.
So the memory does not live in the database at all. It lives in a folder of plain text files.
Why the memory is a notebook
Here is the part that surprises people. The durable memory of my entire agent system is a directory of markdown files, the same simple format this article is written in. Not a vector store. Not a fancy retrieval system. A notebook that any agent can read and any human can open.
The simplicity is the entire point, and it is a deliberate contrast with the database sitting right next to it. The nervous system is in SQLite because operational facts want to be structured and queried fast. The memory is in plain files because memory wants to be read. I can open the mind of my entire system in any text editor and see exactly what my agents know and have done. When something goes wrong, I search it the way I search any folder of documents. No query language, no service to keep alive, no black box. In a system doing complex autonomous work while I sleep, being able to open a file and simply read what the machine is thinking is worth more than any amount of cleverness.
There are two kinds of files in that memory. Some are snapshots, a current-state document its owning agent overwrites fresh each run: what an agent knows right now. The others are histories, append-only logs, one per agent, where every run leaves a permanent dated record at the bottom and nothing above ever changes: what an agent has done, all of it, in order.
That choice to keep memory as readable text turned out to be quietly prophetic, in a way I will come back to in part three. For now, know this: the operational reflexes of my system live in a database, and the memory of my system is a notebook you could read over my shoulder.
But a notebook that everyone writes into and no one ever tidies becomes a mess very quickly. Nine agents, writing every day, leaving a permanent record every time. Within weeks it is thousands of entries deep, thick with near-duplicates, the signal buried under repetition. Something has to keep it clean. That something is the Librarian, and the way it works is my favorite thing in the whole system.
The Librarian, and the two speeds of memory
The Librarian is the agent responsible for the shared mind. It runs at two completely different speeds, and the split is the key to understanding it.
The first speed is instant. When another agent, or I, need to know something from the collective memory, the Librarian answers on the spot. What do we already know about this topic. Have we covered this before. Did anyone research this last month. It is the reference desk. Ask a question, get an answer pulled from everything the system has ever recorded. This keeps agents from redoing work, because before an agent starts something, the memory can tell it whether the work is already done.
The second speed is slow, and it only happens at night, and it is where the real magic lives.
The dream
Every night at about two in the morning, when nothing else in the system is running, the Librarian does something I decided early on to call dreaming. I called it that half as a joke. The name has stuck because it turns out to be an unusually accurate description of what the process actually does, which is more or less what sleep does for a human mind. It takes a busy, cluttered day of memory and quietly consolidates it into something ordered.
Here is what happens during a dream, in sequence.
First it gathers everything. Every entry, from every agent's history, the entire day's worth of what the system did and noticed and decided, all pulled together into one place.
Then it runs a series of passes over that pile, each one doing a specific kind of tidying:
- The deduplication pass finds entries that are saying the same thing and collapses them down to the most recent version. When three agents all noticed the same market shift, the memory does not need three near-identical notes about it. It needs one good one. This pass is doing the heaviest lifting, and the numbers show it, which I will get to.
- The staleness pass looks for information that has aged out. Things that were flagged to expire, or that have sat untouched and uncited for so long that they are no longer pulling their weight. Old news gets moved out of the way so it stops cluttering what is current.
- The pattern pass looks across the whole memory for something subtler. It hunts for topics where an agent that should be paying attention has gone quiet. A subject the system clearly cares about, that one of the agents has stopped contributing to. A gap in the collective attention.
- The whisper pass is the one I am proudest of, and I will give it its own section, because it does something I did not expect a memory system to do.
After all the passes run, one more thing happens, and it is the safeguard that makes me comfortable letting this run unattended. A separate grader scores the entire dream against a quality standard. If the dream does not pass, the whole thing rolls back. Every change from that night is undone, and the system posts a note saying the dream was rejected. The memory would rather change nothing than change badly.
And underneath all of it is one absolute rule: the dream never deletes anything. Ever. Everything it clears away is archived, not destroyed, and any of it can be brought back with a single command. A memory system that can permanently erase its own contents on an automated schedule while you sleep is a memory system one bad night away from a catastrophe. Mine cannot. It can only ever set things aside, reversibly. That constraint cost me nothing and lets me sleep while my system reorganizes its own mind.
What 25 nights actually looked like
I want to show you the real data, because the honest numbers tell the story better than any description, and because the honest numbers include things that did not fire, which is exactly the sort of detail that separates a true account from a brochure.
Over about three and a half weeks, the system dreamed 25 times, once each night. Across that stretch, the canonical memory, the clean, current, de-duplicated core, grew from 26 entries to 65. That is 39 new entries of genuine signal, a 150% increase, two and a half times the knowledge it started with, accumulating at roughly 1 to 2 solid entries per night. That is the real knowledge of the system compounding, carefully, one honest addition at a time.
But the growth number is only half the story, and the other half is the one that actually matters to anyone weighing whether a system like this earns its keep. Look at everything the agents produced in that window, not just what survived. About 155 new entries came in over those three and a half weeks. Of those, only 39 were genuine new signal, the ones that made it into the clean core. The other 116 were duplicates, near-identical restatements of things the system already knew. The nightly dream caught and set aside every one of them.
Sit with that split. Roughly 75% of everything nine busy agents generated was duplication. Three out of every four entries they produced was noise the system had already recorded in some form. Only 1 in 4 was a real addition to what the system knew. Left alone, that ratio buries you: the 65 genuinely useful things would have been sitting under more than 300 near-copies of themselves, and every agent reading the memory would have been reading mostly repetition. The dream is the reason that did not happen. Every night it caught the 75% that was duplication and quietly filed it away, so the 25% that was real signal stayed clean and findable.
In plain business terms: the system's knowledge grew 150% in three weeks, while the memory automatically filtered out three-quarters of the clutter the agents generated, with no human touching it, at 2 in the morning, for free. A knowledge base that gets measurably smarter while keeping itself clean is the difference between a system you can trust in a month and one that has quietly drowned in its own notes.
Now the honest edges. In all 25 of those nights, the staleness pass archived nothing. Not once. My information simply was not aging out fast enough over three weeks to trigger it. And the pattern pass, the one hunting for gaps in attention, stayed quiet the entire time too. Neither of those is a failure. They are the log telling me the truth: those mechanisms are built, they are ready, and the conditions that call for them had not yet arrived. I could have quietly not mentioned that. But a system you are going to trust with real work should be described by what it actually did, not by what it might do on a good day. Two of my four passes spent three weeks warming the bench. That is fine. That is what the record says.
The whisper is the anti-silo
I saved the whisper pass for its own section because it does the single most interesting thing in the system, and because it is the exact answer to a problem I planted earlier in this article.
Remember the bulletin board. Events get broadcast to everyone, which sounds great until you notice its blind spot: broadcast tells everyone that something happened, but it never tells any particular agent that this one is for you. Everyone sees everything, so everyone has to sift, and things slip through precisely because they were technically visible to all and specifically flagged for none. Broadcast is loud and undirected. It is the opposite of knowing what matters to you.
The whisper is the other half of that idea, and it lives in the memory, not the bulletin board. Here is the problem it solves. Left entirely to themselves, each of my agents optimizes its own narrow lane. The Scout gets very good at scanning. The Editor gets very good at topics. And precisely because each one is heads-down on its own job, each one slowly stops noticing things slightly outside its lane. Specialists silo. It is not a flaw in any one agent. It is what specialization does, to people and to software alike. The bulletin board does not fix this, because a firehose of broadcast events aimed at everyone is not the same as a nudge aimed at you.
The whisper pass is that nudge. Every night, the dream looks at what each agent specifically has been neglecting, finds the single richest topic that particular agent has been ignoring, and quietly hands it to them for the next day. Where the bulletin board shouts one thing at everyone, the whisper says one thing to one agent: here is the thing you, specifically, keep overlooking. It is the memory itself noticing that an agent has drifted from something it should care about, and directing its attention back. Broadcast and targeted, the two halves of a working shared mind.
That reframed how I think about what memory is even for. I had assumed memory was storage. A place to keep things so they can be retrieved later. The whisper taught me that memory can be active. It can do more than hold information. It can notice what is being overlooked and push it, precisely, to the one who is overlooking it. In a team of specialists, human or agent, the thing that keeps everyone from disappearing into their own lane is not a louder bulletin board. It is a shared memory that pays attention to each member and speaks to them directly. I did not set out to build that. I set out to stop my agents from repeating themselves, and I ended up with a memory that keeps the team from siloing. The best features are often the ones you discover you built.
What this part was, and where it goes
So that is the shared mind. Three layers, each matched to its job. A bulletin board that broadcasts what just happened. A nervous system of fast operational reflexes in a small database. And a memory, a notebook of text files any agent can read and any human can open, tended by a Librarian that answers instantly by day and, by night, gathers the whole cluttered record and dreams it back into order, safely, reversibly, and with the honesty to leave a log of what it did and did not do.
Memory is the hard part of a multi-agent system. Not the agents. Anyone can spin up agents now. Giving them a shared mind that broadcasts what is urgent, remembers what is durable, keeps itself clean and legible, and actively directs each specialist's attention so the team does not fragment, that is the work. And splitting it correctly, fast structured reflexes in a database, durable readable knowledge in plain files, is the decision the whole thing rests on.
In part three, that decision pays off in a way I genuinely did not see coming. Because a memory made of plain, readable text turns out to be exactly the right thing to feed to a small AI model running locally on the mini PC's own processor, an agent whose entire job is to watch the rest of the system and propose its own improvements. It is the strangest thing I have built, it is the one I trust the least on purpose, and building it showed me that my little refurbished box had wandered onto the same path as the biggest AI lab in the world.
Where Does Your Organization Stand?
The interesting problems in AI are rarely the models themselves. They are the systems around the models. How they remember, how they share what they know, how they keep from tripping over their own work.
Our MACH and AI Readiness Assessment benchmarks your organization against enterprise leaders from the MACH Alliance 2026 Report. Free, about five minutes, and you walk away with a personalized read on where you stand on composable maturity and AI readiness.
Thinking about how knowledge and memory should actually work across your systems? Let's talk. Fidget Labs helps organizations design AI systems that are legible, durable, and built to fit the problem.
