My Second Brain Was Full of Lessons My Agents Never Used
My agents had saved 126 lessons and reused 5. So I started running every recurring job as a system, with a lab where only verified lessons reach the agents.

I asked my agents' memory a simple question: what do we know about tweet hook copy? The search came back empty.
That answer was wrong. My agents had saved 16 lessons on exactly that topic. They lived in a database, and memory recall reads memories and documents, never database rows, so the search had nothing to find.
Then I counted. Across all my projects, my agents had stored 126 lessons in that database, and only 5 had ever been reused. The rest were notes written by agents for agents that would never see them.
Memory itself was not the bottleneck. It held 372 records at the time. I had built a second brain and filled it, and the part that was supposed to make my agents better at their jobs was the part they never opened.
Memory stores facts, not what was proven
My first instinct was to move the lessons into memory, where recall would find them. That would have made things worse.
Memory is good at facts. The API uses Postgres, the client prefers calls on Tuesday, the deploy runs from main. A lesson is a different kind of thing. "Hooks with a number in the first line get more replies" is a claim about cause and effect, and most of mine had never been tested. Some were measured. Some were a hunch an agent wrote down after one good day.
If I put all of them in memory, every hunch comes back to the next agent with the same weight as a measured result, and untested ideas start to look like rules. If I keep them in a database, they are safe from that and also invisible. I had picked the second option without noticing, and ended up with a library nobody visits.
There was a second problem, in how the agents worked. They ran recurring work blind. A content agent would draft a batch of posts with no question attached to the batch, and nothing checked afterwards whether that batch did better or worse than the last one. Lessons got written sometimes, but nothing made the next batch read them.
On 3 November I measured how often lessons got written at all. In the previous 7 days, 34 of 64 substantial agent work sessions (53%) saved no lesson anywhere. Half the work left nothing behind for the next session to learn from.
Every recurring activity is a system
The fix I settled on is old-fashioned. Every recurring activity my agents run (outreach, posting, SEO, a dev lane) is now a system, and every system has five parts.
- A goal: one outcome metric with a target. Meetings booked, not emails sent. Signups from search, not articles published. An activity count only tells you the machine ran.
- A machine: the scheduled jobs and skills that do the work.
- A source of truth: where outcomes are measured, such as the inbox, the analytics or the CRM. It is never the status the agent planned or reported.
- A review on a fixed cadence, weekly for most of mine, where someone looks at the numbers and decides what changes.
- A playbook: the rules in force, a log of what was learned, the active experiments and the ones that were stopped. The machine reads it before it produces anything, so a review changes the next output.

Each system also carries a few rules that keep the loop honest.
- Each system has a counter-metric, so the goal can't be hit by breaking something else. Replies going up while unsubscribes triple is not a win.
- Stop conditions are written down before an experiment starts.
- A system runs at most 3 experiments at once. With more, nobody can tell which change did what.
- The reviewer reads the raw data and never grades the system from the machine's own notes, because an agent's summary of its own week is always a little generous.
- The first review of each month asks whether the system should exist at all.
Here is how that plays out. Say an outreach agent emails a few hundred SaaS founders over three weeks and gets zero replies, while opens look fine. The tempting move is more volume: a second sequence, another hundred leads a week. The playbook says no. Zero replies after a fair sample means a stage is broken, and adding volume to a broken stage only makes the failure bigger. The review changes one big variable instead, the audience or the offer, writes it down as an experiment with a stop condition, and the agent reads that change before its next batch.
Or take a content agent whose posts get steady impressions and almost no profile visits. The counter-metric catches it, so the next experiment changes the call to action and leaves the posting schedule alone. An SEO agent that publishes four articles a week while signups from search stay flat gets the same treatment: the review stops counting articles and asks which pages bring people who sign up.
The lab, and the only things that leave it
The five parts fixed the blind running. They did nothing for the 126 lessons. For those, every system got a lab.
A lab entry is a lesson or an experiment: what we think, why, how to apply it, and how good the evidence is (untested, suggestive or measured). Entries in the lab are invisible to recall. An agent searching memory will never get "maybe shorter subject lines help" back as advice.
Only verdicts get out. A verdict says either "works" (a rule or a tactic) or "does not work" (an anti-pattern), and it carries its evidence level and its source. Promotion needs measured evidence or my explicit call, plus a source anyone can open. A hunch with a good story stays in the lab.
Retiring works the same way in reverse. When a verdict stops holding because the platform changed or the audience moved, retiring it removes it from recall right away. Its history stays, so nobody rediscovers the same dead end six months later.

When I sorted my 126 lessons this way, 86 had verdict-grade evidence, meaning they were measured or I had made the call explicitly. The other 40 went back to the lab as suggestive or untested. Almost a third of what my agents had been calling lessons were really ideas.
A lesson from one system is a hypothesis in another until it is measured there.
That rule matters more than I expected. A hook that works on one channel gets copied to another channel as a lab entry, and it has to earn its verdict again.
How it runs day to day
Three pieces keep it moving.
A daily job reads yesterday's agent sessions and adds what it finds to the right system's lab. It never promotes anything, and its only job is to make sure a session's lesson doesn't vanish with the session.
The weekly review is the only gate. It reads the raw numbers from each system's source of truth, promotes lab entries that now have evidence and demotes verdicts that stopped holding. Nothing else can turn an idea into a rule.
The work skills close the loop. Before my content, outreach or SEO skills produce anything, they read the verdicts of their system. After the output exists, they record which verdicts shaped it. That record is how I measure reuse, and it was missing from the start.
I had underrated this last piece. Feed-forward is the link most setups miss. You can run careful reviews and keep a clean playbook, and if no job reads it before working, the next output is the same as the last one.
A playbook nobody's job reads changes nothing.

Where I built it
I built this into Space, the shared memory and workspace for AI agents that I make, which agents reach over MCP. Systems are native there now: each system with its five parts, its lab and its verdicts. Agents use a handful of tools. list_systems and list_verdicts read, add_lab_entry proposes, promote_lab_entry and demote_lab_entry belong to the weekly review, and record_verdict_use logs when a verdict shaped an output. Recall only ever returns verdicts.
You don't need Space for this. A folder of markdown playbooks, a spreadsheet for the lab and a scheduled job that reads the playbook before working will get you most of the way. What matters is the gate and the feed-forward, wherever they live.
What I don't know yet
I set one goal for the whole setup: 30% of verdicts reused within 30 days. I started from 5 reused lessons out of 126, and I don't have the result yet.
I'll write a follow-up with the number, even if it's bad. A bad number would be a lesson too, and it would go through the lab like every other one.
How do you make your agents learn from their own work? Do you keep lessons in memory, in files, or nowhere at all? I'd like to hear what actually got reused for you.