MeasuredBenchmarks · every script named
Every number. Losses included.
What Chronos DB does fast, what it does slowly, and against whom. Each figure comes with the machine it ran on, the day, the build and the command that reruns it.
- 1.4 µs
- to fork a world, with 100,000 open
- 57–73×
- Postgres, 1,000 agents writing at once
- 4 of 6
- BranchBench jobs finished first
- 17
- losses on record, each one listed
- Chronos DBon disk, 64 workers
- 0.008 ms
- Dolt 2.3.5DOLT_BRANCH, 64 workers
- 24 ms
- Postgres 17a template database, 25 workers
- 2,133 ms
- SQLitea file copy, 64 workers
- 2,762 ms
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28Chronos and Dolt: two runsbuild 8db2f701Chronos and Dolt from one harness, Postgres and SQLite from the other, same machineBENCHMARKS.md §1
With one thread per agent (1,000 threads on disk) Chronos's median fork is 65–73 ms. At equal workers it is 8 µs.
Worlds
A world costs microseconds. The hundred-thousandth costs the same.
A fresh database on disk with 100,000 rows in main, then 10 to 100,000 worlds forked from it, each writing one row of its own.
100,000 worlds
- Fork, median
- 1.4 µs
- Fork, 99th percentile
- 3.5 µs
- First write, median
- 8.2 µs
- On disk, a world
- 564 B
- Memory added
- 103 MB
- Point query, main / world
- 23 / 21 µs
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28queries are averages of 20 runsBENCHMARKS.md §9
1.4µs
to fork a world, with 100,000 already open
The median. With 10 worlds open it is 2.0 µs; the 99th percentile at 100,000 is 3.5 µs.
564B
on disk for a world with one changed row
And 1.0 KB of memory. With 100,000 worlds the folder is 64.0 MB after a checkpoint; with 10 it is 7.5 MB.
23 / 21µs
a point query in main, and in one of 100,000 worlds
A query in a world is as fast as in main: a whole-table aggregate takes 5.0 and 4.8 ms.
| Worlds | Fork p50 | Fork p99 | First write p50 | Point query, main / world | Aggregate, main / world | Disk per world | Memory added | Checkpoint | Reopen |
|---|---|---|---|---|---|---|---|---|---|
| 10 | 2.0 µs | 17 µs | 8.8 µs | 16 / 15 µs | 5.1 / 4.7 ms | 503 B | 0.0 MB | 16 ms | 3 ms |
| 100 | 1.8 µs | 11 µs | 8.0 µs | 15 / 16 µs | 4.8 / 4.6 ms | 521 B | 0.0 MB | 18 ms | 3 ms |
| 1,000 | 1.7 µs | 7 µs | 7.9 µs | 21 / 14 µs | 4.8 / 4.7 ms | 551 B | 0.3 MB | 20 ms | 4 ms |
| 10,000 | 1.5 µs | 3.5 µs | 8.1 µs | 21 / 21 µs | 4.8 / 4.7 ms | 557 B | 1.4 MB | 72 ms | 14 ms |
| 100,000 | 1.4 µs | 3.5 µs | 8.2 µs | 23 / 21 µs | 5.0 / 4.8 ms | 564 B | 103 MB | 868 ms | 166 ms |
Agents
A thousand agents writing at once. On disk, 57–73× Postgres.
Each agent forks main, writes 1,000 rows and merges back, over 100,000 seed rows. Chronos runs in process; the others through their usual clients, on the same machine.
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two rounds eachbuild main with #23 and #29the Dolt runs are of build 8db2f701's day and weren't repeatedBENCHMARKS.md §1
57–73×
Postgres 17, with 1,000 agents, on disk
554k–716k rows a second against 9.8k. Before two fixes of that week (#23 and #29) it was 21–55×.
25×
Dolt 2.3.5, at 64 workers each
713k–716k rows a second against 28.3k–28.4k. Measured together, before those fixes, it was 16×.
1.40s
for all 1,000 agents, at 64 workers
A million rows forked, written and merged, with a log and an fsync on every merge into main. In memory: 0.68 s.
| Agents | System | Fork p50 | Merge p50 | Total time |
|---|---|---|---|---|
| 10 | Chronos (memory) | 0.009 ms | 3.4 ms | 0.01 s |
| 10 | SQLite (file copy) | 6.3 ms | 190 ms | 0.79 s |
| 10 | Postgres 17 (template DB) | 3,553 ms | 68 ms | 4.1 s |
| 100 | Chronos (memory) | 0.009 ms | 33 ms | 0.07 s |
| 100 | SQLite | 16 ms | 1,064 ms | 10.0 s |
| 100 | Postgres 17 | 2,169 ms | 127 ms | 11.2 s |
| 1,000 | Chronos (memory) | 0.005 ms | 322 ms | 0.77 s |
| 1,000 | SQLite | 2,762 ms | 3,113 ms | 404 s |
| 1,000 | Postgres 17 | 2,133 ms | 128 ms | 102 s |
BranchBench
Six jobs agents do. Fastest in four, right in all six.
BranchBench is the Columbia DAP Lab’s benchmark of branching databases. The Chronos adapter and these runs are ours: five warehouses, 2.6 million rows, a two-hour cap, one run each.
An independent benchmark from Columbia University. Each job copies the database, changes the copies, merges or throws them away, and checks the data is right after every step. Shorter bar: finished sooner.
Training an AI
256 attempts, each in its own copy, each started from a saved point.
- Chronos
- 994 s
- Postgresa copy per agent
- 2,529 s
- Doltgresgit for data
- over 2 hours· ran out of time
Trying ideas
Draft changes in copies, undo the bad ones, catch up with main.
- Chronos
- 2.0 s
- Postgresa copy per agent
- 53 s
- Doltgresgit for data
- 13 s
Many agents, one database
512 changes from agents merged into a main that keeps changing.
- Chronos
- 4.7 s
- Postgresa copy per agent
- 149 s
- Doltgresgit for data
- 19 s
A coding agent
Keeps its copy current with a busy main, through a schema clash.
- Chronos
- 580 s
- Postgresa copy per agent
- 4,987 s
- Doltgresgit for data
- 563 s
A bad deploy
Investigate in copies, then put the database back as it was.
- Chronos
- 505 s
- Postgresa copy per agent
- 1,817 s
- Doltgresgit for data
- 634 s
Loading data
32 batches merged in, some of them rolled back.
- Chronos
- 2,221 s
- Postgresa copy per agent
- 2,817 s
- Doltgresgit for data
- 1,493 s· half its data checks failed
GCP c2d-standard-16 · 16 vCPUs · 62 GB2026-10-25one run eachbuild main with #257 and #260Postgres 18.6 and Doltgres 1.4.0 from the run of 2026-10-24BENCHMARKS.md §16.1
10.4s
to put the database back after the bad deploy
One RESTORE WORLD … TO the commit's moment. Postgres copies took 195 s (drop and clone again); Doltgres 208 s.
| Operation | Chronos DB |
|---|---|
| Branch from main | 0 ms |
| Branch from a commit 1–128 commits back | 4–8 ms |
| Commit, 1–10,000 rows written | 1–3 ms |
| Merge 1 / 1,000 / 10,000 rows | 1 / 10 / 94 ms |
| Diff of 1,000 / 10,000 rows | 1.8 / 14 ms |
| Revert 1,000 / 10,000 rows | 23 / 120 ms |
| Reset, undoing 1 / 10,000 rows | 7 / 33 ms |
| Delete a branch, any size | 0–2 ms |
SQL
Level with Postgres on rows. Behind it, core for core, on reports.
Over the Postgres protocol, both on one machine, both flushing every commit to disk.
| Workload | Chronos | Postgres 17 | What ran |
|---|---|---|---|
| Single-row commits | 2,395–2,543 /s | 2,286–2,320 /s | 10,000 inserts, each its own commit |
| Batched rows | 290k–297k /s | 222k–223k /s | 1,000-row statements |
| Lookup by key, p50 | 46–48 µs | 46 µs | 10,000 lookups; p99 62–63 µs against 63–66 µs |
| Update by key, p50 | 0.41–0.42 ms | 0.43–0.46 ms | 1,000 updates |
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two roundsbuild 0f1a19afBENCHMARKS.md §4
Five reports, three releases. Give it cores and watch the bars.
Chronos on
count(*) of orders
Postgres 4.3 msChronos ahead
count(*) where amount > 500
Postgres 4.8 msPostgres ahead
group by age, count(*), max(name)
Postgres 16.3 msChronos ahead
join both tables, group by, sum
Postgres 29.8 msPostgres ahead
join where name like 'user 1%'
Postgres 18.0 msPostgres ahead
On the same two cores it is slower on three (the filtered count 1.1×, join + group by 1.4×, join + like 1.3×) and ahead on the plain count (1.4×) and group by (1.6×).
Apple M2 laptop · 8 cores · 8 GB2026-11-16best of 3 runsbuild 0.5.2, 0.5.3, 0.5.4Postgres 18.7 in Docker, at its defaultsBENCHMARKS.md §4
0.5.3 changed the joins and 0.5.4 the scans: the filtered count is 25% faster, GROUP BY 23% on one core and 37% on two, the joins 20%. How rows are stored didn't change.
| Query | Chronos | Postgres 16 | DuckDB, 32 threads |
|---|---|---|---|
| count(*) of orders | 2.7–2.8 | 6.8–7.0 | 0.4 |
| count(*) where amount > 500 | 4.0–4.1 | 8.8–8.9 | 0.6–0.7 |
| group by age, count(*), max(name) | 9.5–9.9 | 19.5–19.6 | 4.4 |
| join both tables, group by, sum | 25.4–25.7 | 67.0–69.5 | 7.2–7.7 |
| join where name like 'user 1%' | 18.3–18.5 | 43.8–44.4 | 7.1–8.3 |
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two runs; DuckDB best of 3 rounds of 5build 0f1a19afBENCHMARKS.md §4
| Query | 0.5.2 | 0.5.4 | Postgres 18, 2 cores |
|---|---|---|---|
| Q3 | 187 ms | 88 ms | 64 ms |
| Q18 | 598 ms | 137 ms | 226 ms |
Apple M2 laptop · 8 cores · 8 GB2026-11-16best of 3 runsbuild 0.5.2 to 0.5.4BENCHMARKS.md §16.2
| Statement | Before | After |
|---|---|---|
| Correlated EXISTS, 15,000 outer rows | 169 s | 0.17 s |
| DELETE with that EXISTS | 167 s | 0.25 s |
| Correlated NOT EXISTS | 173 s | 0.21 s |
| id IN (a join on lower(email)) | over 450 s | 0.26 s |
| company IN (15,000 values) | 27.4 s | 0.22 s |
| EXISTS on an indexed column | 330 s | 0.77 s |
GCP e2-standard-4 · 4 vCPUs · 16 GB2026-10-02one run eachbuild b8624047 to c7f90ddaBENCHMARKS.md §4
Vectors
Fast, without giving up recall. Speed alone flatters whoever finds less.
999,500 real OpenAI embeddings of 1,536 dimensions, the top 10, one client, eleven systems, each at its defaults and each run alone.
Searching
| # | System | p50 | Recall@10 |
|---|---|---|---|
| 2 | Redis 8.10 | 0.50 ms | 74.2% |
| 1 | Chronos DB | 1.34 ms | 98.6% |
| 3 | Chroma 1.5.9 | 2.25 ms | 96.8% |
| 4 | pgvector 0.8.6 | 2.40 ms | 92.8% |
| 5 | Weaviate 1.39.7 | 2.48 ms | 98.2% |
| 6 | LanceDB 0.39 | 3.43 ms | 85.0% |
| 7 | Elasticsearch 9.5.4 | 3.56 ms | 94.9% |
| 8 | Milvus 3.0.1 | 3.92 ms | 97.3% |
| 9 | Qdrant 1.19.1 | 6.67 ms | 99.0% |
| 10 | pgvectorscale 0.9.1 | 8.33 ms | 96.6% |
| 11 | OpenSearch 3.8.0 | 10.06 ms | 98.5% |
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28 and 29each system alone, its server started freshBENCHMARKS.md §6
1.34ms
the median search of every row, at 98.6% recall
The fastest of every system that finds more than 75% of the true top 10. Only Redis is faster, at 74.2%; only Qdrant finds more (99.0%), in 6.67 ms.
1.19ms
filtered to one user’s rows, at 100% recall
The fastest of all eleven. Elasticsearch takes 3.47 ms at 61.3% recall, Milvus 3.89 ms at 99.7%.
3.1GB
held by the server after the run
7.7 GB at its peak, while the index builds. Milvus 5.2 GB, Qdrant 6.6 GB, Weaviate 11.9 GB, Redis 13.2 GB.
| Search | Chronos | Postgres 17.11 + pgvector 0.8.7 |
|---|---|---|
| DBpedia, 1,536 dimensions, cosine | 1.29 ms · 3,675 q/s · 98.5% | 7.44 ms · 724 q/s · 98.7% |
| Synthetic 768, cosine (pgvector never reached 99.8%) | 0.87 ms · 4,700 q/s · 99.8% | 3.76 ms · 1,211 q/s · 98.2% |
| Filtered to 1% of rows | 1.33 ms · 3,248 q/s · 100% | 40.3 ms · 168 q/s · 100% |
| Filtered to 10% of rows | 2.16 ms · 1,003 q/s · 100% | 211 ms · 19 q/s · 100% |
| Filtered to 50% of rows | 2.02 ms · 902 q/s · 99.96% | 3.90 ms · 1,289 q/s · 98.3% |
| Building the index, DBpedia | 94 s | 349 s |
GCP c2d-standard-16 · 16 vCPUs · 62 GB2026-10-171,000 held-out queries, one system at a timebuild 141013fBENCHMARKS.md §2
Undo
100,000 changes by an agent, undone in 1.47 seconds.
500,000 rows in main. An agent changes 100,000 of them straight in main, with no world and no approval. Then a person changes 50,000 other rows, and 100 of the agent’s.
1.47s
UNDO AGENT bot SINCE … SKIP CHANGED
99,900 rows put back, 100 left as the person changed them. None of the agent's values remain, and all 50,100 of the person's changes are kept.
changed by the agentput backkept: a person changed it since
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28runs not statedBENCHMARKS.md §7
| Step | 32 cores | On the 8 GB M2 laptop |
|---|---|---|
| Load 500,000 rows | 3.1 s | 12.0 s |
| The agent’s 100,000 changes | 1.0 s | 12.6 s |
| UNDO AGENT bot SINCE … SKIP CHANGED | 1.47 s | 6.2 s |
Scale
300,000 worlds, one search. 4 minutes 40 seconds.
A supply-chain optimization. Fork 100,000 worlds from main, give each its own reorder policy, simulate it in SQL inside the world, keep the best 1%, fork 100 children from each winner. Three rounds, then the winner is merged into main.
| Round | Worlds | Alive after | Fork them all | Simulate | Score | Discard the rest |
|---|---|---|---|---|---|---|
| 1 | 100,000 | 1,000 | 729 ms | 50.0 s | 14.3 s | 0.31 s |
| 2 | 100,000 | 1,175 | 851 ms | 70.6 s | 23.1 s | 0.51 s |
| 3 | 100,000 | 1,055 | 886 ms | 84.6 s | 31.6 s | 0.69 s |
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28runs not statedBENCHMARKS.md §10
49,402
worlds made and discarded by a tree search
Monte Carlo Tree Search playing Connect Four, every node a world: 0.84 ms an iteration, at most 230 worlds alive, 20 MB. It won 20 of 20 against a random player, which is a weak opponent.
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-2820 seeded gamesBENCHMARKS.md §11
0.30s
to discard 99,000 of 100,000 worlds, in one call
3.0 µs each; one by one, 0.35 s. Before the fix it took 54.8 s on a 4-vCPU VM.
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28runs not statedbuild 8db2f701BENCHMARKS.md §9
25×
a database bigger than its cache
842 MB of pages on a 32 MB cache: a lookup by key takes 0.052–0.064 ms at the median, a scan of everything about 0.7 s. The cache held to its cap; the process still reached 495 MB during scans and joins, which is to be looked into.
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two runsbuild 0f1a19afBENCHMARKS.md §12
411MB
to insert 10,000,000 rows in one statement
589.4 s, flat in memory, 1.2 GB on disk. Before the change, 3,000,000 rows took 6,811 MB.
GCP VM · 4 vCPUs · 31 GBbefore 2026-09-28, not rerunruns not statedBENCHMARKS.md §12
Correctness
5,675,180 queries with known answers. None wrong that Postgres got right.
SQLite’s sqllogictest corpus, 622 files, sent over the Postgres protocol to Chronos and to a reference Postgres 17.
99.912%
of 5,675,180 records passed
5,670,175 of them. Postgres 17 passed 5,663,585 (99.796%). Most of what fails on either is SQLite's own dialect.
8
answers differed from the corpus
Postgres 17 returned the identical answer each time. There is no record where Postgres answers right and Chronos answers wrong.
63
records fail only on Chronos
A division by zero in machine-generated expressions that Postgres folds away and never evaluates. Of the 6,653 only Postgres fails, Chronos is laxer than Postgres, not better.
GCP VM · 4 vCPUs · 32 GB2026-09-27not rerun on the 32-core machineBENCHMARKS.md §13
Killed, torn and interleaved. Nothing acknowledged was lost.
10,000 crash runs
- Recovered exactly what reached disk
- 10,000 of 10,000
- Time
- 132 s on each build
GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28each on two buildsbuild 8db2f701 and the PR buildBENCHMARKS.md §5
Crash suite
10,000 of 10,000 recover exactly the operations that reached disk
Cuts the log at random bytes, with torn-write garbage, then recovers.
Deterministic simulation
3,000 schedules of each scheduler pass
Agents, direct writes, checkpoints and cleanup, interleaved under controlled schedules.
Jepsen-style kills
60 kills, 31,397 acknowledged transfers: none lost, every balance matched the ledger
kill -9 the server during concurrent fork-and-merge bank transfers.
What the kills found first
Two real bugs before release, both fixed: money created from nothing (a merge took “both sides wrote the same value” for no conflict), and a write lost silently when the server died and restarted in milliseconds. Since the fixes: 300 more kill -9s and 108,178 confirmed transfers on the laptop, none lost.
88.98%
of the lines Postgres 16’s own regression suite expects; 66 of 219 files exactly the same (2026-10-27)
495
differential tests against a real Postgres 16, each giving the same rows or the same error class
7 of 7
real databases moved in with identical row checksums (Chinook, Northwind, Pagila, pgbench at 2M rows and others)
Chronos DB is a beta. Where it stands against Postgres 16, gap by gap: Postgres compatibility.
Your database
Beside the database you keep. Mostly round trips.
Attach copies your tables; agents work in worlds of the copy; each merge is written to your database first, in one checked transaction. Chronos Gateway runs the same engine in front of the database your product already has.
| Step | Direct | Through the pooler |
|---|---|---|
| Attach: copy 20,200 rows in one consistent read | 7.7 s | 7.9 s |
| Merge 1,000 updated rows | 1.19 s | 1.20 s |
| Merge 1,000 inserted rows | 1.19 s | 1.19 s |
| Merge 500 deleted rows | 1.13 s | 1.07 s |
| A row changed in Neon meanwhile | conflict, nothing written | conflict, nothing written |
Chronos on a GCP VM in Mumbai; Postgres 16.15 on Neon in Singapore, about 60 ms apart2026-10-17one run: orders of magnitudeBENCHMARKS.md §14
| Reads | check_reads off | On |
|---|---|---|
| 9,000 point lookups by key, per read | 40.8 µs | 38.3 µs |
| 100,000 point lookups by key, per read | 40.5 µs | 42.0 µs |
| 1,000 filtered scans, per read | 641 µs | 622 µs |
GCP c2d-standard-8 · 8 vCPUs2026-10-17one run, repeated once within 10%BENCHMARKS.md §15
Chronos Gateway. Its own overhead isn't benchmarked yet.
No table exists for what the Gateway adds to a query or a merge beside Postgres, MySQL or MongoDB, so none is shown. These are the measured figures its docs and changelog carry.
57 s → 2.7 s
Undoing a run that wrote 10,000 rows of a 20,000-row table beside Postgres
Through the gateway on an M2, before and after engine 0.5.3. The preview: 52 s to 2.8 s.
13 s · 4 s
Until another gateway leads, after kill -9 and after a clean stop
Several gateways behind one address. Requests in those seconds answer 503 with Retry-After.
about 30 s
Attaching 2.5 million rows of Postgres, one consistent read
On a test machine; one observation, the machine not recorded.
Losses
Where Chronos DB loses. All of it, with the numbers.
The table BENCHMARKS.md opens with, as it stood on 2026-11-17, and one line more from the compatibility page.
Postgres 18
Three of five reports over 200,000-row tables, Chronos held to the 2 cores Postgres had (M2, 2026-11-16)
Chronos DBfiltered count 5.4 ms, join + group by 40.5 ms, join + like 23.4 ms
Against4.8, 29.8, 18.0 ms: 1.1–1.4× faster
§4Postgres 18
All five reports, Chronos on one core against Postgres’s two (M2, 2026-11-16)
Chronos DB5.5–75.1 ms
Against4.3–29.8 ms: 1.1–2.5× faster
§4Postgres 18
CH-benCHmark Q3, one warehouse, Chronos held to 2 cores (M2, 2026-11-16)
Chronos DB88 ms (187 ms in 0.5.2)
Against64 ms
§16.2DuckDB 1.5.5
Analytics reports over 200,000-row tables (2026-09-28, not rerun)
Chronos DB2.8–25.4 ms
Against0.4–8.3 ms: 2.2–7× faster
§4Postgres 17
Merge p50, 1,000 agents on disk, one thread per agent
Chronos DB714–718 ms (1,231 ms before #23 and #29)
Against128 ms (25 workers)
§1Its own target
Vector search inside a fork, against main, 1M rows
Chronos DB1.55× main (no filter), 1.12× (text)
Againsttarget: within 1.1×
§3Its own gate
Filtered vector search at 10%, 500k × 384, against tuned pgvector
Chronos DB0.93 ms
Against1.17–1.22 ms: only 1.3×, under the 5× gate
§2Redis 8.10
Vector search median, all rows, 76k and 1M real embeddings
Chronos DB0.72–0.74 ms, 1.36 ms
Against0.46 ms, 0.50 ms, at 75.0% and 74.2% recall (Chronos: 99.98%, 98.6%)
§6Postgres 17 + pgvector 0.8.7
Filtered vector search (50% of rows), 8 clients, 1M × 768
Chronos DB902 q/s at 99.96% recall
Against1,289 q/s at 98.3% (ef_search 1,000)
§2Its own scaling
Filtered vector search (10%, 50%), 1 to 8 clients, 1M × 768
Chronos DB2.3× and 1.8× the throughput; p99 14.8 and 20.4 ms
§2
LanceDB 0.39
Loading 76k × 1,536 vectors
Chronos DB4.7 s
Against1.0 s (in its own process, from an Arrow table)
§6Weaviate, Redis
One-user (1%) vector search p99, 76k
Chronos DB2.1–2.3 ms
Against1.46 ms, 1.23 ms
§6Postgres 17
One order joined to its row by key, over the protocol
Chronos DB52 µs
Against50 µs
§4Redis, Weaviate
Server memory after the 76k run
Chronos DB1.14 GB (2.3 GB at its peak)
Against1.05 GB, 1.10 GB
§6Doltgres 1.4.0
BranchBench S4: dev worlds rebasing off a busy spine, five warehouses
Chronos DB663 s (580 s in the rerun)
Against563 s
§16Doltgres, Postgres copies
The spine’s TPC-C throughput while BranchBench’s agents work (S4)
Chronos DB28 txn/s
Against30, 73 txn/s
§16Postgres 16
pgbench-style load, same machine (October 2026; not tuned yet)
Chronos DBpoint reads at about 0.5× Postgres’s rate
Andwrites: Chronos at a fraction of Postgres’s rate
doc
The cause of the merge row is found and its fix is being built. No longer losses: CH Q18, unfiltered vector search at 1M (4.69 ms before, 1.36 ms since), and server memory at 1M real embeddings (7.7 GB before, 3.1 GB since).
Method
Same machine, same client, one job at a time.
Every rival ran on the machine Chronos ran on, driven by the same client, at its defaults unless the section says otherwise, and never tuned below them. Recall is always shown beside speed.
- GCP c2d-standard-32 · 32 vCPUs · 128 GB
- AMD EPYC 7B13, a 500 GB pd-ssd, Ubuntu 24.04. One job at a time on an otherwise idle machine.
- Most of this page: the rerun of 2026-09-28
- GCP c2d-standard-16 · 16 vCPUs · 62 GB
- AMD EPYC 7B13, pd-ssd, Ubuntu 24.04.
- BranchBench (2026-10-24 and 25) and pgvector side by side (2026-10-17)
- Apple M2 laptop · 8 cores · 8 GB
- 4 fast and 4 efficiency cores, macOS 26. Postgres 18.7 in Docker with 2 of its cores and 2 GB.
- The five reports and CH Q3 and Q18, rerun 2026-11-16 while the cloud machines were off
- GCP VM · 4 vCPUs · 32 GB
- Linux.
- sqllogictest (2026-09-27) and the bigger-than-memory statements; not rerun since
How old these are
Nothing here was measured on the current release, Chronos DB 0.6.2.
The newest runs are the five reports and CH Q3 and Q18, on 0.5.4 (2026-11-16). Most of the page is the rerun of 2026-09-28; BranchBench is 2026-10-24 and 25. Each chart says its own day and build. Numbers from different machines don't compare with each other.
One run means one run
BranchBench, the subquery fixes and the Neon write-back are single runs: read them as sizes, not as medians. The undo, the simulation and the discards don't say how many runs stand behind them. Where a figure is a range, it is the spread of its runs.
The others
Postgres 17.11, 16.15 and 18, pgvector 0.8.6 and 0.8.7, pgvectorscale 0.9.1, SQLite, Dolt 2.3.5, Doltgres 1.4.0, DuckDB 1.5.5, Qdrant 1.19.1, Chroma 1.5.9, LanceDB 0.39, Milvus 3.0.1, Weaviate 1.39.7, Elasticsearch 9.5.4, OpenSearch 3.8.0 and Redis 8.10.2.
cargo run --release --example bench -- 10 100 1000 # forks and merges; needs PostgresSWEEP=1 ROWS=100000 cargo run --release --example worlds # 10 .. 100,000 worldsN=200000 cargo run --release --example report # the five reportspython bench/vector_dbs.py [system ...] # one vector database per runROWS=500000 AGENT=100000 OTHERS=50000 cargo run --release --example undo_agentULTIMATE=1 cargo run --release --example simulate # 100,000 worlds x 3 roundsCRASH_RUNS=10000 cargo test --release --test durability crash_suiteJEPSEN_KILLS=20 cargo test --release --test jepsen -- --nocaptureThe raw output of every run, and the script that made it, are in the repository beside BENCHMARKS.md, which has every table this page was drawn from, and more.