Write, read, traverse and scan, measured at every release.
Each figure is shown with the release it was taken at, the machine and the door it was measured through, how many workers ran at once, how busy the disks, CPU threads and memory were, where the data was served from, and how it has moved from release to release.
These figures are generated from the release record when the page is built. None is typed by hand, and a figure that no release recorded is shown as not measured, never as zero.
The four operations
Each card says what the operation does for you. The figures for it sit in the section it links to. Every figure carries the cluster that produced it: a figure from an earlier cluster keeps its own release and machine, and is not carried forward as current.
Write
Storing data: how many rows a second the cluster accepts, and how busy its disks were while it did.
Read
Getting things back by id: how many requests a second, and how many were served from memory.
Traverse
Walking relationships: how many connections a second a graph walk follows.
Scan
Reading whole columns: how many rows a second a full pass covers.
Where the four operations stand
Latest published release r11.173, 16 November 2026. Every figure on this page is read from the release record when the page is generated; none is typed.
| Operation | Now | Unit | Release |
|---|---|---|---|
| Write | 75.8 million | rows per second | r11.173, 16 November 2026 |
| Read | 14.4 million | ids per second | r11.173, 16 November 2026 |
| Traverse | 982 million | edge hops per second | r11.173, 16 November 2026 |
| Scan | 234 million | rows per second | r11.173, 16 November 2026 |
The figures come from one cluster of 2 nodes (AMD EPYC 4345P, 8 CPU cores and 16 threads on each): 4 disks at 7.6 GB/s each (30.4 GB/s together), 16 CPU cores and 32 threads in all, and memory bandwidth specification (not a measurement) of 62 GB/s per node (124 GB/s together). The figures on this page were measured on this cluster; each figure names its release.
How each figure is taken
- Concurrency. One concurrent caller per CPU thread on every node, 32 in all, a width the measuring program works out from the cluster each time. The release record does not store the width per release.
- Record size. Every figure counts 64-byte records.
- Memory. Write and scan are run with the engine's memory cache switched off, so every byte they touch goes to or comes from the disks. Traverse is run with a 1 GiB memory budget on each node.
Write: 75.8 million rows per second
Conditions: a short burst on each node, its own rows only; the disks are sampled once a second, so they read below the run's rate; no row crosses between nodes, so it is not a cluster-wide write figure.
Rows appended to the store: 8,000,000 rows a run, written by concurrent callers on both nodes, each row landing on the node that owns it. The figure is the median of three runs. A run is 512 MB and lasts a fraction of a second, and its clock stops only after the disks have confirmed every row, so this is a short burst, not a sustained rate. The disk figures below are sampled once a second over the whole phase, so they read far below the run's own rate. Each node writes the rows it owns, from callers on that node; the figure is the two nodes added together. No row crosses between nodes in this measurement, so it is not a figure for writes spread across a cluster.
Utilisation during write
Measured with 16 concurrent callers on each node.
| Resource | At this release |
|---|---|
| Disks at 95% of their ceiling or more | 0 of 4 |
| CPU threads at 95% busy or more | 0 of 32 |
| Disk throughput, all disks together | 0.88 GB/s |
| Memory bandwidth, both nodes together | see Method |
| Node | Disks, GB/s (share of the disk ceiling, GB/s) | CPU threads at 95% or more | Memory bandwidth (share of ceiling, GB/s) |
|---|---|---|---|
| Node 1 | could not judge | 0 of 16 | see Method |
| Node 2 | could not judge | 0 of 16 | see Method |
Memory bandwidth is counted per node. Per-channel bandwidth is not measured on this hardware, and CPU threads are counted, not listed one by one.
Read: 14.4 million ids per second
Conditions: the third of three passes over the same ids (cold, warm, warm again), read in batches, one 64-byte record per id.
Ids resolved and returned in batches of 256 by concurrent callers on both nodes. Each id returns one 64-byte record. The figure is the third of three passes over the same ids: cold, warm, warm again.
Utilisation during read
Measured with 32 concurrent callers across both nodes.
| Resource | At this release |
|---|---|
| Disks at 95% of their ceiling or more | 0 of 4 |
| CPU threads at 95% busy or more | 15 of 32 |
| Disk throughput, all disks together | 0.08 GB/s |
| Memory bandwidth, both nodes together | see Method |
| Node | Disks, GB/s (share of the disk ceiling, GB/s) | CPU threads at 95% or more | Memory bandwidth (share of ceiling, GB/s) |
|---|---|---|---|
| Node 1 | could not judge | 15 of 16 | see Method |
| Node 2 | could not judge | 0 of 16 | see Method |
Memory bandwidth is counted per node. Per-channel bandwidth is not measured on this hardware, and CPU threads are counted, not listed one by one.
Where the data was served from
| Level | At this release |
|---|---|
| CPU cache (first level, counted by the processor) | not recorded for this operation |
| Served from memory | 100% of this operation's reads |
| Read from disk | 0% of this operation's reads |
Each share is the fraction of this operation's reads that were served from memory or had to be read from disk, counted in the operation's own run at the release gate.
Traverse: 982 million edge hops per second
Conditions: four-hop walks from a set of seed nodes over a generated graph, with a memory budget per node that the working set fits in.
Four-hop graph walks from 20,000 seed nodes over a graph of 3,000,000 nodes and about 30 million edges, by concurrent walkers on both nodes, each node holding a 1 GiB memory budget that the walks' working set fits. Every edge followed counts as one hop.
The same walks with a memory budget smaller than the graph, so it streams from disk: 627 million edge hops per second.
Utilisation during traverse
Measured with 32 concurrent callers across both nodes.
| Resource | At this release |
|---|---|
| Disks at 95% of their ceiling or more | 0 of 4 |
| CPU threads at 95% busy or more | 29 of 32 |
| Disk throughput, all disks together | 0.16 GB/s |
| Memory bandwidth, both nodes together | see Method |
| Node | Disks, GB/s (share of the disk ceiling, GB/s) | CPU threads at 95% or more | Memory bandwidth (share of ceiling, GB/s) |
|---|---|---|---|
| Node 1 | could not judge | 14 of 16 | see Method |
| Node 2 | could not judge | 15 of 16 | see Method |
Memory bandwidth is counted per node. Per-channel bandwidth is not measured on this hardware, and CPU threads are counted, not listed one by one.
Where the data was served from
| Level | At this release |
|---|---|
| CPU cache (first level, counted by the processor) | not recorded for this operation |
| Served from memory | 100% of this operation's reads |
| Read from disk | 0% of this operation's reads |
| Companion run, memory budget smaller than the graph: from RAM | 61.5% of reads |
| Companion run: read from disk | 38.5% of reads |
Each share is the fraction of this operation's reads that were served from memory or had to be read from disk, counted in the operation's own run at the release gate. The companion run uses a memory budget smaller than the graph, so its walks reach the disks.
Scan: 234 million rows per second
Conditions: a full scan of a block of 64-byte rows with the engine's memory cache switched off, so every byte comes from the disks.
A full scan of 8,000,000 rows, 512 MB of 64-byte rows, counting the rows that match, by concurrent callers on both nodes. A scan is counted in whole scans per second, so the rate moves in steps of 0.512 GB/s; rows per second is that rate divided by 64 bytes a row.
The disks' line rate in the release record: 30.4 GB/s together, shown beside the scan's own figure. The scan is not stated as a share of that line rate.
Utilisation during scan
Measured with 32 concurrent callers across both nodes.
| Resource | At this release |
|---|---|
| Disks at 95% of their ceiling or more | 0 of 4 |
| CPU threads at 95% busy or more | 0 of 32 |
| Disk throughput, all disks together | 27.5 GB/s |
| Memory bandwidth, both nodes together | see Method |
| Node | Disks, GB/s (share of the disk ceiling, GB/s) | CPU threads at 95% or more | Memory bandwidth (share of ceiling, GB/s) |
|---|---|---|---|
| Node 1 | could not judge | 0 of 16 | see Method |
| Node 2 | could not judge | 0 of 16 | see Method |
Memory bandwidth is counted per node. Per-channel bandwidth is not measured on this hardware, and CPU threads are counted, not listed one by one.
Where the data was served from
| Level | At this release |
|---|---|
| CPU cache (first level, counted by the processor) | 94.8% of loads, during the scan |
| Memory tier (the engine's own bounded memory budget) | switched off for the scan, by design |
| Disks | 90.5% of the disk ceiling (27.5 of 30.4 GB/s) |
The cache figure and the disk share are the scan window's own. The release record keeps no per-level share of accesses for the disks, so the disk row is throughput against the ceiling, not a share of accesses.
Memory: knowledge graph and retrieval
The memory checks of release r11.173, 16 November 2026: 17 of 17 pass. Each is run by the release gate on our own synthetic test set of 2,000 documents. They say whether a capability works; they are not a comparison with any other system.
| Capability | Result |
|---|---|
| Remember a fact, then recall it by its subject, with its source | passes |
| Recall by a free-text question, not only by the exact subject | passes |
| Relate two facts with a typed link that can be followed | passes |
| Forget removes a fact: it is there before and gone after, and forgetting it twice changes nothing | passes |
| Two memory scopes that hold the same name share no facts | passes |
| Every source a recall returns is a stored record | passes |
| Every stored passage links to its document in one step | passes |
| Every citation in an answer is a stored passage | passes |
| The automated ontology is coherent: classes and relations agree | passes |
| A greeting is answered without citations | passes |
| The chat endpoint that answers from memory is served | passes |
| Two mentions of the same thing resolve to one entity | passes |
| Documents are parsed into passages | passes |
| A fresh install includes the vectors that search by meaning | passes |
| Memory verbs in the client libraries | passes |
| Memory verbs on the binary protocol | passes |
| Memory verbs over WebSocket | passes |
| Timing on our own synthetic test set of 2,000 documents | Now |
|---|---|
| Vector step of a retrieval, median, first pass | 4.53 ms |
| Graph step of a retrieval, median, first pass | 1.24 ms |
| An answer from memory, median | no figure |
Retrieval quality (how often the right passage is found with and without following the graph, and how often an answer is grounded) is also measured on every release, on the same test set. Those figures are diagnostics, not results: they are not published until they are measured on a public dataset against another system set up to answer the same questions.
Method: how to read these figures
- Memory bandwidth. Memory-bandwidth figures are being measured again on the current release.
- Door. The engine's own cluster interface, called inside the measuring program that runs on each node. No network protocol, web server or client library stands in front of it, so these are the engine's figures, not a wire's.
- Unreadable lines. 6 detail line(s) of this run's record were unreadable and are left out of the figures above.
- Unreadable lines. 6 detail line(s) of this run's record were unreadable and are left out of the figures above.
- Unreadable lines. 6 detail line(s) of this run's record were unreadable and are left out of the figures above.
- Unreadable lines. 6 detail line(s) of this run's record were unreadable and are left out of the figures above.
- Whole cluster. Each figure is taken on both nodes at once, with all of their disks, not one machine in isolation; the tables above show how busy each disk actually was.
- Measured at the release. The release gate measures each release before it is published and stops a release that falls on a row it blocks on; some rows are reported without blocking, so a published release can sit below the one before it, as the read trend shows in late September. The trend shows only published releases; 7 other measured build(s) in the record are not plotted.
- The setup changed over time. Early releases were measured with fewer concurrent callers and smaller runs, so the early part of each trend should be read with that in mind.
- A gap is a gap. A release with no figure for an operation leaves a gap in its chart. Nothing is estimated or carried forward.
- Could not judge. Where an instrument could not measure something, the page says so and why, in general terms. A zero is never printed for a value that was not measured.
- Utilisation. The release record keeps the scan's utilisation of disks, CPU threads and memory. Per-core, per-disk and per-channel detail on each node is recorded only for releases published after the release gate began to keep it; until then the page says so rather than showing a number.
- Early measurement rows. Twelve measurement rows from 13 September 2026 recorded no value, and early rows that recorded a zero cannot be told from a measurement. Neither is used here.
- Per-channel memory bandwidth and network traffic are not measured on this hardware, so neither is shown.
Generated from the release record: release_series.json 0c0338a486b3 and release_baseline.json a18555cbf9fa (the first 12 characters of each file's SHA-256). The baseline names r11.173 and is cross-checked against the series. Write, Read, Traverse and Scan: each figure equals the median of the releases the gate's record says it was taken over.