It gets sharper while you sleep.
The HiveMind runs the work by day. At night it dreams on what happened, turns the lessons into instinct, and wakes up less likely to make the same mistake twice. This is how that loop actually runs, in plain words, grounded in the live brain.
An AI with no memory is a stranger every morning.
The model does not remember. Between sessions its memory resets to zero. Every new conversation starts on a blank page, no matter how much you taught it yesterday.
So you re-explain the project. You re-correct the same mistake. You paste the same context you pasted last week. The model is bright and fast and completely new to your world, every single time.
A context window is not memory. It holds what you told it today. Close the session and it is gone. A bigger model does not fix this. A longer window does not fix this. The fix is a loop that writes down what happened and reads it back before the next run. Plain files, on your disk. That is the whole idea on this page.
You are the memory. You carry every correction in your head and repeat it out loud each session. The same mistakes come back. The context gets re-pasted forever.
It carries its own memory. Yesterday's correction is on disk. It reads it back before it acts, so the same mistake does not return, and each day starts already caught up.
Memory is the line between a tool you operate and a teammate that gets better.
What the swarm is carrying today
The brain is not a black box. It is a set of plain files that grow every day. Here is what is in it right now.
[ INTELLIGENCE ] Loaded 13 patterns matching this session
0 errors
Every session starts by pulling the handful of patterns that fit the work in front of it. Nothing is loaded that does not apply.
It dreams at night
When the work stops, a second agent wakes up. It reads the whole day back and writes down two things: what got missed, and what it all means.
Execute
The swarm does the work. Every build, edit, and decision leaves a trail.
Capture
The session log writes down what was done, what stalled, and why.
Dream
The Insight Agent reads the day back through two lenses and writes the brief.
Wake
Next session loads the brief first, so the day starts already caught up.
The dream is not a metaphor for nothing. It is a real nightly job. It reads the session logs and project feeds, then writes one file, the daily brief, through two honest lenses.
What got missed
The parts that are quietly at risk. Work that looks finished but is not wired up yet. The thing nobody flagged out loud.
- A launch that is beautiful on paper but not live in the real world yet
- A blocker hiding inside two small database cells
- A promise made that no step actually delivers
What it all means
The day pulled together into a story. Not a list of tasks. What actually moved, what it connects to, and what it sets up next.
- What shipped, in one line each
- How today's work links to the bigger goal
- The one thing worth doing first tomorrow
A dream older than 48 hours is not trusted
If the nightly brief is stale, the system stays quiet instead of nudging you with old information. It would rather say nothing than say something out of date. Silence is safe. A confident wrong answer is not.
It builds instincts
A lesson starts as a note. An instinct is a lesson that has earned the right to fire without being asked. Here is one, taken apart.
Name
Background agents must be told to send their results back
When the swarm sends a helper off to do research in the background, it now knows to ask for the answer up front. It learned this the hard way: once, five helpers finished their work and then sat there holding it, waiting to be asked. That cost five nudges. Now it is a reflex.
A background helper is sent off and its answer is the thing you actually need back.
The helper runs in the foreground, where the answer already comes straight back on its own.
The score behind the reflex
How a note becomes a habit
Every instinct carries a confidence score. It goes up when the reflex proves right. It goes down when it proves wrong. And if it sits unused, it fades on its own, losing half its weight every 21 days, so the brain does not cling to old habits that no longer apply. Nothing hardens into a rule by accident.
A single instinct's confidence starts near 0.5, rises with confirmations, drops once after a correction, and currently sits at 0.55, still below the 0.70 line where a candidate becomes a confirmed habit.
It learns every day
The loop is short and it is closed. A mistake made once is turned into a rule that makes the same mistake hard to make twice.
- The swarm does the work. A build, an edit, a call, a decision.
- You react. You correct it, or you confirm a call that was not obvious.
- It writes the fact down. One memory file: the rule, and how to apply it next time.
- It finds the fact again. Before similar work, it searches the brain and surfaces the rule.
- The mistake does not repeat. The rule fires before the wrong move happens.
Memories are not one big pile. They come in five plain kinds, so the right one is easy to find when it matters.
brain-search "how did the client detector miss real typing" → 5 results
rule surfaced before the retry
A real one, before and after
Here is a mistake the swarm made once, and the rule it wrote so it cannot happen the same way again.
A client name detector matched words too strictly. The founder's real, human typing, "give me maydays last report", missed. Every lab test had passed. Only live typing exposed it.
Match names the way people actually type them, and pin every phrasing a real person missed as a test the same hour it happens. The gap closes and stays closed.
Mistakes turned into rules this week: 9
One mistake, traced end to end.
Here is the whole loop on a single thread. One small mistake, and how it becomes a thing that cannot happen the same way twice.
It reaches for a package you deleted
Mid-task, the model pulls in a dependency your team dropped months ago. You catch it and say so, once: use the built-in, not that library. A normal correction. In most setups that is where it ends, and it happens again next week.
The correction becomes a written rule
At the end of the session, the capture step writes it down. Not a vague note. A rule, with where it should be seen next time.
The dream brief flags the pattern
That night, the synthesis step reads the day back and records the correction in one line, so the theme is visible above the noise: dependencies are being second-guessed, tighten the rule.
A rule earns its way toward reflex
The rule proves right more than once. It becomes a candidate instinct at confidence 0.50, climbing each time it holds. It is not a law yet. It has to keep earning its place before it fires on its own.
It avoids the mistake before you say a word
New session, blank slate again. But before it writes code, the recall step searches what it already learned and surfaces the rule. It reaches for the built-in on its own. You never had to say it twice. That is the loop paying off.
A mistake here is only allowed to happen once.
Most systems make the same mistake on Tuesday that they made on Monday. This one does not. The dreaming turns a day into a lesson. The instinct turns a lesson into a reflex. The daily loop makes sure the reflex fires before the wrong move happens.
That is the whole point. Not a smarter answer once. A system that is quietly harder to fool every single day, because it remembers, and it never stops keeping score.
The swarm dreams, builds instinct, and wakes up sharper
Day by day the brain gets bigger, the reflexes get sharper, and the same problem stops costing you twice. That compounding is the asset. It belongs to the work, and it grows on its own.
You can read everything it remembers.
An AI that remembers raises three fair questions. Where does it keep this, can it learn something wrong, and is my data safe. The answers are the whole reason to trust it.
Nothing hidden
The memory is markdown and JSON in your own repo. Open it, edit it, delete what you disagree with. It lives in your git history, so a diff shows exactly what changed and when.
It has to earn it
A correction outweighs a confirmation. A new instinct starts as a candidate, not a law, and has to earn confidence before it fires on its own. If it stops being right, it decays.
It stays on your machine
No account, no outside service, no telemetry. And stale beats wrong: an insight older than 48 hours goes quiet instead of nudging you with old information.
A disciplined habit loop, not a black box
Not fine-tuning. The model is untouched. The learning lives in files it reads, not in the model's weights.
Not a vector database product. No embeddings service, no infrastructure to run. Plain files and a search over them.
Not autonomous. You are the teacher. Your correction is the signal. Nothing is learned that you did not confirm.
Not magic. It only knows what got written down. What you capture is what it learns.
Four skills. Yours to keep.
The whole loop is four small skills. Download them, drop them into your own setup, and your work starts learning the same way. You own them outright. Nothing is locked, nothing phones home.
Closes the day. Writes a dated log, then keeps the one mistake worth a rule and the one move worth repeating.
- Turns a mistake into a rule in lessons
- Keeps a winning approach in patterns
- Only saves what is confirmed, never invented
Reads the day back through two lenses and writes a short brief the next session opens first.
- Blind spots: what quietly got missed
- Synthesis: what it all means
- Trusts nothing older than 48 hours
Scores which lessons have earned the right to fire on their own, so nothing hardens into a habit by accident.
- Confidence rises on proof, falls on correction
- Unused reflexes fade on a 21 day half-life
- Candidate becomes a habit at 0.70
Before repeating any work, it searches past lessons, patterns, and memories so a mistake made once is not made twice.
- Five plain kinds of memory, easy to find
- Ask a real question, not a keyword
- Closes the loop the other three open
Written to run in any Claude Code project. No credentials, no lock-in. Read each file before you use it.
Wire it up in an afternoon
The install is just files in the right place. Here is the whole setup.
- Drop each SKILL.md into .claude/skills/<name>/. That is the install. Your assistant discovers them on the next run.
- Make the files they write to. An empty brain/lessons.md, brain/patterns.md, brain/daily-brief.md, brain/instincts.json, and a memory/ folder. Empty is fine on day one.
- Run session-log at the end of a session. It writes your first lesson and pattern.
- Schedule night-insight once a night. A cron job, or a startup hook that fires it. It reads the day back and writes the brief.
- Make brain-recall a habit before work. Ask it what it already knows before you repeat anything.
- Let instinct-ledger sweep your lessons. Run it when a rule has held more than once, and it starts scoring reflexes.
After a week you will have a handful of real lessons, a nightly brief, and your first candidate instincts. That is the loop running. The tell is simple. You stop repeating the same corrections, and the model starts pre-empting them.
Straight answers
No. The model is untouched. The learning lives in files it reads before it works, not in the model's weights.
session-log at the end of a session. night-insight on a nightly schedule. brain-recall before work. instinct-ledger on a sweep of your lessons. Nothing fires on its own that you did not set up.
In your repo: a brain/ folder and a memory/ folder, tracked in git. You own it and can read or delete any of it.
Open the file and delete it. Corrections outweigh confirmations, and an instinct that stops being right decays on its own.
No. Point the skills at whatever paths you use. The loop is the idea, not the filenames.