AgentDB / Engine
Every shape of data. One engine.
The engine underneath everything AgentDB does: your rows, documents, vectors, search, and relationships in one transaction, with one history. It runs inside your software or as a server — and it can prove what it knew, when.
One engine instead of five.
Relational rows, documents, vector similarity, full-text search, and a knowledge graph — queried together, committed together, permissioned together. Nothing to wire, nothing to drift.
History is built in.
Fork the whole database like a branch, read it as of any moment, replay any past answer exactly. What-if analysis stops being a data-engineering project.
Unplug it. Nothing's lost.
Every write is journaled before it's acknowledged. We kill the machine mid-write in the blocking release gate, every merge, to prove it — the record survives; that's the whole point of it.
For the evaluating engineer.
A Rust storage engine kept like a good lab notebook: every claim below has a reproducible test behind it.
Version-chained rows, first-committer-wins conflicts, group-commit WAL with an adaptive fsync window. Committed data survives kill -9 — enforced with a real SIGKILL in the blocking release gate.
HNSW (recall ≥ 0.95 @ 10 vs flat oracle) and disk-backed DiskANN/Vamana with product quantization; BM25 full-text; hybrid blend() fuses both in one ranked query.
Zero-copy forks over a branch DAG. AS OF LSN / TIMESTAMP / BRANCH composes with JOINs and subqueries; REPLAY OF reconstructs the exact state a past run saw.
SQL with verbs SQL never had: blend(), traverse(), RELATE, AS OF, REPLAY OF, DEPLOY … REQUIRE EVAL. One language over every modality — no sidecar query DSLs.
Open it in-process like SQLite, or run agentsql-server for REST /sql, GraphQL, WebSocket commit feeds, and native MCP — all sharing one execution path.
Agent runs, model calls, prompts, evals, tool traces, and the audit chain are first-class tables — versioned, queryable, and replayable like everything else.
Pull the plug.
Nothing’s lost.
If it said saved, it’s saved — through crashes, kills, and pulled power cords. And once it’s written, nobody can quietly rewrite it.
We don’t ask you to trust that. We crash it on purpose.
- 4123insert agent_runs
- 4124update memory
- 4125insert audit_log
- 4126update vectors
- 4127commit
Durable tail latency: 20.7 ms vs 4,174 ms AgentDB p99.9 vs SQLite-FULL p99.9 (Postgres: 77.7 ms) — same durability-matched TPC-C matrix, ccx33 datacenter NVMe, 22t — SQLite pays a per-commit fsync stall; AgentDB amortises it in the group commit. Verified 2026-07-04 at c52131a.
$ cargo test -p agentsql-engine --test kill9_mid_ud_commit_059 -- --ignored
Snapshot isolation, not serializable. Bonus: committed data survives kill -9 even at sync=never — the relaxed mode. loom (3/3 models) and TSAN (0 races) are build-time proofs, not runtime features. The crash suite runs with real SIGKILL in the blocking release gate on every merge.
The audit ledger is hash-chained (BLAKE3) with signed WAL checkpoints — verify it offline with a public key. Even a stolen disk can’t rewrite history quietly.
The kill -9, recorded. Then run it yourself.
kill -9 mid-commit, reopened from the killed process's journal alone. The whole proof runs in about a second, at true speed here. The .cast file this replays is the recording itself — step 6 of the quickstart runs it in your terminal.Don’t take our word for it. Run it.
The only engine that commits a row, a vector, a document, and a graph edge in one transaction — and proves it survives kill -9.
Careful is supposed to be slow. AgentDB puts every write on disk before it says done — and still outruns the engines that don’t bother.
Durable OLTP throughput (TPC-C): 10.69× vs SQLite synchronous=FULL. Condition: durability matched — RPO=0 both sides, fsync-before-ack · datacenter NVMe (Hetzner ccx33) · 22 warehouses, 22 terminals. Verified 2026-07-04 at c52131a — every leg, including the losses, in the claims ledger.
$ cargo test -p agentsql-bench --features bench-sqlite,bench-postgres --release --test throughput_durability_matched_t3 -- --ignored --nocapture
Harness, configs, and competitor pins: github.com/meshbergio/agentdb-bench-harness
On laptop NVMe (cheap fsync) the same protocol reads 3.85× — the moat widens where fsync is real. AgentDB tpm 363,048 ±1.7% vs SQLite-FULL 33,967. Reads on the crud sweep are fastest-with-a-query-surface; bare mmap KV stores win pure point-reads by <2× while losing durable writes 30–100×.
What we don’t claim: OLAP aggregation wins (DuckDB leads there today), a vector index-build win over Qdrant (1.55–1.97× behind — a trade; we lead pgvector 2.4–3.0×), a managed cloud, or a compliance certification. What we do claim — durably, at RPO=0, reproducibly — is the table above.
Don’t take the table’s word either — book 30 minutes and pick the machine. We’ll run it in front of you.
We model-check the concurrency. We run the crash suite with real SIGKILL, in the blocking release gate, every merge. We race competitors with their durability settings matched, and publish what we lose. We crash it on purpose — that’s the kind of database this is.
Rust · loom-model-checked · TSAN-clean · real-SIGKILL gate on every merge · 12/12 TPC-C invariants · SQLite differential oracle