This is a snapshot, rewritten at each milestone. Every figure on this page carries the basis it was produced on and the platform it was taken on — measured, modelled, published, or fixed by a contract in the code. The code and its tests are the ground truth; the git history is where the reasoning lives.
Taken on our own hardware, in the run this snapshot was taken from.
Arithmetic on measured inputs. Not a measurement.
Measured by somebody else, and quoted.
Fixed by a contract in the code: a test asserts it.
These are the figures we lead with, and each one names the platform it was taken on. Where a figure is modelled rather than measured, it says so — on the figure itself, not in a footnote.
The numbers on a laptop and the numbers in the datacenter are different numbers, and these are both printed. The Linux figures come from the container and VM lanes the engine and its gate are measured in; a macOS host is where much of the engineering happens. We do not average them.
| Measurement | Linux container | macOS host | Basis |
|---|---|---|---|
| Engine AST lookup, warm | 225 ns | 196 ns | [measured] |
| Table row read | 2.2 ns | 2.2 ns | [measured] |
| get_frame | 54 ns | 29 ns | [measured] |
| VecIndex::query — 2,000 × 8 words, k=10 | 31,469 ns | 28,059 ns | [measured] |
| dispatch p50 — 1 connection | 6.9 μs | — | [measured] |
| dispatch p99 — 1 connection | 35.0 μs | — | [measured] |
| dispatch p50 — 200 connections | 6.8 μs | — | [measured] |
| dispatch p99 — 200 connections | 76–563 μs (unstable) | — | [measured] |
| 10,000-connection RSS delta | 144.1 MiB | 35.17 MiB | [measured] |
| Per-connection marginal cost | 15,113 B | 3,688 B | [measured] |
| Saturated round trips per second — 200 connections | 133,000–143,000 | — | [measured] |
A dash means the figure was not taken on that platform in this snapshot. Where we have not broken a number out, we say “not published” rather than estimate it.
The platform runs as a fleet of purpose-built machines on the unified kernel family: one service per image, Secure Boot with our own key, and identity keys minted sign-only in hardware. Each machine runs two processes — an init and its one service binary — and the fleet's whole writable storage is two volumes, the store and the model weights. Store RAM: 744 B per entry, flat across two orders of magnitude [measured]. A manifest-verified restart boots in 0.134 s [published].
Frame sizes [published]; the signed record is measured on the live store face, October 2026 [measured]. The two replays between the syncs moved 0 bytes.
943 B of session state [measured], against a published kernel TCP socket cost of 4–10 KB [published]. The platform path has no TCP anywhere — the comparison is what a general-purpose stack would pay for the same job.
~1M sessions per 2 GiB of RAM, and 1–2 M realistic agents per machine, are arithmetic on the 943-byte session — not a result. The measured per-connection cost on Linux is 15,113 B over TCP and 25,171–25,193 B over word-datagrams at 10,000 connections [measured] — the 768 B budget is unmet on both. Reaching 1M TCP connections needs roughly 12–16 GB of RAM, and the binding constraint is kernel socket buffers, not userspace: about 410 MB of the state is userland, the rest is the kernel.
A signed record of about 1 KB commits one at a time: p50 7.2–11.4 ms per write, a sustained ceiling of 89–124 writes per second, and no queue growth at 50 per second. A point read is p50 ~108 µs — reads are about 100× cheaper than writes — and a 256-record history walk is 0.5 ms. Measured on the live store face, October 2026 [measured].
Reads rotate over every face of a replica set and every reply is hash-verified before the caller sees it; writes go only to the head. At equal concurrency: 100,882 → 192,398 reads per second with three faces (1.91×), p50 226.5 → 95.3 µs. Across the whole run, 833,000 routed reads with zero errors and zero verify failures [measured, October 2026].
Every figure measured on CPU, in the production binary. Nothing on this card is modelled.
Most of what follows is a design difference, not a benchmark claim. Where a figure appears, it carries its basis — modelled means arithmetic, published means somebody else measured it.
| Row | The common approach | Tartarus |
|---|---|---|
| Agent connection cost | A kernel TCP socket costs 4–10 KB per connection [published]. | 943 B of session state [measured]. The measured per-connection cost on Linux is 15,113 B over TCP and 25,171–25,193 B over word-datagrams at 10,000 connections [measured] — over the 768 B budget on both. |
| Re-sync bytes on the wire | Changed content is re-sent on every sync, because nothing addresses the content itself. | Mesh sync moved 756 content words — 6,048 content bytes — and the two replays between the syncs moved 0 bytes [measured]. |
| Data on the wire | JSON text: 138 / 950 / 240 bytes [modeled]. | TWP words: 72 / 368 / 96 bytes [modeled]. |
| Task de-duplication and caching | The same work is repeated, because the work has no address. | Content addressing: identical content is one node. Derived views — vectors and the code graph — are deterministic functions of engine content, rebuilt on start, never stored twice. |
| Row lookup | A lookup that crosses an API boundary and re-parses what it reads. | 2.2 ns per row read — pointer arithmetic, no platform surface [measured]. |
| Read scaling | A cache layer in front of one writer, and a second writer nobody has reasoned about. | Verified read replicas: reads rotate over every face, each reply is hash-verified before the caller sees it, and writes go only to the head. 100,882 → 192,398 reads per second with three faces at equal concurrency [measured]. |
| API surface | HTTP and JSON, a version to negotiate, a schema to agree on. | No HTTP or JSON API in the platform path. An agent connects, proves who it is, and speaks TWP; an unknown message gets a typed error. |
| State after a crash | Recovered by replaying a write log. | One durable write helper, in a fixed order: write, fsync the file, rename, fsync the directory — an acknowledgement only after the last step. Proved by a syscall-order recorder and a kill matrix: six kill moments, thirty rounds, every acknowledged record present and the store reopening clean. |
| Semantic search | An embedding pipeline feeding a separate vector database. | VecIndex::query on 2,000 × 8 words, k=10: 28,059 ns on a macOS host, 31,469 ns on Linux [measured]. At the default 8,192-vector budget, a full-index query costs about 150 μs [modeled]. |
| Running compiled work | A build pipeline, a container image, and an orchestrator to place it. | Stored trees lower to code, compile, and ship as a binary named after the hash of its own bytes. Compiled work now runs as its own purpose-built machine image — one service per image, booted from an exact-content read-only image [published]. |
The modelled figures are the frame header, the admission reply, and telemetry, encoded two ways.
A page of measurements that only prints the wins is a brochure. These are the open items, measured the same way as everything else on this page.
Per-connection RAM on Linux is 15,113 B over TCP and 25,171–25,193 B over word-datagrams at 10,000 connections, against a 768 B budget — about 20–33× over, on both transports. Most of it is unaccounted for, and it is the largest unexplained number in the work.
At the measured per-connection cost, the 192 MiB budget for 10,000 connections is exhausted at 13,321 connections on Linux.
Code emission is seconds-class: p50 31 s for the 1.5B and 64 s for the 3B on CPU — and the 3B never beat the 1.5B on quality either. Size is not the lever; the corpus rebalance is.
Quantized, the smith scores 0/6 behavior-match on C while the unquantized control scores 4/6 on the same sample. Until the rebalanced generation lands, C emission stays behind the deterministic emitter.
The shaper keeps paraphrase pairs together 6 of 12 times where its teacher manages 0.833. It ties the teacher on exactness at a fraction of the size, and the teacher stays the configured default wherever consistency decides correctness.
Two things we built, measured, and then left alone. Both are published because the result is the useful part.
Four files batch into one kernel submission, and the ring path is roughly 1.5× slower: the default std path runs ~240,000–266,000 ns per checkpoint with 4 submissions, while --features io-uring runs ~350,000–400,000 ns with 1. Not ring setup — IoUring::new is ~4.4 μs. A write through the ring costs ~79 μs against ~67 μs for a direct write(2). Batching saved three kernel entries, and each batched write cost more than the four unbatched ones would have. The feature is off by default. Measured.
The store carries one durability dial on its flush path, and it stays a dial because fsync cost is a property of the storage, not of the code. Measured A/B on identical checkpoint bytes: the dial OFF is 2.14 ms per checkpoint at 4.68 M ASTs/s; ON is 3.80 ms at 2.63 M ASTs/s. The dial costs +1.67 ms, or −44% throughput. What is not negotiable is the write order itself — write, fsync the file, rename, fsync the directory, acknowledged only after the last step — proved by a syscall-order recorder and a SIGKILL crash matrix: six kill moments, thirty rounds, every acknowledged record present. Measured.
The mesh is being built in waves, and each wave is measured before the next one starts. The first wave has landed: two real stores with real fabric between them — 36 objects converged across two syncs, 756 content words, 6,048 content bytes, with the two replays between them moving 0 bytes.
Replication of the verb log — writes, not just frames — is in flight. Two things are still unmeasured and are stated as unmeasured: a real cross-machine fabric leg, and the cost of applying a batch at the replica. Until both are measured, no replica round trip is quoted as a number.
The numeric wire format is designed to become a chip specification — SmartNIC first, then FPGA, then ASIC, over a multi-year horizon. The silicon accelerates the platform data plane — the models themselves run on CPUs, and always have.
The goal is throughput per watt and a steady tail — not a smaller number on a benchmark.
This is a snapshot, rewritten at each milestone. The git history and the test suites are the ground truth. Every number is labelled measured, modelled or published, and a hypothesis handed to a worker must carry its derivation and be verified before it is acted on. Two inherited hints were wrong, and both were killed by measuring first.
Governed by the Constitution and Laws — the order of power, and the limit on each.