Storage is not learning. Most systems write a record once and read it back forever, unchanged. Emerjent changes what it knows through four explicit operations: a scheduled consolidation cycle that proposes rather than overwrites, retrieval that updates a memory's confidence, spaced review of high-stakes knowledge, and corrections that turn into rules. Each process has provenance, a deterministic write path, and a person in the approval seat. A person approves every structural change.
Four learning loops run in production, each with its own math, configuration, and guardrails that keep it from writing its mistakes into durable memory. The design is engineered from primary memory research rather than the loose sleep metaphor that most productized "background pass" features lean on, and it is honest about which parts of that research are well-supported and which are not.
Most systems store. Few learn.
A knowledge base that never revises its own confidence is a filing cabinet with a search box. It returns what you put in, ranked by how well the words match, with no opinion about whether a record is still true, whether use has confirmed it, or whether it should have aged out months ago. The cabinet does not get smarter. You do, and then you go fix the cabinet by hand.
Learning is the part the cabinet skips: the system updating its own estimate of what is worth keeping, what is decaying, and what a person keeps correcting. Emerjent treats that as a set of named processes, each with its own store, schedule, and approval path, not a single job that quietly rewrites your records overnight. Two of those processes act on the knowledge base itself. One acts on how a memory is read. One acts on the agents that draft your work. They are separated on purpose, because the failure modes are different and the guardrails have to be too.
Consolidation: a scheduled pass that proposes, never overwrites
What the cycle does
The consolidation cycle runs in three stages, then checks itself before it writes anything.
On a per-tenant schedule (the default is a nightly cycle, 3am tenant time), consolidation reviews recent activity and asks a narrow question: is there anything here worth promoting into durable memory, and anything stale worth demoting? It runs in stages. The first stage ingests the window of runs and retrievals since the last watermark. A brand-new tenant with no watermark falls back to a bounded lookback, so the first pass can never trigger an unbounded scan of all history. Candidates are deduplicated against existing memory and staged with their provenance attached.
The second stage replays across the staged candidates and existing memory, extracts patterns and candidate truths, and flags contradictions. The third stage scores each candidate against a vector of signals and promotes only the items that clear a gate. Demotion is symmetric: saturated, low-utility items lose strength in the same pass.
The gate is a function, not a vibe
The gate is a deterministic function over the candidate's signal vector, not a judgment the model renders in prose. It takes the signals and returns promote-or-not under a configuration the tenant controls, so the same configuration produces the same outcome every time and a person can read exactly why a candidate passed.
The default scores each candidate as a weighted blend of its signals and promotes anything past a single threshold. The alternative promotes a candidate that clears any k of its signals, where k = 1 is the permissive setting that keeps the long tail and k = N is the strict setting that demands agreement across the board.
The split that makes the gate trustworthy
The model proposes. A deterministic worker decides and writes.
The reasoning agent only proposes. It estimates the judgment signals a model is actually good at, like how conceptually central or how confident a candidate is, and it cites the specific activity behind each estimate. It does not decide anything. A deterministic worker enforces the gate. It computes the countable signals directly from the cited activity rather than trusting the model to count. It runs the gate, does the writes, enforces idempotency, and records every change as an append-only history entry.
The safety net
A good consolidation pass touches a small number of high-confidence items. A pass that suddenly wants to promote a large fraction of what it staged is a signal that something upstream is wrong. So the worker carries anomaly thresholds, and the gate runs before that canary check. If a pass crosses the thresholds, it pauses the cycle, writes a notification, and applies nothing. This is the load-bearing decision.
Retrieval as a learning event
For opted-in memory classes, reading a memory can change it. When a retrieval confirms that a memory was useful, or contradicts it, that outcome updates the memory's confidence. The idea comes straight from reconsolidation research: Nader, Schafe and LeDoux (2000) showed that a consolidated memory, when reactivated, briefly returns to a labile state before it restabilizes.
The opt-in is per class, not global. By default the eligible classes are research, architecture decisions, frameworks, playbooks, and client intel. Two guardrails keep this from becoming a feedback loop that eats itself. First, the history is append-only. Second, looped reads do not compound the signal: confirmation is keyed on the retrieving run, the query, and the resource together, so repeated reads count once.
Active recall: the system studies its own knowledge
Consolidation runs on a fixed schedule and does not choose what to review. Studying selects high-stakes knowledge actively. The testing effect (Roediger and Karpicke, 2006) is one of the most replicated findings in learning research: actively retrieving information produces far stronger long-term retention than re-reading it.
Emerjent schedules high-stakes memory classes for spaced rehearsal on a Leitner-style schedule. Each item's interval expands or contracts with the outcome of its last review: a clean recall doubles the interval, a partial recall nudges it out by a day, and a failed reconstruction resets it to the next day. A daily tick selects the batch due for review, capped so a backlog never floods a single day. The scheduler surfaces the batch; it does not grade it. A wrong reconstruction is treated as a signal, not an error.
Your edits are the training data
Every correction a person makes at an approval gate is Emerjent's richest learning signal. When an agent drafts something and it goes to a person for approval, what happens at that gate (kept, edited, refined, or rejected) is the cleanest available statement of what good looks like. Capturing that signal, distilling it, and turning a recurring pattern into a rule is the correction-learning loop.
Capture with an honest denominator
Every meaningful edit at an approval gate is captured as a structured event with a line-level diff. A delta gate keeps the trivia out. The denominator is the part most systems omit: an approval where the person changed nothing tells you how often the agent was already right. Counting the untouched approvals alongside the edits gives an honest edit rate.
From repeated corrections to one rule
A nightly miner pulls the non-trivial events since its last run, groups them by scope, and clusters them by embedding similarity. Once a cluster has enough corroborating events, a single reflective model call distills the pattern into one candidate rule. It adds exactly one new bullet per qualifying cluster and stops. The candidate is filed as a write intent on the same approvals surface as any other governed change. A person approves it, and can edit the wording at the gate before it ever applies.
Learned preferences never outrank governed rules. The injection order is fixed: agent instructions and skills first, then House rules (the mined, human-approved rules), then Learned house preferences (the inferred, un-approved preferences), then the task instruction and context.
Learned preferences sit below governed rules in the injection order, never above them.
The human stays the editor
Every structural change a consolidation cycle applies is logged for review. A keep-or-revert queue lists each promotion and demotion the cycle made, with the change detail and what reverting it would do. A person works the queue one decision at a time. Over time, the queue also calibrates its own trust: the system tracks how often a human keeps versus reverts each category of change, and once a category has earned a strong keep record, low-risk changes in that category can be auto-kept. This queue is the line between a system that learns and one that drifts.
Why memory research, not metaphor
The loops above are engineered from primary memory research. The testing effect is why studying is built as active retrieval. Reconsolidation is why retrieval is allowed to be a write event. The rational analysis of memory (Anderson and Schooler, 1991) is why memory strength is multi-dimensional and decay is not a flat exponential. Where the evidence is thin, the design says so and does not ship.
Built and run on a real practice
These loops run on the same practice that built Emerjent, against a live knowledge base. The architecture document that specifies these loops is itself a memory in the knowledge base: it carries a live strength vector, a retrieval count that climbs each time a session pulls it, and a spaced-review schedule. The system that describes the learning is subject to the learning it describes.