Bitemporal queries · Agent memory · Hash-chain audit

The graph database that
remembers.

Know what happened. Know when you learned it. Replay either, at any moment. For high-stakes businesses — and the AI agents that serve them.

Start free See live demos
2 Time axes, native
97ms 131K-row bitemporal count
18.7× Faster than last quarter
0 Overwritten rows, ever
graphiquity · drag the timeline
-- How many modifications existed at the audit,
-- according to what we knew on this date?
 
MATCH (x:Modification) AT VALID '2024-10-15' AT RECORDED '2024-10-15'
RETURN count(x)  → 197
The auditor's view at Oct 15. Drag right to see what arrived after.
Built for regulated industries
Insurance Pharma Defense Finance Energy Aerospace
This is your data

Relationships you can see.
History you can replay.

Every record, every approver, every counterparty — connected. And every edge is stamped with when we knew it. The three amber nodes? Those were filed after the audit, backdated to before. Click-and-drag a node. This is live Cytoscape, the same renderer you get in the Graphiquity console.

Backdated modifications Modifications on record Officers Accounts Audit event
Live · backdating detection
Nodes 42
Edges 58
At audit modifications: 197
Now modifications: 200
What makes it different

The time-aware
graph database.

Other graph databases are great at relationships but lose the thread of when. Graphiquity was designed for temporal queries, audit trails, and compliance from day one.

AT TIME is native Cypher.
Other graph databases require custom temporal layers, schema redesigns, and months of bespoke engineering. Graphiquity has it built in. One line.
Graphiquity — 2 lines
MATCH (e:Employee) AT '2024-06-01'
RETURN e.salary
Other graph databases — 6+ lines
MATCH (e:Employee)-[:HAD_STATE]->(s)
WHERE s.from <= date('2024-06-01')
  AND (s.to IS NULL
   OR s.to > date('2024-06-01'))
RETURN s.salary
// + schema, indexes, app code...
Two time axes. One query.
"What was true" vs "what we knew." The question regulators actually ask. Bitemporal in the query language, not bolted on after.
Graphiquity
MATCH (x:Loan)
  AT VALID '2024-10-15'
  AT RECORDED '2024-10-15'
RETURN count(x)
Others
// Not supported natively.
// Dual timestamp schema,
// custom data model, app joins
// across valid/transaction time
// = weeks of bespoke engineering.
Audit-grade by default.
Immutable hash chains, WORM mode, access logs, compliance bundles. Not a plugin. Not an add-on. The database itself is the audit trail.
Graphiquity
// Every write versioned automatically.
// Tamper-evident hash chain.
// WORM mode: immutable after commit.
// Compliance bundle: one API call.
Others
// No immutable history.
// No tamper-evident chain.
// No WORM mode.
// Audit = your problem.
A brain for your AI agents.
Vector DBs are recall. A brain has structure, time, and provenance. Replay exactly what your agent knew when it made any decision — the only graph that can.
Graphiquity
await mem.record({sessionId, type, text})
await mem.recall({query, asOf})
// Time-travel. Audit. Isolation.
// One graph per agent, scoped key.
Vector DBs (Zep, Mem0, …)
// Search engine, not a brain.
// No structure. No relationships.
// Can't replay state at a moment.
// "What did the agent know?" — nope.
Documents from your graph.
Use it like a document database. Query it like a graph. Time-travel through both. Define a template once, materialize full JSON documents with bitemporal replay. No N+1 queries.
Graphiquity
CALL db.document.project(
  'Claim', claimId, template
) AT '2024-10-15'
// One call. Full document. Any point in time.
Other graph databases
// Query the claim node.
// Query its adjuster. Query its policy.
// Query each line item. Assemble in app.
// N+1 queries. No time-travel.
Two time axes

Every fact lives on a lattice.
Not a line.

Most databases store one time: when you saved the row. Graphiquity stores two. Together they let you replay any past state — and expose facts that were backdated to look like they were there all along.

VALID When the fact was true in the real world. The loan's origination date. The policy's effective date. The trade's execution time.
RECORDED When the database learned about it. The instant the row was written. Immutable.
Deadline · Oct 15 valid = recorded Backdated → VALID TIME → RECORDED TIME → Jan Apr Jul Dec Jan Apr Oct Dec
Receipts

Audit-grade, and fast.

"Compliance-friendly" usually means "slow." Not here. 536,000 nodes. 810,000 edges. A $30/month ARM instance. Here's what a single query costs.

MATCH ... RETURN count(*)
1-hop count, 131K edges
Previous
1,813 ms
Graphiquity
97 ms
18.7× faster
MATCH (a)-[:T]->(b)-[:T]->(c)
2-hop traversal, 20K rows
Previous
3,852 ms
Graphiquity
586 ms
6.6× faster
MATCH ...-[:T*3]->...
3-hop traversal, 400K rows
Previous
7,581 ms
Graphiquity
1,392 ms
5.5× faster
// t3.medium ARM · 89 MB resident · CSR acceleration · bitemporal enabled · no warm cache
// Receipts Tested &
shipped.
969 Tests passing in CI
37 Bitemporal correctness cases
23 Hash-chain integrity cases
29 WAL crash-recovery cases
4 Layers of backup / DR
How we compare

Pick any one. We have all four.

Every other database forces a trade-off. Graphs or time. Speed or auditability. Structure or agent memory. We built one that doesn't.

Capability Graphiquity Neo4j Zep / Mem0 DuckDB + SQL
Graph-native query ✓ Cypherbuilt-in ✓ —vector-only —SQL joins
Bitemporal AT VALID / AT RECORDED ✓native Cypher ⚪via plugins — ⚪DIY
Tamper-evident hash chain ✓WORM + audit log — — —
Agent memory SDK ✓@graphiquity/memory — ✓vector recall —
Time-travel asOf recall ✓replay any state — — —
Query in Cypher, SQL, or GraphQL ✓all three + NLQ ⚪Cypher only —REST only ⚪SQL only
October 2024
October 15, 2024
Weeks later
One Cypher query
The gap you couldn't see
Now you can.
AT RECORDED 2024-10-15 197 modifications
AT RECORDED now 200 modifications
// Ask the same question, two different times the database was “the truth.” MATCH (x:Modification) AT VALID '2024-10-15' AT RECORDED '2024-10-15' RETURN count(x) → 197 // what was on record then MATCH (x:Modification) AT VALID '2024-10-15' RETURN count(x) → 200 // what the record looks like now
Live demos

Six walkthroughs. Real data.

Each demo is a full interactive investigation — dollar-for-dollar, hop-for-hop. Open one and replay a real case through time.

Anti-money laundering Follow the money. Rewind the clock. $47M laundered · 500 shell accounts · 18-month trail Open demo
Insurance fraud The fraud ring only temporal queries could catch. 47 claims · $634K exposure Open demo
Breach investigation 72 hours. 14 hops. One kill chain. 10K devices · 250K connections Open demo
Clinical trial audit What did you know, and when? 2,000 patients · 12 sites · 18 months Open demo
Supply chain recall Trace contamination across 6 supplier hops. 30K nodes · 85K edges Open demo
Digital forensics Chain of custody. Reconstructed by query. 15K nodes · 42K edges Open demo
Built on Graphiquity

One engine.
Whatever you build on it.

Graphiquity is a time-aware graph database. Treat it as a foundation — a few examples of what that foundation supports:

StaticOwl
The content platform that sees every change. A graph-native static-site CMS built on Graphiquity — dependency-aware rebuilds, Editor.js blocks, AI writing and image generation.
Visit staticowl.com Early access
Agent memory SDK
Persistent, structured, time-travel memory for AI agents. @graphiquity/memory on npm. Replay exactly what an agent knew when it acted.
Read the spec Available now
Your use case
Audit trails, investigation graphs, knowledge graphs, fraud detection, provenance, regulated record-keeping. Whatever you're modelling — temporal, relational, audit-grade — the engine's ready.
Read the docs Developer-first
Questions worth answering

The pushback, up front.

The questions smart engineers ask when they first hear "temporal graph database."

Why not just add a valid_from column to Postgres?

Because the hard part isn't storing two timestamps — it's querying them. Every bitemporal question becomes an app-level join across valid time and recorded time, with careful handling of overlaps, corrections, and supersession. Most teams get the first 10% right and silently ship the other 90% wrong.

Graphiquity puts AT VALID and AT RECORDED in the query language. One clause, one answer. Plus you get graphs.

How is this different from Neo4j plus a temporal plugin?

Plugins tack time onto a schema that doesn't know about it. That means app-level timestamp fields, custom traversal code, and no native query support — you still write the join yourself.

Graphiquity was designed bitemporal: every node and edge carries both timestamps, every snapshot is immutable, and AT VALID / AT RECORDED are first-class Cypher keywords. Plus a hash-chained audit log, WORM mode, and compliance-bundle export that Neo4j doesn't ship.

What does it cost?

Today: design partners run free (see below). Once we're charging, we'll price per graph and per reserved capacity — similar to managed-database pricing, with the bitemporal/audit capabilities included rather than upsold.

Open-source or BYO-infrastructure options are on the roadmap for teams that want self-hosted.

What happens at 100M records?

Our largest benchmarked graph is 536K nodes / 810K edges running on a $30/month ARM instance at 97 ms for a 131K-row bitemporal count. The architecture (append-only disk buckets, CSR acceleration, label-hinted lookups, delta-aware compaction) is designed to scale linearly with an index hit and sublinearly with caching. Multi-EC2 horizontal reader scaling is live today.

Past 100M, we'd partition by tenant or by label. If you're targeting that scale, that's a conversation to have early — it shapes your schema decisions.

How do I get my data out?

Every snapshot on disk is JSONL. POST /graphs/:name/backup produces a tar+gz of the full history — nodes, edges, adjacency, audit log, schema — that restores to any Graphiquity instance. No proprietary binary format. No vendor lock-in.

Can AI agents write to it?

Yes — that's the @graphiquity/memory SDK. One graph per agent, scoped API key, per-key rate limit, auto-expiring credentials. Every mutation stamped with _actor for audit replay. Bitemporal lets you query "what did the agent believe when it made that decision?" — something no vector DB can answer.

What about backups and disaster recovery?

Four layers: EBS snapshots via DLM, per-graph S3 archives with lifecycle rules, cross-account replication to a separate AWS organization, and EC2 recovery alarms. Tested. Documented in our runbook. Ask for it.

Do I need to learn a new query language?

No. Graphiquity speaks standard Cypher — the language Neo4j popularised — plus SQL (for tabular queries), GraphQL (for API generation), and natural-language queries. Most engineers start querying in minutes.

Design partners

Looking for our first high-stakes partners.

We're early, pre-revenue, and picky on purpose. If you're sitting on a pile of records that have to hold up to a regulator, an auditor, or a plaintiff — let's talk about shaping the product around your first real workload. Here's the trade:

You get
  • Unlimited dev access. Free tier cap removed. Run the product hard.
  • Direct line to engineering. Shared Slack, same-day response, no tiers.
  • Schema & modeling help. We'll sit with your data and help you model it bitemporally.
  • Roadmap influence. Features that matter to you get built for you.
We get
  • A real case study. Names negotiable. The story matters.
  • Real volume, real pain. Graphs harden under real load, not synthetic tests.
  • Hard feedback. You telling us what's broken is how we get good.
  • Long-term pricing. Design partners get grandfathered into our best tier, permanently.
Write us about your first workload // We read every one. Usually reply same-day.
Get started

Ready for an upgrade?

Free to get started. No credit card required. Standard Cypher, nothing to relearn. Import your first graph in under a minute.

Sign up free Read the docs