A small team of researchers out of Google, SpaceX, Berkeley, Stanford, and Cambridge. The system below is in use in nine research labs today.
We are building continual learning for science: a system where your lab’s knowledge grows with every session, and which goes looking for complementary ideas in fields you don’t have time to read.
We find that a system with its own learning rules - a gated write path that decides what to keep, write-time supersession that revises what evidence contradicts, offline consolidation that compacts specifics into structure - beats a frozen frontier model with strong retrieval wherever facts change over time, evidence exceeds the context window, or work accumulates across sessions, and it ties elsewhere.
Our system is a shared, structured knowledge state that people and their AI sessions write into and reason over. In it, knowledge carries attribution and supersession history, so what one researcher’s system learns can reach another’s with provenance intact. We built it for science first, but its traits should carry over to other knowledge work.
Every number carries its n, seeds, and scope.
BABILong qa3 (3-hop), 4K to 100M, one canvas. Left of the break (dual-judge scoring): the same reader alone declines from 74 at 4K to 34.4 at 1M (n=90 paired), and the cross-vendor pilot ladders - Gemini 3.1 Pro, Opus 4.7, GPT-5.5 - fall the same way toward their windows (single seed, n=8-30 per cell, directional; no vendor has a clean 1M cell, and the retired attempt-pooled cells are excluded). With Sapience the band holds 83 to 87. Right of the break (official scorer, 3 seeds, n=300 per scale): 81.0 at 2M down to 79.7 at 100M, the model reading ~685 tokens per question. Beyond every frontier window no cortex-only reader is measurable. The flatness is scale-invariance by construction - the write gate bounds the payload - not a claim that reasoning survives 100M raw tokens unaided.
Learning in the age of AI mostly runs in turns: the world’s corpus trains a model, the model freezes, people use it, repeat in six to twelve months. Measured against the brain’s at least five distinguishable learning systems - episodic, semantic, procedural, motor-calibration, emotional, each with its own learning rules - that stack implements roughly two: semantic in pretraining, procedural in RLHF, plus working memory in the context window. No hippocampus, no write gate, no replay, no reconsolidation; that gap is the axis we build on. The most effective science will not just build on what a frontier model learned a year ago. Most AI-for-science efforts make a different bet: build a vertically integrated lab in one domain - pharma, materials - and let agents, in some tellings a recursive superintelligence, automate the discovery.
Two things are off with that. Science is iterative, not a single leap: a model trained on everything ever published would likely still not solve cancer or room-temperature superconductors, because the work runs on unpublished reasoning and on tests against the real world. And a system built for one lab cannot carry what one field learns into another - which is exactly where the hardest problems come unstuck. We found the size of that gap as a byproduct of building the discovery engine: across 50 documented cases where a method crossed fields, the lag between when a discovery becomes possible and when it is made runs more than a decade on average - and most of it, around 70%, is not the irreducible time to run and validate experiments, but a connection left unmade, because the knowledge that would close it sat with the wrong person, in the wrong field, often never published. That does not close by searching the literature harder - the pieces are not all in the literature. It closes when the right knowledge reaches the right person and they build on it, which is iterative and runs through people. Boolean algebra waited 83 years to reach circuit design. It still happens in the age of AI: the idea of attention, introduced in 2014, took six years to reach protein folding, in AlphaFold2 - and that connection was made inside a single company.
So we build the other thing: not a lab of our own, but a learning layer that plugs into any lab - collaborative superintelligence, we call it internally - a system with high dynamic range - the capability of frontier models with the specificity of your domain - trustworthy enough that experts hand it their reasoning and not just their conclusions. It learns from the science people are doing today, before it is published, together with them.
The premise we build on: “somewhere in a lab you’ve never heard of, someone is working on the other half of your breakthrough”. Many scientists have lived some version of it: someone they’d never heard of, in a sub-field they hadn’t searched, working on the other half of their realization (in the best cases a breakthrough), invisible to both for a long time. When researchers connect what their systems have learned, that answer reaches the person stuck on it quicker than the decade it has historically taken: when looking for ways to structurally connect research toward discoveries, we found that across 32 documented cross-domain imports, the true source had been published and surfaceable, often for more than a decade, before anyone imported it. Published sources are the half we can score against a held-out future - and even there, no retriever or frontier model reaches them. But published work is the easy half. The store also holds what never reaches a paper - the reasoning behind a claim, the dead ends nobody writes up. A system that only reads the literature cannot connect any of that. It takes people writing their working knowledge into a connectable store to find latent connections. Even where the literature does carry the knowledge, capture at the source wins on granularity and on timeliness. A paper bundles many findings and buries its negatives, while the store keeps each claim with its reasoning attached. And a paper arrives a year late through the review mill - the store captures the work the day it happened. That is the endgame we are building toward.
The loop of scientific advancements runs through people: researchers and their AI systems working on ideas together, with reality’s corrections written back into the shared record. The cross-domain row in the regime map below is the first measured step. The sealed prospective prediction set is our first public test.
Today’s AI stacks have two components: the model and the harness. We add a third, with its own state and its own learning rules. The store stays coupled to reality through the work itself: when evidence contradicts a claim, the claim gets superseded - visibly, with the correction and its provenance attached (nothing is averaged into anything). The same system runs over an 8B open model and over closed flagships and the margins barely move (section 5): the answers are resolved in the store; the language model transcribes them. The learning lives outside the model, so it accumulates across sessions and carries over when models change. It ships today as a local-first system that plugs into the coding tools people already use; the store lives on the user’s machine.
The write path
At capture, work is distilled into knowledge objects: claims with their reasoning, evidence, and provenance. Encoding is gated by prediction error - what contradicts or extends the store writes strongly; the redundant fades. The system decides what to reason over harder. When a new claim lands on an entity that already carries one, the two are linked at write time: the old claim is marked superseded, forming a chain. At read time, retrieval walks the chain to its head, so a superseded value cannot outrank its replacement no matter how similar it is to the question. Offline, consolidation compacts specifics into structure - fast capture, slow integration.
The mechanism, isolated: over the same update stream, a flat vector store returns a stale near-duplicate of the current value in 27 of 27 probes; chain head-resolution returns the current value in 36 of 36 chains, no collisions.
Supersession gets the deepest treatment here because currency is where structure is cheapest to prove beyond doubt - it is the exemplar, not the whole system. The other mechanisms carry their own evidence below: the write gate (the flat scaling line), consolidation (synthesis over the store), the structural chain-walk (state tracking at 1M), and mechanism-space matching (the discovery channel).
The design follows complementary learning systems (CLS) theory: a fast, gated episodic learner feeding a slow statistical generalizer. The mapping is mechanism-level, not metaphor:
| Brain mechanism | What it does | Sapience implementation |
|---|---|---|
| Sleep replay | The hippocampus re-fires the day’s episodes at ~20x speed, teaching cortex offline; silence the ripples and consolidation fails | Consolidation over the store; replay corpora rendered from the store for weight adaptation (section 5) |
| Memory typing | Episodic, semantic, and procedural memory are separable systems, visible in a single patient (H.M.) | Typed knowledge objects; episodic and semantic tiers with different decay |
| Consolidation gradient | Memories migrate from hippocampal dependence to cortical storage over time | Knowledge moves from raw capture to consolidated, schema-linked objects |
| Reconsolidation | A retrieved memory becomes rewritable before re-storage - update, not duplicate | Supersession edges: what replaced what, tracked at write time |
| Salience gating | The amygdala tags what is worth keeping; most of experience is deliberately not kept | The write gate. Selection is the intelligence, not a compromise |
| Pattern separation / completion | Similar episodes stored as distinct codes; whole memories retrieved from partial cues | Distinct typed objects plus hybrid associative retrieval |
| Schema-dependent consolidation | New information that fits existing structure consolidates far faster | The structured store accelerates rather than archives |
| Working memory vs. the stores | Prefrontal cortex holds a few items at high metabolic cost; the fix for its limit is routing, not enlargement | The context window is working memory; scaling it is the wrong axis |
Question under test: in which regimes does the learning system beat the strongest applicable baseline - a frozen frontier model with strong retrieval where retrieval competes, the same model alone where it cannot - and in which does it not. Each row names its baseline, the measured delta, and the control that makes it mean something.
The scaling figure at the top of the page is this question’s headline evidence; the rows below give every regime its baseline and control.
| Regime | Result | Scope and control |
|---|---|---|
| BABILong leaderboard, 10M tokens (official scorer) | #1 overall: 97.2 average across qa1 to qa5, against 76.6 for the best published entry, a model fine-tuned on these tasks; submission open on the leaderboard repo since 2026-08-26 | Our own gaming audit, published the same day: the generic pipeline with zero task adaptation scores 24.7 on the same suite (generic embedding retrieval surfaced zero gold facts on qa1/qa2; the language model is 92% correct whenever the right facts reach it), so the gap is retrieval visibility on template text, not reasoning. The qa3 ladder holds 81.0 to 79.7 from 2M to 100M under the same scorer. |
| Within-window, single-shot, static corpus | TIE with frozen frontier + strong RAG (+0.00pp held-out, p=1.0) | Pre-registered, losing condition published before the run; it came out a tie. Full post-mortem in the data room. |
| Write-order currency, synthetic (dates obscured) | +67 to 78pp over similarity retrieval (3 seeds; discordant-pair McNemar) | Steelman parity control: hand-ordered retrieval recovers parity - the structure carries exactly what similarity discards, which is write order. |
| Write-order currency, real Wikipedia revision histories | +40.4pp on current-state questions vs similarity retrieval (40 paired probes flipped in our favor, none against - McNemar design; 33 unique probes × 3 seeds, pooled) | Recall witness: the baseline held both values in all 72 dateless probes and failed only on which-is-current. The ordered baseline reaches 98% parity. Corpus construction and baseline mechanics in the notes below. |
| Cross-session, real git history (Repo-Evolution) | +30 to 65pp (question accuracy) over every store-less baseline; margin holds at an 8B model | Baselines: retrieval over the full history, an agentic git-grep loop, running notes. Gold derived mechanically from git, no LLM judge; the margin holds at an 8B model. Detail in the notes below. |
| 10M tokens | 45.0% vs 16.7% for the same model reading its maximum 1M window, and 0% when the evidence lies beyond that window (the 0% is window arithmetic: that evidence physically cannot be read) | 24 unique items × 3 seeds, holdouts excluded; abstaining scores as wrong in both arms. Against a competent hybrid RAG: accuracy tie from ~33x fewer evidence tokens. Detail in the notes below. |
| RULER variable tracking, 1M to 10M tokens stored | 24/24 at 1M; 16/16 at each of 2M, 5M and 10M | Exact-match scoring, corpora sha-pinned; the language model ingests ~260 tokens per query (the retrieved assignment chain), so the 2M-10M cells cost $0.34 total. Best-case task shape for this architecture; full suite, protocol and harness publishing this week. The structural chain-walk does the work; the claim is scoped to that mechanism, not to general capability. |
| Long-context reasoning at 1M (BABILong qa3) | +32.2pp over the same model reading the same 1M context (66.7% vs 34.4%) | Matched-model paired design, n=90 item-paired (pooled with the pre-specified extension): same frozen model, only the architecture varies. Frontier models at 1M: 0 to 31%. Number reconciliation in the notes below. |
| Multi-hop at 1M vs strong retrieval | 46.4% vs 28.6% (n=56 × 3 seeds) | Matched model and judge, leakage-clean. At 1M the win over retrieval is accuracy; at 10M it is token cost. |
| Beyond the window, real novels (NoCha) | 38.6% vs 20.1% pair accuracy (3 seeds) | Published novels rather than synthetic corpora; the beyond-window result on real literary data. |
| Multi-hop (MuSiQue), both regimes | in-window: +32 to +48 points over the same model without the store; over-window: +33 to 37pp against the same model on truncated full context | Official exact-match, no LLM judge; direction reproduces on a second model family; 5-hop is unsolved. Regime detail in the notes below. |
| Accumulation across sessions (10-session curve) | 2.2% → 98.9%, monotone in all 3 seeds (n=90/point); no-accumulation control 0% | Pre-registered; the kill condition did not fire. Coverage growth with the language model unchanged - accumulation drives this row; structure is evidenced in the currency and scale rows. Detail in the notes below. |
| Memory-tool benchmarks (LongMemEval-S; not our target) | 88.5 vs 63.2 for the leading memory layer, tuned (+25.3pp, p<1e-16) | We did not build for the memory-layer category and do not compete in it; on its own benchmark family the system clears the leading tool anyway. |
| Strongest published structured-memory system (HippoRAG-2) | 84.0% vs 15.5% on the identical 100 BABILong qa3 items at 1M | The strongest published structured-memory baseline, run on the same items; its token footprint is more than 2,500x ours. |
| Consolidation (write-time aggregation gate) | +22.8pp (95% CI [+8.1, +38.2]) over a compute-matched language-model counter on covered aggregation questions | Paper v4.3, result (3): exact distinct-counts materialized at write time; the same contrast runs -3.3pp on trend questions and is exactly neutral on single-episode controls; single reader at a single scale, synthetic instrument. Broader semantic and schema consolidation is implemented but unestablished. |
| Cross-domain reach (the co-occurrence blind spot) | Beyond dense-retrieval rank 200: 10 of 155 realized future imports recovered vs 0 for dense retrieval (p=0.002); on the stricter multi-retriever null stratum (n=120), 6 convert end-to-end where no tested retriever surfaces the source | The blind-spot design from the discovery channel below; memorization ruled out. Discovery-choice pilot (9 of 11 vs expert consensus 1 of 11) and full design in the notes below. |
Write-order, real Wikipedia histories. Recall witness: the baseline retrieved both values in all 72 dateless probes and failed purely on cannot-tell-which-is-current. Corpus construction: MediaWiki revision snapshots with revision timestamps stripped, isolating the order signal; probes carrying in-text date signal are analyzed as a separate stratum. The steelman is embarrassingly simple - same retriever, snippets re-sorted by write order - and reaches 98%, statistical parity; the global ordering it borrows by hand is what the system constructs per-entity at write time.
Repo-Evolution. Baselines are DeepSeek-V3.2 with retrieval over the full history, an agentic git-grep loop, and running notes. Gold derived mechanically from git, no LLM judge; no-memory screen 0/77.
10M tokens (internal 10M corpus, held-in cells). 24 unique items × 3 seeds (calibration-holdout items excluded). Metric: 45.0% scores answered items; over all items including abstentions it is 44.4% - the system rarely abstains, so the denominators nearly coincide. Cross-judge kappa 0.97, non-overlapping Wilson intervals. Against a competent hybrid RAG baseline: accuracy tie from ~33x fewer evidence tokens.
BABILong at 1M (paired vs full-run numbers). Matched-model paired design, n=90 item-paired (the pre-specified extension pooled with the original block): both arms are the same frozen model; only the architecture varies. Frontier models measure 0 to 31% at 1M (the 0% is Opus, whose native window sits below 1M; plotted for reference); the strongest frontier long-context measurement we hold is 64.0% at a 660K effective window (n=50, Wilson [50.1, 75.9]). The figure pools the saturated 256K-1M regime into one effective measurement: 87.0% (87 of 100, Wilson [79.0, 92.2]); the write gate makes those scales 97 to 100% identical outcomes, so they are not independent draws. This row’s 66.7% is the stricter item-paired construction against the identical model, unchanged between arms. Single seed 42 on the qa3 curve, provisional pending fresh-item replication.
Accumulation across sessions. Later questions require facts from earlier sessions. Pre-specified; the failure condition did not occur. Measures coverage growth with the language model unchanged; unstructured accumulating memory also climbs on this task, so this row evidences accumulation, and structure is evidenced by the currency and scale rows. Fictional entities, so pretraining cannot answer.
Cross-domain reach (design + discovery-choice pilot). Historical-reconstruction design: connections scored before checking whether the science later realized them; multiple independent models, memorization ruled out. Small n; value against strong baselines not yet shown; a sealed, hash-committed prospective prediction set puts this to a public test. In a pilot-scale internal set, shown the shortlist scientists faced at the time, the system also picked the eventually-winning approach 9 of 11 times (the era’s expert consensus picked it once, p=0.008) and ranked the true post-cutoff approach above the ones that failed 11 of 13 times (p<0.001, two model families); a larger pre-specified run is in progress.
MuSiQue, regime split. Over-window: Same benchmark split by regime: this row is questions whose evidence exceeds the window; the in-window split appears below. No question is counted twice. Against the same model on truncated full context; iterative retrieval holds where full-context collapses. Official exact-match, no LLM judge. In-window: +36.7 / +48.3 / +31.7 by hop count (2-, 3-, 4-hop), official exact-match, no LLM judge; direction reproduces on a second model family. 5-hop remains unsolved and we say so.
One recorded probe from the write-order row, verbatim
Q: “As of the most recent entry, what manager does Hull City A.F.C. have now? Give only the value.” · recorded update chain, 7 changes: Bruce → Phelan → Slutsky → Adkins → McCann → Arveladze → Rosenior (current)
| similarity retrieval | “Shota Arveladze.” | stale: asserts the superseded manager, one update behind |
| order-aware baseline | correct (recorded) | with the ordering supplied by hand |
| Sapience | “Rosenior” | supersession chain resolves the head |
The baseline’s retrieval window contained all seven values including the current one; it failed on which-is-current, not recall (witness logged on all 72 dateless probes; the other 27 of 99 carry in-text dates and are analyzed separately). Outputs verbatim from the logged run. The corpus is real revision histories with timestamps stripped, so order is the only signal (date-bearing probes analyzed separately) - the same pattern as the rate limit that changed or the config that replaced last quarter’s.
If the embedded explorer does not load, open it directly: the recorded runs.
The discovery channel
Genuine cross-domain discovery is structurally justified surprise: a connection valuable because it lies outside what has ever co-occurred. Every instrument the field uses projects into that blind spot: dense retrieval, lexical search, citation graphs, and a frontier model’s own associations, which can only sample from a prior. Our approach abstracts the domain away and matches in mechanism space. On LEAP, a held-out-future gold set of realized cross-domain imports built so a solve cannot be memorization, it recovers connections no co-occurrence instrument and no frontier memory reaches - reproduced across models from two vendors, replicated on a disjoint corpus - and the median source had been surfaceable for over a decade before the field connected it. In a capability-matched test, a frontier model’s only comparable reach is memorization - its solves name already-published tools on 10 of 13, while cutoff-safe rewriters floor. That is also the private-knowledge argument in measured form: a model may recall answers from the public literature, but on the unpublished frontier it has nothing to recall. At least 29 of 155 realized imports sat in a skimmable top-40 more than a year before the field made them - a floor, since these ranks use abstract-level distillation and a full-text pass can only move more targets into that corner. Within its own horizon, dense retrieval out-recovers this channel; the channel’s value is the stratum retrieval cannot enter at all. So this is a complement, not a replacement. It surfaces the connection; selection remains the open bottleneck.
Swap the model for a model roughly a hundredth the size; on version-currency questions over real repo histories, the margin holds. Four ablations separate the hypotheses.
| Ablation | Result | Reading |
|---|---|---|
| Language-model swap, 671B-class to 8B | Repo-Evolution margin holds; 26/27 identical on the largest repo | If this were prompt scaffolding, the small model would collapse. It does not, because the store resolves the answer and the language model transcribes it |
| Both-direction ablations | single-pass over the same store collapses ~90pp; same model without the store: 0% at 10M | Neither the scaffolding alone nor the model alone produces the result |
| Reasoning-tax control (AIME 2024) | 50.0% with the store vs 46.7% same engine alone (n=30) | Smoke test: no reasoning tax detected (n=30 resolves only a large one). |
| Weight-consolidation path | same material into weights: +6.01pp pooled held-out, 95% CI [+3.16, +8.87], 10 of 10 seeds, replicated on 5 fresh seeds; naive in-context injection of the same material: -8.7pp | Where knowledge helps depends on how it is delivered - a gap no harness can reach; consolidation is training-time |
Everyone has knowledge items and retrieval. What is unusual here is the controls.
Where model size stops mattering
Swap the model from a 671B-class model to an 8B open model and the coding margin holds: 26 of 27 answers identical on the largest repository, and both models clear every store-less baseline. The store resolves the answer; the language model transcribes it. Whether a smaller model is enough turns out to depend on where the capability lives: when the store resolves the answer, an 8B model suffices and the whole system runs on hardware you own; where residual reasoning stays with the model, a stronger model still buys accuracy. We report both.
The whole system runs on machines you own, with open models a hundredth of frontier size. Reads scale with the query, not the history: on our benchmark setup, a few hundred input tokens per answer from the store versus roughly 304,000 re-sent once the accumulated history exceeds the window, and at 10M tokens an accuracy tie with a competent hybrid RAG from ~33x fewer evidence tokens. Write-side cost, concretely: roughly 678 tokens written per captured fact; extraction is regex-gated and local, so no LLM reads the raw stream at ingest; reads are subsecond-class. The cost amortizes across queries; the comparison above is the multi-query regime. The alternative to reading from the store is dumping it into the context: accuracy collapses 78% to 42% to 13% as the store grows, while retrieval over the persistent store holds 100% from ~961x fewer tokens per answer (3 seeds, lookup probes). The store grows with what you keep, not what you read, and reads never scale with it: the write gate holds the retrieved payload near 685 tokens whether the store is a megabyte or a full career, and consolidation compacts specifics into structure as it accumulates. Size is a storage question, not a reasoning-cost one.
Adjacent systems improve the choosing step: which snippets to hand the model. The failures measured on this page happen earlier, at the keeping step - write order, supersession, and provenance are discarded at embedding time, and no retriever recovers what ingestion threw away. Zep’s Graphiti (arXiv 2501.13956) keeps bi-temporal edges and is the nearest prior art. The differences: here supersession is inferred from write order alone, no timestamps required (the dateless corpus above exists to prove exactly that); it is enforced as a retrieval rule rather than left to the model’s goodwill; and the controlled isolation - ordered-baseline controls, recall witnesses - does not appear in that literature. The assembled mechanisms (write-time detection, supersession-dominant ranking, head resolution) are filed across seven patent families.
Why an incumbent does not simply build this: training on users is the model business, and attribution would price it; un-learning what a model has absorbed is not an offered capability. Persistence features from the labs are single-vendor by construction - a platform tied to one model cannot be the neutral layer across all of them. And the slow part is not the code: an accumulated store, months of per-lab history with its supersession record, exists only where it was lived.
The other design point is memory in the weights: RMT- and Titans-class models internalize state in recurrent parameters. We sit deliberately at the opposite point - state outside the model, so it survives model swaps, carries provenance, and can be inspected and corrected. The two points bridge rather than compete: the consolidation path moves what has stabilized in the store toward the weights (+6.01pp replicated on matched 8B pairs, section 5), which makes the store a staging ground for what deserves to become parametric.
The mechanisms measured on this page are the tested subset of a wider filed portfolio: capture, structure, consolidation, retrieval routing, cross-domain matching, and attribution.
Matched protocol (same model, judge, items per cell), multi-seed with stochasticity on, calibration holdouts excluded from every headline, cross-judge audits (kappa 0.97 to 1.0 on cited cells), item-paired statistics (McNemar on same-question flips), mechanical ground truth instead of LLM judges wherever the task permits, and pre-registration with published kill conditions, reported whichever way they land. Every number on this page traces to a result file and the generator script that produced it; nothing is hand-entered from memory. Reproduction bundles on request.
Built with itself
Sapience’s development runs on the system itself: dozens of concurrent AI sessions across our team share one store carrying a year of history, so a session today reads decisions a session recorded in March. One entry from the store’s own log, from the day this page was finalized: when the company blurb was revised, the store detected a same-subject revision and superseded the prior version with the correction attached - without anyone needing to ask it to. And everything is stored in transcripts, reproducible on request.
Papers: Facts as First-Class Objects (arXiv 2603.17781) · Selective Memory for AI (2603.15994) · Attention Is Not Retention (2601.15313) · Attribution-Native ML (2602.11690) · Discovery by Dreaming (2607.16256) · Constraint Gain (ResearchGate) · Discovery Stack (Nature Communications, in review) · the architecture paper: doi.org/10.5281/zenodo.21894568.
In use today in seven research labs, including groups at Cambridge, CERN, and Queen Mary University of London.
Priority receipts and full methodology in the data room.
The article trail: Feb 27 · Mar 27 ("Own your Intelligence") · May 3 · Aug 5 sequel.
spnc.ai · oz@spnc.ai · deck and live walkthrough on request. · Last verified 2026-08-31 · part of the Sapience evidence set: https://spnc.ai/evidence