Dreaming: How an Agent Fleet Curates Its Own Memory Overnight

The library no one designed

Run a real company on a fleet of AI agents and a second knowledge layer appears that no one designed. The agents that schedule the field work, run the QA, reconcile the billing, and key in the data don't just execute tasks — they take notes. An agent learns that a customer prefers calls before 10am. Another discovers a data table is missing the column it expected. A third writes down what the QA lead actually meant: a borderline case is a warning on the report, not an automatic rejection. None of that lives in a spec. It accrues, mid-task, as the fleet meets the world — the operational knowledge a company only ever earns by doing the work.

Left alone, that layer rots. Several agents independently relearn the same hard lesson, each one paying the failure cost over again. Conflicting rules pile up — three notes about a single QA criterion, written weeks apart, quietly disagreeing. Stale facts linger past their expiration. And nothing is ever checked: a note from March is trusted in June on pure faith. A library that grows but is never curated doesn't become wiser. It becomes a liability.

Dreaming is the HomieAI feature that curates it. Each night, while the fleet is idle, an out-of-band process reads across every agent's recent work, finds the duplicates and contradictions and stale entries no single agent can see from inside its own task, and proposes a clean set of corrections to the shared memory. The bet underneath it is simple, and it is the one that matters: a fleet that learns from its own experience overnight is worth far more tomorrow than it was today — and that gain belongs to every agent at once.

The second knowledge layer rots

Every agent in the fleet keeps a long-term memory store — a running file of atomic facts it writes down mid-task, the way a good employee jots a note after a tricky call. These are not abstractions. They are concrete, operational, and earned: "this customer prefers calls before 10am." "That data table is missing the column you expect — query the other one." "Per the QA lead, a borderline case is a warning on the report, not an automatic rejection." Each fact is a small piece of hard-won judgment, and the next time the agent faces the same situation it reads the note instead of re-learning the lesson. That store is the difference between an agent that starts every shift cold and one that arrives already knowing how the business actually runs.

But a memory store is a living thing, and living things accumulate damage. The same property that makes it valuable — that any agent can write to it, any time, mid-task — is what lets it decay. At the scale of a fleet, that decay has a predictable shape:

• Duplicate lessons. Several agents independently hit the same wall and each writes its own version of the same fix. The lesson is learned many times over, and every one of those agents paid the full failure cost to learn it.
• Conflicting rules. Three notes about a single QA criterion, written weeks apart by different agents, quietly disagree with one another. Nothing flags the contradiction; whichever one an agent happens to read wins.
• Stale facts. A delivery rescheduled twice still carries all three notifications. The world moved on; the memory didn't. The agent acts on a state of affairs that stopped being true in March.
• Nothing is ever verified. A note from March is trusted in June on pure faith. No facts have an expiry, no re-check, no last-confirmed stamp — only the date they were first written.

The instinct is to ask the agents to keep their own house in order. It won't work, and the reason is structural. A live agent is mid-task. It sees one customer, one job, one slice of the store — never the cross-session view where the duplicates and contradictions actually live. And its objective is to finish the job in front of it, not to curate a shared library it can barely see. Asking it to do both is asking it to serve two masters at once.

Memory quality is a separate objective. It deserves its own process and its own clock — because an agent in the middle of its work, with one perspective and a job to finish, will never stop to tend the library it relies on.

Reading the fleet's whole week

No single agent can see what the fleet has learned. Each one lives inside its own task — a scheduling agent never reads the billing agent's transcripts, and neither remembers what the QA agent discovered last Tuesday. They are, by design, narrow. Dreaming is the one process with the wide view. Once a night, while the fleet is idle, it reads the last seven days of every agent's conversations at once — the cross-session perspective that exists nowhere else in the system — and from that whole-week read it proposes a single change to the shared memory: a memory diff.

A diff is the right unit because the goal is not to rewrite the library but to correct it surgically. Dreaming looks for the patterns only the panoramic view exposes: the same failure hit by three different agents, a strategy that quietly worked and deserves to be remembered, a note that a fresh transcript just contradicted, two memories that say the same thing in different words. Then it writes those observations as discrete, reviewable changes — never a wholesale overwrite.

There are five change types, and each maps to a specific kind of memory rot:

That last type matters more than it looks. Verify is how a memory earns continued trust: not by surviving untouched, but by being re-checked against real evidence and dated accordingly. A library where every shelf carries a "last confirmed" stamp is a library you can actually rely on.

The fleet reads a week's worth of its own work and offers back a handful of careful corrections — resilience that compounds while everyone sleeps.

Nothing passes the gate unverified

A process that edits the memory the whole fleet relies on has to earn its keep on trust before it earns it on autonomy. So Dreaming is cautious by default. It does not write to the memory store. It proposes. Every run ends not in a change but in a staged diff — a list of suggested edits that sit, untouched, until a person says otherwise.

That review is deliberately granular. An operator opens the dashboard and works the diff change by change, not as one all-or-nothing batch. Each proposed edit opens into a modal with the full before-and-after: the memory as it stands, the memory as Dreaming would have it, and the written reason for the difference. You can apply the merge of three contradictory QA notes and decline the deletion of a stale delivery reminder in the same sitting. Approve what's right; leave the rest. Once the diffs have earned an operator's confidence, a single setting flips the default from review to auto-apply — trust extended on evidence, not assumed on day one.

Three more guarantees sit underneath the review. Every memory carries a version number and a last-verified date, so its history is legible at a glance — what it says, when it was last confirmed true, and how many times it has changed. Every applied edit lands in an audit ledger with its before-and-after value, a written rationale, and links to the exact conversations that justified it; no change exists without its receipts. And because a run reads a week of transcripts while agents keep working, live writes always win: if an agent recorded something fresher mid-run, Dreaming skips its own proposal as a conflict rather than overwrite newer knowledge. The library is never quietly rolled back.

The default isn't "trust the machine." It's "show your work, and let a person decide" — until the work is good enough that they stop needing to.

The fleet that learns overnight

Morning starts quietly. A coordinator opens the dashboard and finds, waiting, a short account of what the agent fleet learned while the building slept. Not a log of activity — a diff of understanding. A duplicate fact, learned three separate times by three separate agents, is now proposed as one. A QA rule that two memories disagreed about is reconciled, with the transcript that settles it cited inline. A delivery note rescheduled twice, still carrying its first two reminders, is marked stale. The coordinator reads each proposed change, opens the ones worth a closer look, sees the before and after side by side, and approves selectively — change by change, the ones that have earned it, leaving the rest. It takes minutes. The fleet is measurably smarter by the time the first customer call lands.

The discipline shows on each agent's own memory page. Every fact carries a version number and a last-verified date; the revision history reads like a ledger — what changed, when, why, and which conversations proved it. A note from March is no longer trusted on faith in June; it is either re-confirmed against a real transcript or retired. Nothing in the store is older than its last proof.

Tomorrow's agents are better than yesterday's — and there is a paper trail showing exactly how.

This is the part that compounds. A live agent learning a lesson the hard way pays for it once and keeps it to itself. A fleet that consolidates overnight pays once and shares the lesson with everyone — the failure one agent hit on Tuesday is a memory the whole fleet carries by Wednesday. The gains amortize across the entire roster, and they accrue. Each curated night raises the floor the next day starts from. That is what resilience actually looks like: not a system that never stumbles, but a system whose stumbles become collective knowledge faster than they can recur. An ark is not the boat that avoids the flood; it is the one built to carry everything forward through it, and to arrive heavier with what it learned.

The transferable lesson is narrower than the metaphor, and more useful. A memory process must be as disciplined as it is clever. The cleverness — finding the pattern across sixty transcripts no single agent could see — is the easy half to admire and the dangerous half to trust alone. The discipline is what makes it safe to run unattended: references, not faith; a ledger, not a silent overwrite; fresher knowledge always winning over the batch; and review before autonomy, every time, until the diffs have earned the right to apply themselves. Build the cleverness if you can. But ship the discipline first.