We used the math behind AI
to build a database.
The matrix operations behind every large language model — the mathematical engine driving the AI revolution — turn out to be a radically better way to store and query data. Not to generate it. Not to predict it. To retrieve exactly what’s there, with perfect accuracy, faster and cheaper than anything else on the market.
The Problem
The cost of data infrastructure
is becoming unsustainable.
Behind every enterprise data budget is a deeper crisis — power, compute, and complexity compounding faster than the value they deliver.
spend per year1
by data centers by 20302
maintain data pipelines1
that fail expectations1
Enterprise data spending has reached $29 million per year on average, with cloud compute and ingestion alone running over $500K per month at many organizations. Engineering teams spend $2.2 million a year just maintaining data pipelines. And despite all of that, 73% of enterprise data initiatives fail to meet expectations.1
Behind those budgets is a deeper problem: power. Data centers are on track to consume 9% of all US electricity by 2030 — triple what they use today.2 Power demand is growing at 15% per year.3 The industry’s own new benchmark for infrastructure value is “tokens per watt per dollar”4 — a metric that Jensen Huang formally introduced at GTC 2026.5
Every watt spent on database overhead is a watt not available for the workloads that actually generate value.
Traditional databases are a major part of this waste. They store your data and then build an equally large shadow of infrastructure around it — indexes, logs, caches, replication layers — until the system is 5 to 10 times larger than the data itself. All of that overhead consumes compute, memory, storage, and electricity. It exists because the old approach to databases requires it.
TETRA doesn’t.
The Solution
One engine. A fraction of the footprint.
TETRA’s mathematical foundation is so efficient that the complete, queryable, encrypted database is roughly the same size as the compressed raw data it was built from. There is almost no overhead. Where a traditional system wraps your data in layers of infrastructure, TETRA’s structure is the query engine. Nothing is wasted.
That efficiency cascades into every cost line:
Smaller servers. Lower cloud bills. Lower electricity. A multi-server cluster workload runs on a single standard machine.
Replaces separate systems for structured records, relationships, search, and analytics. Fewer systems, fewer teams, fewer integration points.
No indexes, logs, caches, or replication layers to maintain. The savings compound from the storage layer through the power grid.
Datacenter, edge, or a device in the field. Intelligence moves to where the data lives, without a round trip to a central server.
A workload that required a multi-server cluster — with all the licensing, staffing, cooling, and power that implies — runs on a single standard machine.
Everyone else used this math to build language models. We used it to build a database.
AI + Data
It makes AI accurate
instead of approximate.
The biggest unsolved problem in enterprise AI is accuracy. Models hallucinate. The proven fix is giving them structured knowledge to reason over — not documents to guess from.
better accuracy on complex business questions when LLMs reason over structured knowledge graphs vs. vector-only retrieval.6
The bottleneck has been the database underneath. Existing options are too slow to keep up with a model during a live query, and too heavy to deploy alongside one.
TETRA is fast enough and small enough to sit inside the AI stack itself — no separate infrastructure, no additional power draw, no added complexity. This turns AI from a tool that sometimes gets it right into a system that reasons from your actual data, every time.
And because the engine is so compact, it runs wherever the AI runs — in a datacenter, at the edge, on a device in the field. Intelligence moves to where the data lives, without a round trip to a central server and without spinning up another rack.
Timing
Why now.
The data infrastructure industry is hitting a wall. Power constraints are dictating where data centers can be built, what workloads they can run, and how much they can grow.7 Every efficiency gain at the database layer translates directly into capacity freed up for everything else.
projected by 20307
data center power3
use by 20302
TETRA doesn’t just reduce cost. It reduces the physical resources required to do the same work — at a moment when those resources are the binding constraint on the entire technology industry.
The result changes the economics of enterprise data infrastructure at exactly the moment those economics are breaking.
Sources
See TETRA in action.
Explore the technical benchmarks or talk to us about what TETRA can do for your infrastructure.
A graph data system
that runs anywhere.
We didn’t improve the graph database. We reinvented it. Sub-millisecond queries. No specialized hardware. Tiny RAM footprint.
Benchmark Report
LDBC Social Network Benchmark
SF10 · 30M nodes · 115M edges · single file · single process
What this proves
TETRA handles a production-scale social network — 30 million people and 115 million connections — on a single laptop. No cluster, no GPU, no cloud instance. The LDBC Social Network Benchmark is the industry-standard test maintained by an independent consortium. SF10 means 10× base scale. Every query completed in under 77ms.
Latency distribution · all 31 queries · p50
Counts
How fast can TETRA count 145 million elements? These queries scan metadata for every node and edge type — the foundation of dashboards, monitoring, and analytics.
| Query | P50 | P99 |
|---|---|---|
total nodes MATCH (n) RETURN count(n) | 45µs | 107µs |
total edges MATCH ()-[r]->() RETURN count(r) | 43µs | 57µs |
Person MATCH (n:Person) RETURN count(n) | 42µs | 67µs |
Comment MATCH (n:Comment) RETURN count(n) | 42µs | 82µs |
Post MATCH (n:Post) RETURN count(n) | 58µs | 80µs |
Forum MATCH (n:Forum) RETURN count(n) | 50µs | 66µs |
City MATCH (n:City) RETURN count(n) | 42µs | 93µs |
Country MATCH (n:Country) RETURN count(n) | 51µs | 61µs |
KNOWS edges MATCH ()-[r:KNOWS]->() RETURN count(r) | 43µs | 62µs |
LIKES edges MATCH ()-[r:LIKES]->() RETURN count(r) | 44µs | 56µs |
HAS_CREATOR edges MATCH ()-[r:HAS_CREATOR]->() RETURN count(r) | 41µs | 51µs |
REPLY_OF edges MATCH ()-[r:REPLY_OF]->() RETURN count(r) | 42µs | 55µs |
CONTAINER_OF edges MATCH ()-[r:CONTAINER_OF]->() RETURN count(r) | 47µs | 55µs |
IS_LOCATED_IN edges MATCH ()-[r:IS_LOCATED_IN]->() RETURN count(r) | 43µs | 55µs |
HAS_MODERATOR edges MATCH ()-[r:HAS_MODERATOR]->() RETURN count(r) | 39µs | 48µs |
HAS_MEMBER edges MATCH ()-[r:HAS_MEMBER]->() RETURN count(r) | 41µs | 81µs |
1-hop traversals
Following a single relationship across the full graph. Each query scans every node of a type and follows one edge — like asking “where does every person live?” across 30 million people.
| Query | P50 | P99 |
|---|---|---|
Person→KNOWS→Person MATCH (p:Person)-[:KNOWS]->(o:Person) RETURN count(o) | 25.5ms | 31.0ms |
Forum→CONTAINER_OF→Post MATCH (f:Forum)-[:CONTAINER_OF]->(p:Post) RETURN count(p) | 28.4ms | 30.7ms |
Forum→HAS_MODERATOR→Person MATCH (f:Forum)-[:HAS_MODERATOR]->(p:Person) RETURN count(f) | 42.5ms | 64.0ms |
Person→IS_LOCATED_IN→City MATCH (p:Person)-[:IS_LOCATED_IN]->(c:City) RETURN count(p) | 12.2ms | 12.6ms |
2-hop traversals
Chained traversals — following two relationships in sequence. The classic “friends of friends” query. These touch the most data and push the engine hardest.
| Query | P50 | P99 |
|---|---|---|
friend-of-friend count MATCH (p:Person)-[:KNOWS]->(f:Person)-[:KNOWS]->(fof:Person) RETURN count(DISTINCT fof) | 45.1ms | 46.2ms |
comment→post→creator MATCH (c:Comment)-[:REPLY_OF]->(p:Post)-[:HAS_CREATOR]->(person:Person) RETURN count(DISTINCT person) | 69.6ms | 70.9ms |
forum→post→creator MATCH (f:Forum)-[:CONTAINER_OF]->(p:Post)-[:HAS_CREATOR]->(person:Person) RETURN count(DISTINCT person) | 70.2ms | 71.8ms |
Aggregation
Top-K rankings computed on the fly — no pre-computed views. Answers questions like “who has the most connections?” or “which forum is most active?”
| Query | P50 | P99 |
|---|---|---|
top KNOWS degree MATCH (p:Person)-[:KNOWS]->(other) RETURN p.firstName, count(other) AS cnt ORDER BY cnt DESC LIMIT 10 | 20.9ms | 21.3ms |
top forum by posts MATCH (f:Forum)-[:CONTAINER_OF]->(p:Post) RETURN f.title, count(p) AS posts ORDER BY posts DESC LIMIT 10 | 19.2ms | 21.7ms |
top comment creators MATCH (c:Comment)-[:HAS_CREATOR]->(p:Person) RETURN p.firstName, count(c) AS comments ORDER BY comments DESC LIMIT 10 | 44.2ms | 45.1ms |
WITH pipeline
Complex query pipelines — filtering, aggregating, and transforming results mid-query. This is where query languages earn their keep: chaining operations without round-trips to the application layer.
| Query | P50 | P99 |
|---|---|---|
WITH + STARTS WITH filter MATCH (p:Person) WITH p WHERE p.firstName STARTS WITH 'A' RETURN p.firstName, p.lastName LIMIT 10 | 6.3ms | 6.8ms |
WITH + agg + filter MATCH (p:Person)-[:KNOWS]->(f:Person) WITH p, count(f) AS friends WHERE friends > 100 RETURN p.firstName, friends ORDER BY friends DESC LIMIT 10 | 9.9ms | 10.6ms |
WITH DISTINCT MATCH (p:Person)-[:KNOWS]->(f:Person) WITH DISTINCT f RETURN f.firstName LIMIT 20 | 14.7ms | 47.4ms |
Multi-hop
Chained patterns with deduplication and limiting — multiple joins across the full graph with result materialization.
| Query | P50 | P99 |
|---|---|---|
2-hop DISTINCT LIMIT MATCH (p:Person)-[:KNOWS]->(f:Person)-[:KNOWS]->(fof:Person) RETURN DISTINCT fof.firstName LIMIT 20 | 27.2ms | 53.2ms |
comment reply chain MATCH (c:Comment)-[:REPLY_OF]->(p:Post) RETURN count(c) | 65.1ms | 76.4ms |
Environment
engine: Tetra Graph Engine · Go · native arm64 binary · single process
storage: Single 8.7 GB file · mmap’d · ~30s cold start
hardware: Apple M4 Pro · 10 cores · 16 GB RAM · CPU only — no GPU, no cluster
protocol: Bolt v4.4 · openCypher
format: TETRAFILE v2 · LDBC SNB SF10
Tetra Graph Engine · TETRAFILE v2 · LDBC SNB SF10 · 31/31 passed
Visualization
Query. Analyze. Visualize. Innovate.
To give you maximum data utility, we built a 2D/3D graph viewer right in. Click a node, follow the connections, see what’s actually there.
Force-directed, spherical, and radial — switch on the fly
2D overhead or full 3D orbit
Six distinct platonic solids. Each node type gets its own shape and color automatically.
Click to focus — see N hops deep
Fly to any node in the graph
Pin and inspect multiple nodes at once
Performance
78 queries. 300 iterations each. Same hardware.
Recommendations dataset — 28,863 nodes, 166,261 edges. Both containerized on Apple M4 Pro, 16GB, CPU only. Native binary shown for reference.
p50 & p99 latency by query
Sorted by TETRA advantage — biggest wins top, Neo4j wins bottom
graph LR N((n)):::any -->|count| R[result]:::result
Counts & Lookups
count all nodes
MATCH (n) RETURN count(n)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A((a)):::any -->|r| B((b)):::any -->|count| R[result]:::result
Counts & Lookups
count all edges
MATCH ()-[r]->() RETURN count(r)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[movie]:::movie -->|count| R[result]:::result
Counts & Lookups
count Movie
MATCH (n:Movie) RETURN count(n)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[person]:::person -->|count| R[result]:::result
Counts & Lookups
count Person
MATCH (n:Person) RETURN count(n)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[genre]:::genre -->|count| R[result]:::result
Counts & Lookups
count Genre
MATCH (n:Genre) RETURN count(n)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[user]:::user -->|count| R[result]:::result
Counts & Lookups
count User
MATCH (n:User) RETURN count(n)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[acted_in]:::any -->|count| R[result]:::result
Counts & Lookups
count ACTED_IN
MATCH ()-[r:ACTED_IN]->() RETURN count(r)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[rated]:::any -->|count| R[result]:::result
Counts & Lookups
count RATED
MATCH ()-[r:RATED]->() RETURN count(r)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[directed]:::any -->|count| R[result]:::result
Counts & Lookups
count DIRECTED
MATCH ()-[r:DIRECTED]->() RETURN count(r)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[in_genre]:::genre -->|count| R[result]:::result
Counts & Lookups
count IN_GENRE
MATCH ()-[r:IN_GENRE]->() RETURN count(r)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[matrix]:::movie
Counts & Lookups
lookup Matrix
MATCH (m:Movie {title: 'Matrix, The'}) RETURN m.title, m.released1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[keanu]:::movie
Counts & Lookups
lookup Keanu
MATCH (p:Person {name: 'Keanu Reeves'}) RETURN p.name, p.born1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[toy story]:::movie
Counts & Lookups
lookup Toy Story
MATCH (m:Movie {title: 'Toy Story'}) RETURN m.title1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph RL P[Person]:::person -->|rel| M[Movie]:::movie
Single-Hop Traversals
actors in Matrix
MATCH (m:Movie {title: 'Matrix, The'})<-[:ACTED_IN]-(a:Person) RETURN a.name4 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR P[Person]:::person -->|ACTED_IN| M[Movie]:::movie
Single-Hop Traversals
movies by Keanu
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie) RETURN m.title33 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Single-Hop Traversals
genres of Toy Story
MATCH (m:Movie {title: 'Toy Story'})-[:IN_GENRE]->(g:Genre) RETURN g.name5 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph RL P[Person]:::person -->|rel| M[Movie]:::movie
Single-Hop Traversals
directors of Matrix
MATCH (m:Movie {title: 'Matrix, The'})<-[:DIRECTED]-(d:Person) RETURN d.name2 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR P[Person]:::person -->|ACTED_IN| M[Movie]:::movie
Single-Hop Traversals
movies by Spielberg
MATCH (d:Person {name: 'Steven Spielberg'})-[:DIRECTED]->(m:Movie) RETURN m.title30 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Single-Hop Traversals
users who rated Matrix
MATCH (m:Movie {title: 'Matrix, The'})<-[:RATED]-(u:User) RETURN count(u)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR P[Person]:::person -->|ACTED_IN| M[Movie]:::movie O[Other]:::person -->|ACTED_IN| M
Two-Hop Patterns
co-actors of Keanu
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie)<-[:ACTED_IN]-(a:Person) RETURN DISTINCT a.name LIMIT 5050 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph RL P[Person]:::person -->|rel| M[Movie]:::movie
Two-Hop Patterns
directors of Keanu movies
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie)<-[:DIRECTED]-(d:Person) RETURN DISTINCT d.name33 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Two-Hop Patterns
genres Keanu acts in
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie)-[:IN_GENRE]->(g:Genre) RETURN DISTINCT g.name14 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Two-Hop Patterns
actors same genre as Matrix
MATCH (m:Movie {title: 'Matrix, The'})-[:IN_GENRE]->(g:Genre)<-[:IN_GENRE]-(other:Movie)<-[:ACTED_IN]-(a:Person) RETURN DISTINCT a.name LIMIT 5050 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Two-Hop Patterns
users rated Keanu movies
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie)<-[:RATED]-(u:User) RETURN count(DISTINCT u)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::person -->|rel| B:::movie -->|rel| C:::person -->|rel| D:::genre
Three-Hop Chains
3-hop actor chain
MATCH (a:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m1)<-[:ACTED_IN]-(b)-[:ACTED_IN]->(m2) RETURN DISTINCT m2.title LIMIT 5050 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Three-Hop Chains
actor→movie→genre→movie
MATCH (a:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m)-[:IN_GENRE]->(g)<-[:IN_GENRE]-(rec) RETURN DISTINCT rec.title LIMIT 3030 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Three-Hop Chains
user→movie→actor→movie
MATCH (u:User {userId: '1'})-[:RATED]->(m)<-[:ACTED_IN]-(a)-[:ACTED_IN]->(rec) RETURN DISTINCT rec.title LIMIT 3030 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Aggregations
movies per genre
MATCH (m:Movie)-[:IN_GENRE]->(g:Genre) RETURN g.name, count(m) AS cnt ORDER BY cnt DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|traverse| B:::any -->|aggregate| R[result]:::result
Aggregations
top rated movies
MATCH (u:User)-[r:RATED]->(m:Movie) RETURN m.title, count(r) AS ratings ORDER BY ratings DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|traverse| B:::any -->|aggregate| R[result]:::result
Aggregations
prolific actors
MATCH (a:Person)-[:ACTED_IN]->(m:Movie) RETURN a.name, count(m) AS movies ORDER BY movies DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|traverse| B:::any -->|aggregate| R[result]:::result
Aggregations
prolific directors
MATCH (d:Person)-[:DIRECTED]->(m:Movie) RETURN d.name, count(m) AS movies ORDER BY movies DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Aggregations
avg ratings per genre
MATCH (u:User)-[r:RATED]->(m:Movie)-[:IN_GENRE]->(g:Genre) RETURN g.name, avg(r.rating) AS avg_rating ORDER BY avg_rating DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[genre popularity (count)]:::genre -->|count| R[result]:::result
Aggregations
genre popularity (count)
MATCH (u:User)-[:RATED]->(m:Movie)-[:IN_GENRE]->(g:Genre) RETURN g.name, count(u) AS popularity ORDER BY popularity DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[start]:::any -->|match| B:::any -->|WITH| C[result]:::result
WITH Pipeline
forward WITH + filter
MATCH (p:Person) WITH p WHERE p.name STARTS WITH 'Tom' RETURN p.name LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[start]:::any -->|match| B:::any -->|WITH| C[result]:::result
WITH Pipeline
forward WITH + DISTINCT
MATCH (a:Person)-[:ACTED_IN]->(m) WITH DISTINCT a RETURN a.name LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[start]:::any -->|match| B:::any -->|WITH| C[result]:::result
WITH Pipeline
WITH agg + filter
MATCH (a:Person)-[:ACTED_IN]->(m:Movie) WITH a, count(m) AS movies WHERE movies > 5 RETURN a.name, movies ORDER BY movies DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[start]:::any -->|match| B:::any -->|WITH| C[result]:::result
WITH Pipeline
WITH stage barrier
MATCH (p:Person)-[:ACTED_IN]->(m:Movie) WITH p MATCH (p)-[:DIRECTED]->(d:Movie) RETURN p.name, d.title LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[start]:::any -->|match| B:::any -->|WITH| C[result]:::result
WITH Pipeline
director's other movies
MATCH (m:Movie {title: 'Matrix, The'})<-[:DIRECTED]-(d) WITH d MATCH (d)-[:DIRECTED]->(other) RETURN other.title14 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR U[User]:::user -->|RATED| M[Movie]:::movie O[Other]:::user -->|RATED| M
WITH Pipeline
collab filter (similar)
MATCH (u:User {userId: '1'})-[:RATED]->(m:Movie)<-[:RATED]-(other:User) WITH other, count(m) AS shared WHERE shared > 3 RETURN other.name, shared ORDER BY shared DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::person -->|rel| B:::movie -->|rel| C:::genre
Multi-MATCH
MATCH+MATCH shared var
MATCH (a:Person {name: 'Keanu Reeves'}) MATCH (a)-[:ACTED_IN]->(m:Movie) RETURN m.title33 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::person -->|rel| B:::movie -->|rel| C:::genre
Multi-MATCH
MATCH+MATCH chain
MATCH (a:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m) MATCH (m)<-[:DIRECTED]-(d) RETURN d.name, m.title41 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Multi-MATCH
return both endpoints
MATCH (a:Person)-[:ACTED_IN]->(m:Movie) RETURN a.name, m.title LIMIT 3030 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Multi-MATCH
return all 3 vars
MATCH (a:Person)-[:ACTED_IN]->(m:Movie)-[:IN_GENRE]->(g:Genre) RETURN a.name, m.title, g.name LIMIT 3030 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Multi-MATCH
edge type() in RETURN
MATCH (m:Movie {title: 'Matrix, The'})<-[r]-(p) RETURN type(r), p.name265 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Multi-MATCH
whole node + prop
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie) RETURN p, m.title33 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::person -->|rel| B:::movie -->|rel| C:::genre
Multi-MATCH
3-match chain
MATCH (a:Person {name: 'Tom Hanks'}) MATCH (a)-[:ACTED_IN]->(m) MATCH (m)-[:IN_GENRE]->(g) RETURN g.name104 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Multi-MATCH
multi-pattern shared
MATCH (a:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m), (m)<-[:DIRECTED]-(d) RETURN d.name, m.title37 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[Keanu]:::person -.->|shortest| B[Tom Hanks]:::person
Exotic Patterns
shortestPath
MATCH p = shortestPath((a:Person {name: 'Tom Hanks'})-[*]-(b:Person {name: 'Kevin Bacon'})) RETURN length(p)1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -.->|OPTIONAL| D[Director?]:::person
Exotic Patterns
OPTIONAL MATCH basic
MATCH (a:Person {name: 'Keanu Reeves'}) OPTIONAL MATCH (a)-[:DIRECTED]->(m:Movie) RETURN a.name, m.title1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -.->|OPTIONAL| D[Director?]:::person
Exotic Patterns
OPTIONAL MATCH chain
MATCH (p:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m:Movie) OPTIONAL MATCH (m)<-[:DIRECTED]-(d:Person) RETURN m.title, d.name41 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -.->|OPTIONAL| D[Director?]:::person
Exotic Patterns
OPTIONAL null emit
MATCH (m:Movie {title: 'Toy Story'}) OPTIONAL MATCH (m)<-[:DIRECTED]-(d:Person) RETURN m.title, d.name1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Exotic Patterns
named path return
MATCH p = (a:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie) RETURN p33 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Exotic Patterns
edge var type()
MATCH (p:Person {name: 'Keanu Reeves'})-[r]->(m) RETURN type(r), m.title33 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Exotic Patterns
edge var props
MATCH (u:User {userId: '1'})-[r:RATED]->(m:Movie) RETURN m.title, r.rating LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Exotic Patterns
RETURN *
MATCH (p:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m:Movie) RETURN *38 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A[Node]:::person B[Node]:::movie
Exotic Patterns
cartesian 2-node
MATCH (a:Person {name: 'Keanu Reeves'}), (b:Person {name: 'Tom Hanks'}) RETURN a.name, b.name1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR P[Person]:::person -->|EXISTS?| M[Movie]:::movie
Exotic Patterns
EXISTS in WHERE
MATCH (p:Person) WHERE exists { (p)-[:DIRECTED]->() } RETURN p.name LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Exotic Patterns
OR in WHERE
MATCH (m:Movie) WHERE m.title STARTS WITH 'The' OR m.title STARTS WITH 'A ' RETURN m.title LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Exotic Patterns
count + group + order
MATCH (p:Person)-[:ACTED_IN]->(m:Movie) RETURN p.name, count(m) AS movies ORDER BY movies DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::person -->|rel| B:::movie -->|rel| C:::person -->|rel| D:::genre
Variable-Length Paths
4-hop actor chain
MATCH (a:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m1)<-[:ACTED_IN]-(b)-[:ACTED_IN]->(m2)<-[:ACTED_IN]-(c) RETURN DISTINCT c.name LIMIT 5050 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR KB[Kevin Bacon]:::person -.->|*1..2| O[Person]:::person
Variable-Length Paths
Kevin Bacon 2-degree
MATCH (kb:Person {name: 'Kevin Bacon'})-[:ACTED_IN]->(m)<-[:ACTED_IN]-(other) RETURN DISTINCT other.name LIMIT 10090 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR KB[Kevin Bacon]:::person -.->|*1..3| O[Person]:::person
Variable-Length Paths
Kevin Bacon 3-degree
MATCH (kb:Person {name: 'Kevin Bacon'})-[:ACTED_IN]->(m1)<-[:ACTED_IN]-(a)-[:ACTED_IN]->(m2)<-[:ACTED_IN]-(b) RETURN DISTINCT b.name LIMIT 100100 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR KB[Kevin Bacon]:::person -.->|*1..4| O[Person]:::person
Variable-Length Paths
Kevin Bacon 4-degree
MATCH (kb:Person {name: 'Kevin Bacon'})-[:ACTED_IN]->(m1)<-[:ACTED_IN]-(a)-[:ACTED_IN]->(m2)<-[:ACTED_IN]-(b)-[:ACTED_IN]->(m3)<-[:ACTED_IN]-(c) RETURN DISTINCT c.name LIMIT 100100 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR KB[Kevin Bacon]:::person -.->|*1..4| O[Person]:::person
Variable-Length Paths
VLP 1..4 from Keanu
MATCH (p:Person {name: 'Keanu Reeves'})-[:ACTED_IN*1..4]->(m:Movie) RETURN DISTINCT m.title LIMIT 10033 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR KB[Kevin Bacon]:::person -.->|*1..6| O[Person]:::person
Variable-Length Paths
VLP 1..6 Kevin Bacon
MATCH (kb:Person {name: 'Kevin Bacon'})-[:ACTED_IN*1..6]-(other:Person) RETURN DISTINCT other.name LIMIT 100100 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Variable-Length Paths
full genre cross-agg
MATCH (n)-[r]->(m) RETURN labels(n)[0] AS src, labels(m)[0] AS dst, type(r), count(r) ORDER BY count(r) DESC5 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR U[User]:::user -->|RATED| M[Movie]:::movie O[Other]:::user -->|RATED| M
Real App Queries
content-based recs
MATCH (u:User {userId: '1'})-[:RATED]->(m:Movie)-[:IN_GENRE]->(g:Genre)<-[:IN_GENRE]-(rec:Movie) WHERE NOT (u)-[:RATED]->(rec) RETURN DISTINCT rec.title LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR U[User]:::user -->|RATED| M[Movie]:::movie O[Other]:::user -->|RATED| M
Real App Queries
collab filter recs
MATCH (u:User {userId: '1'})-[:RATED]->(m:Movie)<-[:RATED]-(other:User)-[:RATED]->(rec:Movie) WHERE NOT (u)-[:RATED]->(rec) RETURN rec.title, count(other) AS score ORDER BY score DESC LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::any -->|query| B[result]:::result
Real App Queries
similar users
MATCH (u:User {userId: '1'})-[:RATED]->(m:Movie)<-[:RATED]-(other:User) RETURN other.name, count(m) AS shared ORDER BY shared DESC LIMIT 2020 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR P[Person]:::person -->|ACTED_IN| M[Movie]:::movie
Real App Queries
actor filmography
MATCH (a:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m:Movie) RETURN m.title, m.year ORDER BY m.year DESC38 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph RL A:::person -->|ACTED_IN| M:::movie B:::person -->|ACTED_IN| M
Real App Queries
movie detail page
MATCH (m:Movie {title: 'Matrix, The'})<-[r]-(p) RETURN type(r), p.name265 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Real App Queries
genre browse
MATCH (m:Movie)-[:IN_GENRE]->(g:Genre {name: 'Comedy'}) RETURN m.title, m.year ORDER BY m.year DESC LIMIT 5050 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie
Real App Queries
search by title prefix
MATCH (m:Movie) WHERE m.title STARTS WITH 'The' RETURN m.title LIMIT 3030 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR A:::person -->|ACTED_IN| M:::movie B:::person -->|ACTED_IN| M
Real App Queries
mutual connections
MATCH (a:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(m:Movie)<-[:ACTED_IN]-(b:Person {name: 'Laurence Fishburne'}) RETURN m.title1 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR U[User]:::user -->|RATED| M[Movie]:::movie O[Other]:::user -->|RATED| M
Real App Queries
friend-of-friend
MATCH (a:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m1)<-[:ACTED_IN]-(b)-[:ACTED_IN]->(m2) WHERE m1 <> m2 RETURN DISTINCT b.name, m2.title LIMIT 3030 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR N[yearly movie count]:::movie -->|count| R[result]:::result
Real App Queries
yearly movie count
MATCH (m:Movie) WHERE m.year > 2000 RETURN m.year, count(m) AS cnt ORDER BY m.year16 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR M[Movie]:::movie -->|IN_GENRE| G[Genre]:::genre
Real App Queries
top genres by avg rating
MATCH (u:User)-[r:RATED]->(m:Movie)-[:IN_GENRE]->(g:Genre) RETURN g.name, avg(r.rating) AS avg, count(r) AS total ORDER BY avg DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
graph LR P:::person -->|ACTED_IN| M:::movie O:::person -->|ACTED_IN| M
Real App Queries
most connected actors
MATCH (a:Person)-[:ACTED_IN]->(m:Movie)<-[:ACTED_IN]-(b:Person) WHERE a <> b RETURN a.name, count(DISTINCT b) AS connections ORDER BY connections DESC LIMIT 1010 rows · 300 iterations
Latency distribution (µs)
p50 — median
σ — std dev
p99 — worst case
Algorithms
Ask questions. Get answers on the graph.
Who’s the most connected? Where are the clusters? What’s the shortest path? Run it, see it.
Standards Compliance
No lock-in. Real Cypher.
TETRA passes all 1,611 scenarios in the openCypher TCK. So does Neo4j. Your queries work on both. Move when you want to.
Same language. Faster results.
Throughput
Concurrent scaling. Same hardware. Fair fight.
Mixed workload — queries per second as concurrent clients increase. Both containers capped at 2 CPU / 2 GB RAM on Apple M4 Pro. Native binary shown for reference.
Queries / second by concurrency level
Higher is betterContainers: 2 CPU / 2 GB RAM each · Bolt v4.4 · Mixed read workload · Recommendations dataset
Methodology
platform: Apple M4 Pro · 16 GB RAM · macOS · CPU only
environment: Both databases containerized, identical conditions
dataset: Recommendations — 28,863 nodes, 166,261 edges
queries: 78 Cypher queries across 10 categories · 300 iterations each
metric: p99 worst-case latency — lower is better · 5% tie threshold
throughput: Mixed workload, queries per second — higher is better
cypher_tck: 1,611 / 1,611 scenarios (100%)
Demo the TETRA viewer for FREE in your browser.
Explore the recommendations dataset in 3D. 2,330 nodes. 3,506 edges. Running entirely in your browser.
Launch Demo →Introductory Pricing
Questions? Schedule a call or reach out.