A single-binary multimodal database.

Relational SQL, documents, vectors, full-text, graph, and git-style time-travel and branching — one engine, one transaction, one snapshot. It beats the purpose-built engines at their own benchmarks at matched durability.

The proof strip · Wave 5 + Clean Sweep · July 2026

Every modality, measured against the specialist.

Wins and losses in the same table, at the same weight. Each row carries its date and engine SHA; the ledger carries the conditions and a command you can run.

AxisVerdictFigureAgainstVerified
Durable single-row writes (RPO=0)LEADING2.6–2.8× / 6.7–10× / 5.3–6×vs RocksDB / Fjall / SQLite synchronous=FULL — every single-row write leg2026-07-12 · ac1f1dd
Embedded TPC-C at RPO=0 (single warehouse)LEADING252,045 tpmC · 3.42×vs SQLite WAL+FULL at matched RPO=0 — p99.9 65× better (24.1 vs 1,567 ms)2026-07-08 · 98d9b94
Point reads (query-surface engines)LEADING29.2× / 19.4×point reads vs SQLite / Postgres — 1.71M ops/s, fastest system with a query surface2026-07-12 · ac1f1dd
Point reads (bare mmap/LSM KV tier)BEHIND0.71–0.74×vs LMDB / Fjall zero-copy point reads — the KV tier keeps this axis2026-07-12 · ac1f1dd
Async single-row writes (relaxed durability)BEHIND0.24–0.37×vs RocksDB single-row create/update/delete at sync=false2026-07-12 · ac1f1dd
Vector ANN query (SIFT-1M, real corpus)LEADING6.8× · tiequery p50 6.8× ahead of pgvector · statistical tie with Qdrant's stable runs2026-07-09 · 87666ee
Vector index build (SIFT-1M)COMPETITIVE2.4–3.0× · 1.55–1.97× behindbuild wall-clock ahead of pgvector · Qdrant keeps the lead (1.55× same-session, 1.97× quiet-box)2026-07-09 · 787608c
Full-text BM25 ranked top-kLEADING3.8×ranked top-10 QPS @1t vs SQLite FTS5 (p50 67 µs vs 252 µs = 3.7×)2026-07-11 · dc0ad36
Graph depth-3 traversalLEADING8× / ~70×depth-3 BFS QPS @8t vs a tuned recursive CTE · p50 vs SurrealDB embedded2026-07-12 · d10413f
Ranked array top-k (tags + recency)LEADING33–80×CONTAINS + ORDER BY created_at LIMIT 10 vs Postgres GIN + btree2026-07-12 · d10413f
Unbounded array membership (full set)LEADING2.2–2.9×ahead of Postgres GIN on full-set CONTAINS at 500k docs (PK-covered postings vs GIN + heap fetch)2026-07-13 · 3ac76f33
AS-OF reads under write load (time-travel throughput)LEADING≥62×AS-OF point-read QPS at a pinned fork vs Dolt — p99 ~600–850× better (6.6–9.3 µs vs 5.6–5.7 ms)2026-07-12 · d10413f
Single-warehouse hot-row TPC-C vs no-fsync defaultsBEHIND2.32×behind SQLite WAL+NORMAL raw defaults (no fsync per commit) on one hot warehouse2026-07-08 · 98d9b94
Multi-modal atomicityUNIQUEone transactionrelational + vector + full-text + graph + audit in one commit, one snapshot2026-07-01 · e56a61f

Benchmarks run in numbered waves; the 2026-07-12 cloud re-lock put 3-run error bars on the standing ratios. The next wave re-runs the full set — verdicts may change; the dates and SHAs never do. Full conditions, caveats, and reproduction commands: the claims ledger · harness, configs, and competitor pins: the published repo.

Three doors

Three ways in. One engine.

Door 1

The AI application data layer

Vectors, full-text ranking, relations, and graph context in one snapshot-consistent query — no sync glue, no fusion-score hand-tuning across systems. Branch the corpus, re-embed, A/B recall against production, merge: the reindex treadmill becomes a database verb.

-- One snapshot: vector + BM25 + SQL predicate, fused natively
SELECT id, title,
       blend(vector => embedding <-> ?, text => bm25(body, 'refund policy'))
FROM docs WHERE region = 'EU' ORDER BY 3 DESC LIMIT 10;

-- A/B the re-embed on a branch, then make it a verb
SELECT * FROM docs AS OF BRANCH 'reembed-v3';
MERGE BRANCH 'reembed-v3' INTO 'main' ON CONFLICT SKIP;
Door 2

The accountable agent substrate

Agent runs, tool calls, decisions, and evidence are database objects in the same engine as your data — the trace is the transaction log. Replay exactly what a run saw; verify the audit chain with nothing but a public key. Built for AI that must explain itself, especially where traces cannot leave your VPC.

-- Replay exactly what a run saw, as it saw it
REPLAY OF 'run_7f3a' IN agent_runs;

-- The blake3 hash-chain, verifiable by an outside auditor
SELECT * FROM verify_audit_chain();

-- Schema time-travels too
SHOW COLUMNS FROM agent_runs AS OF LSN 4096;
Door 3

One engine for the rest

Full SQL — joins, window functions, recursive CTEs, foreign keys, CHECK, DECIMAL — at the durable-write numbers in the proof strip, in one binary with zero external dependencies. Teams arrive through doors 1–2 and discover they never needed the other five systems.

-- Plain SQL on the same data, same snapshot
SELECT region,
       sum(amount) OVER (PARTITION BY region ORDER BY day) AS running_total
FROM payments
JOIN accounts USING (account_id)
WHERE status = 'settled';
Studio — the operator layer

DataGrip-class table stakes; instruments no other console has.

A 19-panel console over the same API every client uses. Every capture below is unretouched.

AgentDB Studio Tables panel: a data grid over live tables with staged, review-before-apply edits.
DataGrip-class grid work — edits stage into a reviewable batch before anything is applied.
AgentDB Studio Branches panel: a branch diff view comparing rows between a fork and main before merge.
Fork the database, inspect the diff, MERGE — git verbs on data, in the console.
AgentDB Studio Replay Lab: a recorded agent run selected for replay, showing the statements it executed.
Pick a recorded run and replay exactly what it saw — the instrument no other console has.
AgentDB Studio Audit panel: the append-only audit log with actions, targets, and outcomes.
The hash-chained audit log, queryable and verifiable from the same surface.

Credentials never sit in browser storage: Studio exchanges your key for short-lived session tokens at connect, and never persists it. More on Studio →

Trades, stated

What it gives up. On this page, not in a footnote.

  • Async singles 0.24–0.37× of RocksDB: the price of per-commit WAL discipline vs a raw memtable append; the same discipline pays 2.6–2.8× ahead at matched RPO=0. (W2-F closed as attributed.)

    ledger row · 2026-07-12 · ac1f1dd
  • Point reads 0.71–0.74× of bare mmap KV: MVCC owned-row materialization vs zero-copy borrowing — a deliberate, permanent trade for transactional semantics.

    ledger row · 2026-07-12 · ac1f1dd
  • Vector index build 1.55–1.97× behind Qdrant at 1M: one measured lane attempt came back neutral (banked); the residual is memory latency plus Qdrant's segmented per-segment builds against our one MVCC/AS-OF-serving graph — a one-time build cost that still beats pgvector 2.4×. (R5b, closed attributed-and-stated.)

    ledger row · 2026-07-09 · 787608c
  • OLAP: an operational engine. Columnar cold tier exists; no vectorized executor; DuckDB-class analytics is out of scope by posture.

    ledger row · 2026-07-07 · 5633312
  • Array membership with non-PK projections keeps the same owned-row materialization floor as point reads (~1.3–1.4× behind Pg-GIN at 500k; PK projections lead 2.2–2.9×).

    ledger row · 2026-07-13 · 3ac76f33
  • Single-warehouse hot-row TPC-C vs no-fsync engines: 2.32× behind SQLite-NORMAL raw defaults.

    ledger row · 2026-07-08 · 98d9b94

Every number ≥3 runs with stdev, same-box, durability-matched, with in-repo reproduction rigs and published configs. If a trade closes — or a win stops being true — the ledger changes first.

Get it

One binary. Six steps: fork the database, then try to lose data.

Unpack it, mint a key, serve it, seed it — fork the whole database and query the past — then kill -9 an engine mid-commit and watch RPO=0 hold. No cluster, no sidecar, no external services — the whole database is one process, secure by default (RBAC-required keys, hashed key file).

# 1 · unpack the release tarball (early access — request a build below)
tar xzf agentdb-0.1.2-linux-x86_64.tar.gz && cd agentdb-0.1.2-linux-x86_64

# 2 · mint an API key — hashed entry lands in keys.json, plaintext prints once
KEY=$(./agentsql keygen --tenant demo --role admin --out keys.json)

# 3 · serve (durable at ./agentdb; lake/S3/PITR are env vars when you need them)
#     port 8080 taken? AGENTSQL_BIND=127.0.0.1:8081 — and change 8080 below
AGENTDB_DATA_DIR=./agentdb AGENTSQL_API_KEYS=keys.json \
  AGENTSQL_ADMIN_KEYS=$KEY ./agentsql-server >server.log 2>&1 &

# 4 · seed a table — two rows in
curl -s -X POST localhost:8080/sql -H "Authorization: Bearer $KEY" \
  -H 'content-type: application/json' \
  -d '{"sql": "CREATE TABLE runs (id BIGINT NOT NULL, note TEXT, PRIMARY KEY (id))"}'
curl -s -X POST localhost:8080/sql -H "Authorization: Bearer $KEY" \
  -H 'content-type: application/json' \
  -d "{\"sql\": \"INSERT INTO runs VALUES (1, 'first'), (2, 'second')\"}"

# 5 · now fork the whole database — no dump, no copy — and query the past
curl -s -X POST localhost:8080/admin/branch -H "Authorization: Bearer $KEY" \
  -H 'content-type: application/json' -d '{"name":"what-if","parent":"main"}'
# → {"branch":"what-if","branch_id":1,"fork_lsn":13,"parent":"main"}
#   (fork_lsn counts every write, system tables included)
curl -s -X POST localhost:8080/sql -H "Authorization: Bearer $KEY" \
  -H 'content-type: application/json' \
  -d "{\"sql\": \"SELECT count(*) FROM runs AS OF BRANCH 'what-if'\"}"
# → {"columnTypes":["i64"],"columns":["count"],"elapsed_us":123,"rows":[[2]]}
#   — a fork of your database at write 13, queryable in SQL.
#   Open Studio → Branches to watch it.

# 6 · now try to LOSE data — a real kill -9, mid-commit, in your terminal
./agentsql crashtest
# →   acked:     632   (commits acknowledged before SIGKILL)
#     recovered: 632   (rows present after reopen + WAL replay)
#     lost:      0
#     RPO=0 held: every acknowledged commit survived kill -9.
#   It SIGKILLs a scratch engine, not your server. Your acked count will
#   differ (the jittered kill lands where it lands); lost: 0 is the
#   contract, and a violation exits non-zero.

Already have an agent host? Point any MCP client at /mcp and it can query, branch, and replay over the same engine — MCP-native since June 2026, destructive admin tools preview-by-default (explicit apply to execute). Existing tooling connects too: a pg-wire front-end serves psql and Grafana directly (simple protocol, token auth shared with the HTTP custody model).

Production posture in two env vars: AGENTSQL_BOUNDS_PROFILE=bounded caps what any session can SET its limits to (10-minute statement ceiling / 10⁹ scanned rows; managed = 2 min / 10⁸ for multi-tenant), and AGENTSQL_STATEMENT_TIMEOUT_MS=30000 sets the separate, composable session default. Under a ceiling, SET statement_timeout_ms = NULL resolves to the ceiling — no escape hatch — and an unknown profile name refuses to boot. Shipped unset, the Postgres convention: nothing is bounded until you opt in.

Early access

Early access to the self-hosted binary.

The engine is a single self-hostable binary — it runs in your VPC, your data never leaves it. Tell us what you're building and we'll get you a build.

We reply within two working days. No spam — just the build and the docs.