What we are building, what we measured, what it costs to run, and where it fails. Every number here is a row of the ledger.
The AI stack today has two components: the model and the harness. We build the third - one with its own state and its own learning rules. The model stays frozen and swappable; the system around it learns while it works.
AI today generates. What it cannot yet do is connect. Sapience is the connective layer: one living memory that connects your sessions to each other, your AIs to each other, you to your AIs - and, with consent, you to other people.
Most network products are worth nothing until the network shows up. Sapience is at its most useful on day one, alone - the memory and long-context reasoning now carry public leaderboard receipts. The network isn't the price of admission; it's the compounding on top.
Every number is a row of the benchmark ledger.
| Benchmark | Sapience | Against | Ledger |
|---|---|---|---|
| BABILong, qa1 to qa5 at 10M tokens, official scorer | 97.2 | 76.6, the best published entry (fine-tuned on these tasks) | row 2 |
| BABILong qa3, multi-hop, 2M to 100M tokens | 81 to 80 | no reader without the store is measurable out there | row 4 |
| Repo-Evolution, what is current in a codebase | 88 / 82 (8B reader) | Mem0 51, grep 29, notes file 25, flat retrieval 18 | row 10 |
| MuSiQue, multi-hop past the window | 43 to 28 | 19 to 0 for a truncated full-context reader | row 6 |
| When facts change (108 update probes) | 98% current | +70 points over similarity retrieval | ledger |
| Modern retrieval, built by us, official 10M cells | 86 with the store | 11.3 to 12.3 for the steelman, reading 4.9x our tokens | row 16 |
Eight more rows live in the ledger, among them the published null (a frozen model with strong retrieval ties us inside one window), the HippoRAG-2 pair at 1M, the weight-path retention numbers, and the discovery lead-time study. Each row carries n, seeds, caveats and the result 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. When a new claim lands on an entity that already carries one, the two are linked at write time and the old claim is marked superseded. At read time, retrieval walks the chain to its head, so a superseded value cannot outrank its replacement however similar it is to the question. Offline, consolidation compacts specifics into structure: fast capture, slow integration, the division complementary learning systems theory describes.
Cost is decided on the read path, so that is the part worth drawing. A query goes to the router, retrieval walks each supersession chain to its head so a stale value never reaches the model, and what arrives is a few hundred tokens of resolved evidence rather than the history. That payload stays near the same size whether the store holds a megabyte or a career, which is why accuracy and cost stay flat as stored history grows. The flatness is scale-invariance by construction, not a claim that reasoning survives a hundred million raw tokens unaided.
Six different BABILong numbers appear across our pages. Here is what each one measures, and which one is the headline.
| Number | What it measures, and its scope | Ledger | Role |
|---|---|---|---|
| 97.2 | Average of qa1 to qa5 at 10M, official scorer (97.5 is the 3-seed judge figure). At 10M only; task-adapted pipeline. | row 2 | the headline |
| 24.7 | Zero-adaptation audit: the shipped generic pipeline, no task adaptation, average at 10M (qa1 4.7 / qa2 4.3 / qa3 6.3 / qa4 45.7 / qa5 62.7); pooled 3 seeds, n=300 per task. | row 3 | published audit |
| 80.0 | qa3 (multi-hop) flat from 2M to 100M, official scorer, 3 seeds, n=300 per scale. | row 4 | the scale claim |
| 87.0 | qa3 on the official HuggingFace cells: 86 / 87 / 87 / 84 / 86 at 128K / 256K / 512K / 1M / 10M; n=100 per cell, seed 42, single seed. | row 1 | ledger only |
| 66.7 vs 34.4 | Matched-reader pair at 1M (qa3): the same frozen Sonnet 4.6 with and without Sapience, n=90 item-paired. | row 14 | the 1M pair |
| 68.9 vs 31.1 | An earlier n=45 half of that same pair (+37.8), superseded by the n=90 pooled figure. | retired list | archive only |
Two qa3 values at 10M exist on purpose: 86 in row 1 (official HuggingFace cells) and 80.0 in row 4 (generator-built corpora); same task, same scorer, different corpora. Every BABILong number here comes from a task-adapted pipeline, in the same sense that the fine-tuned entries on that leaderboard are task-trained; the 24.7 audit measures how much that adaptation contributes.
Public coding benchmarks resolve inside a single context window, so they cannot tell a system that accumulates knowledge about a codebase from one that re-derives everything per run. Repo-Evolution targets that regime directly: an agent experiences the real git history of four production repositories as ordered time-slices, then answers which value is current and which value replaced which, with gold derived mechanically from git.
| Arm | Accuracy | What it is |
|---|---|---|
| With Sapience, 671B-class reader | 88 | Each change is recorded as a supersession edge at write time, so a currency question becomes a traversal to the head of a chain. |
| With Sapience, 8B open reader | 82 | Swap in a model a hundredth the size and the margin holds: the store resolves the answer, the model transcribes it. |
| Mem0 | 51 | The leading memory tool. |
| Agentic git-grep loop | 29 | Search over the real history, the tooling a good engineer would build. |
| Running notes file | 25 | The pattern most teams actually use. |
| Flat retrieval over the full history | 18 | Write order is discarded at ingestion; similarity search cannot recover it. |
A task-level pilot, on whether the same agent makes a real code change more cheaply with an accumulated memory, has produced two single observations with a split sign and no result yet. The powered, pre-registered run reports either way. Detail on the coding results page.
Multi-hop reasoning once the evidence outgrows the window: iterative retrieval over the store declines gently while a truncated reader goes to zero. The second thing measured here is reach. The connections worth finding are the ones that never co-occurred in the literature, and an instrument built on co-occurrence cannot see those. Inside its own horizon dense retrieval recovers more than our channel does, so this is a complement to retrieval; it works in the stratum retrieval cannot enter.
The whole system runs on machines you own, with open models a hundredth the size of the largest LLMs. Reads scale with the query: a few hundred tokens of resolved evidence per answer instead of hundreds of thousands, about 1,800x cheaper per query on the licensed figure. The alternative is dumping the store into the context, which collapses as the store grows past the window (78.3 to 41.7 to 13.3 on lookup probes) while retrieval over the persistent store holds 100% from about 961x fewer tokens per answer. Latency behaves the same way: about 1.4 seconds per query against about 10 seconds for the LLM alone at 1M on a warm cache, roughly 7x, flat as history grows. The store grows with what you keep; its size costs storage, and reads stay a few hundred tokens regardless.
Matched protocol (same model, judge and items per cell), multi-seed, calibration holdouts excluded from every headline, cross-judge audits, item-paired statistics, mechanical ground truth wherever the task permits, and pre-registration with published kill conditions, reported whichever way they land. Every number traces to a result file and the script that produced it. Reproduction bundles on request.
Investor reading room: room.spnc.ai