DONTO
Evidence OS
The substrate
contradiction-preserving · evidence-first
donto vs the field

Comparison

25 alternatives — agent-memory systems, bitemporal databases, knowledge-graph platforms, claim models, entity resolution — assessed feature-by-feature against donto and ranked by relevance, most relevant first. Researched 2026-06-11 from vendor docs, papers, and code. This page is honest in both directions: it names the four features no alternative has, and it names what each alternative does better than donto.

deep divedonto × Palantir Gothamread →

The 15-year field precedent for donto’s bones — per-datum provenance, append-only revisioning, reversible identity — and the deep fork: Gotham resolves ambiguity at ingest, donto at query time. Essay-length, fully sourced.

01

The twelve features

the rubric

donto’s feature set, used as the rubric. Four of them — F3, F7, F8, F11 — scored “yes” for no researched alternative.

F1Bitemporal state

Separate transaction-time and valid-time axes; time-travel queries on both — “what did we believe at T1 about time T2?”

F2Contradiction-preserving

Conflicting claims held simultaneously as legal, queryable state — never auto-resolved, invalidated, or merged away.

F3Typed argument edgesdonto-only

rebuts / undercuts / supports structure between claims, so disagreement itself is queryable.

F4Evidence anchoring

Every claim linked to the exact source span in a retrievable document — or honestly flagged as unanchorable interpretation.

F5Non-destructive revision

Append-only belief history; deletion structurally forbidden (donto enforces this with a database trigger).

F6Schema-late vocabulary

Extractors freely invent predicates at write time — no fixed ontology, no property-approval process.

F7Query-time alignmentdonto-only

Vocabulary equivalences resolved at read time via similarity, confidence-weighted — not eager canonicalization.

F8Identity-as-hypothesisdonto-only

Entity identity kept as scored, revisable edges; no hard merges; threshold selectable per query.

F9Claim standing

Computed per-claim standing: verification maturity, corroboration, contradiction-pressure, recency.

F10Hybrid retrieval + memory API

FTS + vector fusion; memorize / recall / search; MCP server. (Table stakes in 2026 — everyone competes here.)

F11Verified LLM extractiondonto-only

A separate post-hoc citation stage verifies every extracted claim against its source span — a structural hallucination filter.

F12Process provenance

Extraction runs, source documents, and content-addressed blobs recorded per claim.

02

The matrix

✓ has it · ◐ partial · — absent

✓ has it · ◐ partial (justified per system below) · — absent. Systems in relevance order. Hover any cell for the per-system justification.

donto vs the field — feature matrix
systemF1F2F3F4F5F6F7F8F9F10F11F12
donto✓✓✓✓✓✓✓✓✓✓✓✓
#1Zep / Graphiti✓◐—◐◐✓——◐✓—◐
#2Hindsight (Vectorize)◐◐—◐◐◐——◐✓—◐
#3Mem0—◐——◐◐◐——✓—◐
#4Wikidata / Wikibase◐◐—◐◐◐——◐——◐
#5Nanopublications◐✓◐◐✓✓—————◐
#6Palantir Gotham◐◐—◐◐——◐—◐—✓
#7Neo4j—◐◐◐—✓———◐◐—
#8Vector databases (as a class)—◐—◐——◐——◐——
#9XTDB v2✓———◐◐—————◐
#10ORKG◐◐—◐◐✓◐——◐◐◐
#11Datomic◐◐——◐——————◐
#12Cognee———◐—◐——◐✓—◐
#13Letta (MemGPT)———◐◐————✓—◐
#14Dolt◐———◐————◐—◐
#15TerminusDB◐———◐◐—◐—◐—◐
#16Senzing—◐—◐◐——◐———◐
#17Palantir Foundry (Ontology)◐——◐◐————◐◐✓
#18Stardog—◐———◐◐——◐◐◐
#19Ontotext GraphDB◐◐——◐◐———◐◐◐
#20AllegroGraph◐◐———◐———◐◐◐
#21SQL:2011 temporal tables✓———◐——————◐
#22RDFox—◐———✓◐——◐—◐
#23Diffbot Knowledge Graph———◐————◐—◐◐
#24Quine / thatDot◐———✓◐——————
#25LangMem (LangChain)—————◐——◐◐——

donto’s row is honest with footnotes: F3’s machinery is live but its density is still low (2,433 argument edges against 42M claims), and F9 is standing v1, shipped 2026-06-11.

03

The field, ranked

25 systems

Most relevant first. Relevance means “how seriously should someone choosing donto evaluate this instead” — a mix of conceptual overlap, buyer overlap, and capability.

#1

Zep / Graphiti

agent memoryhigh relevance

Real-time temporal knowledge-graph memory: Graphiti (OSS core) builds bi-temporal graphs from conversations; Zep is the managed platform on top.

3✓ 5◐ / 12

Why ranked here: The closest conceptual neighbor: the only competitor with genuine bi-temporality and an invalidate-not-delete philosophy. The architectural fork: Graphiti RESOLVES contradictions; donto HOLDS them.

Feature detail + what it does better
Zep / Graphiti — feature-by-feature verdicts
F1Bitemporal state✓four edge timestamps; point-in-time queries on both axes
F2Contradiction-preserving◐contradicted edges are invalidated — picks a winner; history queryable, not co-equal
F3Typed argument edges—contradiction handled solely by invalidation
F4Evidence anchoring◐edges link to source episodes; no character spans, no unanchorable flagging
F5Non-destructive revision◐invalidate-don’t-delete by design, but delete APIs exist
F6Schema-late vocabulary✓LLM invents relation names freely by default
F7Query-time alignment—opposite: eager ingest-time dedup and canonicalization
F8Identity-as-hypothesis—entity resolution hard-merges at write time
F9Claim standing◐LLM “fact ratings”; no corroboration or contradiction-pressure
F10Hybrid retrieval + memory API✓semantic + BM25 + graph traversal; official MCP server 1.0
F11Verified LLM extraction—single-pass extraction, no post-hoc citation verification
F12Process provenance◐episodes kept as ground truth; no content-addressed blobs or run records
what it has that donto lacks
  • Managed cloud with SOC 2 + HIPAA BAA
  • Multiple graph-DB backends
  • Polished Python/TS/Go SDKs + framework integrations
  • Graph-explorer UI
  • Published MCP server 1.0
~27k GitHub stars, YC-backed, very active; the best-known temporal-KG memory

Published LongMemEval_s 71.2% (gpt-4o reader, Jan 2025) — reader choice dominates these scores, so cross-vendor comparison is soft.

Graphiti Apache-2.0 (Neo4j/FalkorDB/Neptune backends); Zep Cloud proprietary managed, SOC 2 Type II
#2

Hindsight (Vectorize)

agent memoryhigh relevance

Four-network agent memory (facts, experiences, confidence-scored opinions, observations) with retain/recall/reflect and 4-way hybrid retrieval — the AMB/BEAM benchmark authors.

1✓ 7◐ / 12

Why ranked here: The most epistemics-flavored competitor — append-only facts, contradiction-aware recall, scored opinions — and the system donto benchmarks against on BEAM. Its reflect/freshness loop is the JUDGE-loop-shaped thing donto is still building.

Feature detail + what it does better
Hindsight (Vectorize) — feature-by-feature verdicts
F1Bitemporal state◐occurrence interval + ingestion time; no transaction-time axis or time-travel
F2Contradiction-preserving◐raw facts append-only, but opinions converge to one scored belief
F3Typed argument edges—reinforce/weaken update scores; not stored argument edges
F4Evidence anchoring◐document ids + preserved chunks; no per-fact span offsets
F5Non-destructive revision◐facts append-only; entity summaries LLM-merged; delete APIs exist
F6Schema-late vocabulary◐free narrative facts but fixed 4-network typology
F7Query-time alignment—eager write-time canonicalization of entities
F8Identity-as-hypothesis—hard entity merges via weighted argmax
F9Claim standing◐opinion confidence + proof counts; no maturity axis
F10Hybrid retrieval + memory API✓4-way retrieval + cross-encoder rerank; 30-tool MCP server
F11Verified LLM extraction—no post-hoc citation verification stage
F12Process provenance◐documents API + operations tracking; no content-addressed blobs
what it has that donto lacks
  • Disposition parameters (skepticism/literalism/empathy modulating belief formation)
  • Shipped reflect loop with observation freshness trends
  • Cross-encoder reranking + token-budget packing
  • Embedded no-server mode
  • Owns the AMB benchmark harness
~16k stars and the fastest growth in the category; $3.6M seed; arXiv 2512.12818

Self-published BEAM-10M 64.1%; donto-full-1 scored 0.684 on identical questions in a partial-ingest state (~5% claim coverage). Hindsight runs the leaderboard it tops.

MIT OSS (Postgres default); managed Hindsight Cloud (open-core)
#3

Mem0

agent memoryhigh relevance

The adoption leader in agent memory: an LLM pipeline extracting salient facts into a vector store, served back via hybrid retrieval.

1✓ 5◐ / 12

Why ranked here: The name every prospect knows — mindshare leader, architecturally a fact cache rather than an epistemic substrate. Its April-2026 pivot to ADD-only (no destructive update) is the market converging on donto’s append-only stance.

Feature detail + what it does better
Mem0 — feature-by-feature verdicts
F1Bitemporal state—single created_at plus optional timestamp; no dual axes
F2Contradiction-preserving◐classic pipeline LLM-DELETEd conflicts; 2026 ADD-only pivot co-stores but doesn’t model them
F3Typed argument edges—graph variant removed from OSS in 2026
F4Evidence anchoring—memories are LLM paraphrases; no source spans
F5Non-destructive revision◐audit-only history table; deletes still destroy live state
F6Schema-late vocabulary◐free-text facts, no predicate model
F7Query-time alignment◐embedding+BM25 fusion only; no explicit equivalence machinery
F8Identity-as-hypothesis—entity linking is a ranking boost, not scored identity
F9Claim standing—retrieval relevance only
F10Hybrid retrieval + memory API✓hybrid fusion; OpenMemory MCP server
F11Verified LLM extraction—extraction output trusted as-is
F12Process provenance◐user/agent/run ids; no source documents or blobs
what it has that donto lacks
  • Massive community + funding momentum
  • AWS first-party distribution (Bedrock/Strands)
  • ~20 pluggable vector stores and LLM providers
  • OpenMemory local-first cross-client MCP
  • Sub-second latency engineering
~58k stars, $24M raised (Oct 2025), AWS partnership, 186M API calls/quarter

Benchmark numbers publicly contested (the Mem0-vs-Zep LOCOMO dispute); self-reported BEAM-10M 48.6% unreplicated.

Apache-2.0 OSS + managed platform (SOC 2 Type 1, HIPAA tiers)
#4

Wikidata / Wikibase

claim modelhigh relevance

The planet’s community-curated claim store: every statement carries qualifiers, references, and a three-level rank; Wikibase is the deployable software.

0✓ 7◐ / 12

Why ranked here: donto’s closest conceptual ancestor — statement-level references, ranks, and held disagreement. It falls short exactly where donto bets: span-level evidence, computed standing, queryable belief history, free predicate minting, hypothesis-grade identity.

Feature detail + what it does better
Wikidata / Wikibase — feature-by-feature verdicts
F1Bitemporal state◐qualifiers carry valid time; edit history not queryable in SPARQL
F2Contradiction-preserving◐conflicting statements coexist, but ranks drive social resolution
F3Typed argument edges—disagreement lives on talk pages, not in the graph
F4Evidence anchoring◐references are URL/work-level; span quotation optional and rare
F5Non-destructive revision◐full revision history, but live statements destructively edited
F6Schema-late vocabulary◐property creation gated by community proposal (~12K properties)
F7Query-time alignment—one curated vocabulary; no similarity folding
F8Identity-as-hypothesis—items hard-merged with redirects
F9Claim standing◐ranks are 3-valued editorial flags, not computed standing
F10Hybrid retrieval + memory API—SPARQL + label search; no vector recall or memory API
F11Verified LLM extraction—human/bot editing, no extraction pipeline
F12Process provenance◐per-edit provenance; no extraction-run or blob model
what it has that donto lacks
  • The community-curation governance machine
  • Multilingual labels at planetary scale
  • The WDQS SPARQL ecosystem
  • Property constraints (soft validation)
  • Federation hooks
~115M items, thousands of editors, national-library adoption
Wikibase GPL-2.0+; data CC0; self-host or wikibase.cloud
#5

Nanopublications

claim modelhigh relevance

Atomic claims as tiny immutable RDF graphs — assertion + provenance + pubinfo — cryptographically named (Trusty URIs) and published to a decentralized server network.

3✓ 4◐ / 12

Why ranked here: Philosophically the nearest neighbor: immutable, provenance-first, atomic claims with supersede-not-delete. It is a publishing standard, though — no alignment, standing, retrieval engine, or extraction pipeline. The only other system where immutability is enforced rather than promised.

Feature detail + what it does better
Nanopublications — feature-by-feature verdicts
F1Bitemporal state◐creation timestamp only; no valid-time axis or time-travel
F2Contradiction-preserving✓anyone publishes anything; conflicts coexist permanently
F3Typed argument edges◐CiTO cite/dispute terms usable; no enforced argumentation semantics
F4Evidence anchoring◐PROV provenance at work level, not exact spans
F5Non-destructive revision✓Trusty URIs enforce immutability; supersede/retract are append-only
F6Schema-late vocabulary✓any RDF predicate usable
F7Query-time alignment—alignment is manual ontology reuse
F8Identity-as-hypothesis—standard RDF identity
F9Claim standing—nothing aggregates assessments into standing
F10Hybrid retrieval + memory API—SPARQL services only
F11Verified LLM extraction—human/tool authoring
F12Process provenance◐signed per-nanopub provenance; no blob store or run model
what it has that donto lacks
  • Cryptographic verifiability — anyone can check integrity offline
  • Full decentralization, no single owner
  • DOI-like citability of single claims
  • W3C-stack interop
10M+ published; strong in life sciences and FAIR scholarly workflows
Open spec + MIT-family tooling; Knowledge Pixels is the commercial steward
#6

Palantir Gotham

intel platformhigh relevance

Palantir’s defense/intelligence platform (2008): a curated Dynamic Ontology over an append-only Revisioning Database, with per-datum provenance-borne access control, federated search, link analysis (Graph), geospatial C2 (Gaia), and multi-instance Nexus Peering.

1✓ 6◐ / 12

Why ranked here: The 15-year field precedent for donto’s bones — per-datum source tethering, append-only revision cards, reversible entity merges, human-adjudicated conflict — built pre-abundance: typing at ingest, identity by winner-merge, one current truth in the UI. The deepest structural sibling in the field.

Feature detail + what it does better
Palantir Gotham — feature-by-feature verdicts
F1Bitemporal state◐RevDB “stack of cards” gives full per-attribute transaction-time history; no valid-time axis — world-time is just data properties visualized on timelines
F2Contradiction-preserving◐conflicting values coexist as revision cards and parallel analyst sandboxes, but the UI presents a winner — no co-true ranked state
F3Typed argument edges—no argument model; replication conflicts go to a human adjudication queue
F4Evidence anchoring◐every property and relationship tethers to its source document — record/document granularity, not spans, and no unanchorable flagging
F5Non-destructive revision◐append-only revision cards (actor + time + security + source per change), but a hard-delete purge capability exists
F6Schema-late vocabulary—the Dynamic Ontology is admin-curated and typed at ingest; “dynamic” means editable post-deployment, not emergent
F7Query-time alignment—alignment is integration-time parser work by forward-deployed engineers
F8Identity-as-hypothesis◐object resolution is reversible with preserved sub-histories, but picks a “winner” record for writes — asserted merge, not scored hypothesis
F9Claim standing—no maturity/corroboration ranking; documented critique: algorithm-derived links read as fact in the UI
F10Hybrid retrieval + memory API◐federated search across every integrated source + Search Around multi-hop graph queries; not a memory API, no MCP
F11Verified LLM extraction—AI detections get human confirm/dismiss (Video app); no citation-verification stage
F12Process provenance✓per-revision actor/source/classification, and provenance carries mandatory access control into derivatives — exceeds donto here
what it has that donto lacks
  • Provenance that is ACCESS-CONTROL-BEARING: classification propagates as mandatory control into every derived dossier, slide, and chat message — auto-classify to highest content, redact-down
  • Nexus Peering: multi-instance replication of full record history, across different classification schemes, disconnected-tolerant, with human conflict queues
  • CBAC + RBAC + ABAC down to per-property portion markings; tamper-evident audit accredited for TS/SCI environments
  • Operational apps donto has no analogue for: Gaia (geospatial C2), Video (FMV + AR overlays), Target Workbench
  • 15 years of field validation in the hardest provenance-critical environments on earth
15+ years in production across all Five Eyes + NATO deployments; live battlefield use in Ukraine; converging with Foundry/AIP into one platform

Full essay-length comparison at /comparison/gotham — researched 2026-07-02 from Palantir docs, the 2010 whitepaper, patents, the UK G-Cloud service definition, and press coverage.

Proprietary; forward-deployed engineering; government-scale contracts, accredited to IL5/IL6/TS-SCI
#7

Neo4j

graph platformhigh relevance

The dominant property-graph database, now centered on GraphRAG: vector indexes, an official GraphRAG framework, and LLM graph-construction tooling.

1✓ 5◐ / 12

Why ranked here: The default answer to “store extracted knowledge as a graph” — the thing donto must explain itself against. Every donto invariant is a build-it-yourself convention on Neo4j, silently violable by any writer.

Feature detail + what it does better
Neo4j — feature-by-feature verdicts
F1Bitemporal state—temporal property types only; no engine time-travel
F2Contradiction-preserving◐reified claim nodes coexist by convention; no semantics
F3Typed argument edges◐any relationship type expressible; no argumentation tooling
F4Evidence anchoring◐GraphRAG lexical graph links chunks to docs — convention, not contract
F5Non-destructive revision—in-place update and DELETE are the normal model
F6Schema-late vocabulary✓schema-optional; labels and relationship types minted freely
F7Query-time alignment—alignment must be precomputed
F8Identity-as-hypothesis—standard practice is destructive node merging
F9Claim standing—GDS scores are generic graph metrics
F10Hybrid retrieval + memory API◐native vector + FTS, hybrid retrievers, official MCP; no memorize/recall semantics
F11Verified LLM extraction◐LLM Graph Builder extracts; no span-citation verification
F12Process provenance—no native extraction-run or source lineage
what it has that donto lacks
  • Cypher + the GQL ISO standard
  • Multi-hop traversal performance
  • Clustering/HA + managed Aura
  • Graph Data Science library
  • The largest graph talent pool and integration surface
#1 graph DB for a decade; enormous ecosystem, drivers, GDS algorithms, Bloom visualization
Community GPLv3; Enterprise commercial; AuraDB managed cloud
#8

Vector databases (as a class)

retrievalhigh relevance

Pinecone / Weaviate / Qdrant / pgvector — embedding-similarity stores, the default memory layer of the RAG era. (donto itself runs on pgvector.)

0✓ 4◐ / 12

Why ranked here: What every team evaluating “agent memory” reaches for first — high perceived relevance, low capability overlap. The class answers “what’s similar?”; it cannot answer “what’s claimed, by whom, contradicted by what, as of when?”

Feature detail + what it does better
Vector databases (as a class) — feature-by-feature verdicts
F1Bitemporal state—timestamp metadata filters at best
F2Contradiction-preserving◐stores contradictory texts blindly; cannot represent conflict as conflict
F3Typed argument edges—no edges at all
F4Evidence anchoring◐chunk metadata can point at sources — app convention
F5Non-destructive revision—upsert/delete are the API
F6Schema-late vocabulary—claims aren’t representable — only opaque text + payload
F7Query-time alignment◐embedding similarity is read-time matching, but over text with no claim joining
F8Identity-as-hypothesis—no entity model
F9Claim standing—cosine similarity is not corroboration
F10Hybrid retrieval + memory API◐hybrid retrieval at scale is the class’s home turf; memory semantics live in layers above
F11Verified LLM extraction—out of scope
F12Process provenance—out of scope
what it has that donto lacks
  • Managed elastic scale to billions of vectors
  • Single-digit-ms ANN latency
  • Quantization + GPU acceleration
  • Multi-tenancy and serverless pricing
  • Enormous integration ecosystem
Ubiquitous; best-in-class filtered/hybrid ANN engineering at billions of vectors
Spectrum: Pinecone proprietary serverless; Qdrant Apache-2.0; Weaviate BSD-3; pgvector OSS
#9

XTDB v2

bitemporal DBmedium relevance

An immutable bitemporal SQL database — every table tracks system time and valid time per SQL:2011 — on a columnar Arrow engine, speaking the Postgres wire protocol.

1✓ 3◐ / 12

Why ranked here: The best-in-class answer to “who else does real bitemporality?” and the credible “just use a bitemporal DB” objection — but it versions one agreed truth; nothing for contested knowledge. Its ERASE is a compliance feature donto deliberately rejects: a philosophical fork, not a gap.

Feature detail + what it does better
XTDB v2 — feature-by-feature verdicts
F1Bitemporal state✓system + valid time on every table; time-travel on both axes
F2Contradiction-preserving—updates supersede per entity/period; conflicts resolved
F3Typed argument edges—no argumentation model
F4Evidence anchoring—no evidence concept
F5Non-destructive revision◐immutable by default, but ERASE permanently destroys (GDPR feature)
F6Schema-late vocabulary◐dynamic columns, no DDL; still relational attributes
F7Query-time alignment—no vocabulary folding
F8Identity-as-hypothesis—hard primary-key identity
F9Claim standing—no standing
F10Hybrid retrieval + memory API—no vectors, no memory API
F11Verified LLM extraction—no extraction
F12Process provenance◐reified queryable transactions; write-level audit
what it has that donto lacks
  • SQL:2011 bitemporal SQL on the Postgres wire protocol
  • Columnar Arrow engine + object-storage separation (cheap full history)
  • ACID serializable transactions
  • ERASE for GDPR Art. 17
  • Kubernetes-native ops
v2 GA June 2025; production in regulated KYC and energy; ~3k stars
MPL-2.0 fully open source; self-host; backed by JUXT
#10

ORKG

claim modelmedium relevance

TIB Hannover’s Open Research Knowledge Graph: scholarly contributions as structured statements, compared across papers in machine-actionable tables.

1✓ 8◐ / 12

Why ranked here: The closest use-case cousin: cross-source scientific claims with per-source attribution and post-hoc property alignment — independent validation of donto’s thesis, including the free-predicate “problem”. A curated scholarly app, not a general substrate.

Feature detail + what it does better
ORKG — feature-by-feature verdicts
F1Bitemporal state◐immutable published snapshots; no valid time or time-travel
F2Contradiction-preserving◐contradictory paper results coexist by design — per-paper attribution, not semantics
F3Typed argument edges—comparisons juxtapose; no argument edges
F4Evidence anchoring◐anchored to papers at DOI level, not spans
F5Non-destructive revision◐published comparisons immutable; working graph editable
F6Schema-late vocabulary✓users freely mint properties — predicate proliferation is their documented problem too
F7Query-time alignment◐comparison builder aligns similar properties — curatorial, not query-time
F8Identity-as-hypothesis—manual resource merges
F9Claim standing—curation grades, not computed standing
F10Hybrid retrieval + memory API◐faceted + similarity search, SPARQL, REST APIs; no memory API
F11Verified LLM extraction◐LLM-assisted suggestion with human validation
F12Process provenance◐per-statement who/when + PROV on snapshots
what it has that donto lacks
  • The comparison-table product (citable cross-paper SOTA tables with DOIs)
  • Scholarly integrations (DataCite, ORCID)
  • Curated templates and observatories
EU/DFG-funded research infrastructure, ~7 years, active through 2025
MIT OSS; primarily used as the hosted orkg.org service
#11

Datomic

bitemporal DBmedium relevance

Nubank’s immutable fact database for the JVM: an append-only log of [entity attribute value tx] datoms with Datalog queries and as-of/since/history time travel.

0✓ 4◐ / 12

Why ranked here: The closest mainstream system to donto’s append-only DNA, at the opposite epistemic pole: unitemporal, single-truth, schema-required. System-of-record for one agreed reality.

Feature detail + what it does better
Datomic — feature-by-feature verdicts
F1Bitemporal state◐transaction time only; valid time hand-modeled
F2Contradiction-preserving◐cardinality-many holds multiple values; cardinality-one auto-retracts
F3Typed argument edges—no argumentation model
F4Evidence anchoring—no evidence concepts
F5Non-destructive revision◐append-only with history, but excision permanently deletes
F6Schema-late vocabulary—every attribute requires upfront schema
F7Query-time alignment—fixed attribute identifiers
F8Identity-as-hypothesis—deterministic upsert identity
F9Claim standing—no standing
F10Hybrid retrieval + memory API—Lucene fulltext only; no vectors or memory API
F11Verified LLM extraction—no LLM tooling
F12Process provenance◐reified transactions take arbitrary metadata
what it has that donto lacks
  • Datalog with recursive rules
  • Peer model — database-as-a-value queried in-process
  • Speculative what-if databases (never committed)
  • Jepsen-validated single-writer ACID
  • Planet-scale production proof
~14 years in production; core banking at Nubank (~2.5B transactions/day); Jepsen-validated
Free binaries since 2023 but closed source; Pro self-host or Cloud (AWS)
#12

Cognee

agent memorymedium relevance

An Extract-Cognify-Load pipeline ingesting 38+ formats into a combined knowledge-graph + vector + relational store with remember/recall/forget operations.

1✓ 4◐ / 12

Why ranked here: A well-funded graph-RAG productizer with overlapping pitch language, but architecturally the opposite of a claim substrate: eager canonicalization, hard merges, deletion-as-feature.

Feature detail + what it does better
Cognee — feature-by-feature verdicts
F1Bitemporal state—extracts event valid-time only; no transaction axis
F2Contradiction-preserving—conflicts trigger invalidation or clarification — resolution, not coexistence
F3Typed argument edges—absent
F4Evidence anchoring◐page/section citations, not exact spans
F5Non-destructive revision—forget/prune are first-class features
F6Schema-late vocabulary◐free extraction by default, but pushes Pydantic/OWL schemas
F7Query-time alignment—eager canonicalization at write (fuzzy cutoff at ingest)
F8Identity-as-hypothesis—content-hash + embedding hard merges at cognify
F9Claim standing◐marketing claims feedback-reweighted edges; undocumented
F10Hybrid retrieval + memory API✓vector+graph hybrid, official MCP, Claude Code plugin
F11Verified LLM extraction—citations carried from ingestion, never verified
F12Process provenance◐relational doc/chunk tracking + OpenTelemetry
what it has that donto lacks
  • Pluggable multi-backend matrix (5 graph DBs × 7+ vector stores)
  • OWL ontology integration
  • 38+ format multimodal ingestion
  • Graph visualization UI + one-click deploys
~18k stars, $7.5M seed (Feb 2026), claims 70+ companies live incl. Bayer
Apache-2.0; managed Cogwit cloud
#13

Letta (MemGPT)

agent memorymedium relevance

The UC-Berkeley agent runtime for stateful agents that learn via self-editing memory blocks, archival vector memory, and sleep-time background agents.

1✓ 3◐ / 12

Why ranked here: Extremely well-known, but it competes as an agent runtime with memory, not a memory substrate — prose blocks, not claims.

Feature detail + what it does better
Letta (MemGPT) — feature-by-feature verdicts
F1Bitemporal state—created/updated timestamps only
F2Contradiction-preserving—self-editing memory rewrites conflicts into one clean context
F3Typed argument edges—memory is text blocks, not a claim graph
F4Evidence anchoring◐source passages link chunks to files; no per-claim anchoring
F5Non-destructive revision◐block history undo/redo; in-place edits are the design
F6Schema-late vocabulary—free prose — no typed claims at all
F7Query-time alignment—no predicates exist to align
F8Identity-as-hypothesis—no entity model
F9Claim standing—retrieval rank only
F10Hybrid retrieval + memory API✓hybrid vector+FTS via RRF; insert/search APIs
F11Verified LLM extraction—sleep-time derivation unverified
F12Process provenance◐source files + passage lineage + block history
what it has that donto lacks
  • A full agent runtime (loop, tools, subagents, server-side state)
  • ADE visual development environment
  • Sleep-time compute
  • Agent File (.af) portability standard
~23k stars, $10M Felicis seed; MemGPT is among the most-cited agent-memory papers
Apache-2.0 server (Postgres/pgvector); Letta Cloud + Desktop
#14

Dolt

versioned DBmedium relevance

A MySQL-compatible SQL database with full Git semantics — branch, merge, diff, clone, and pull tables like a repository; actively marketing “agents need branches”.

0✓ 4◐ / 12

Why ranked here: The strongest general-purpose versioned-data product and the only one in its class converging on donto’s agent-memory buyer narrative — with single-truth semantics: merging forces a winner.

Feature detail + what it does better
Dolt — feature-by-feature verdicts
F1Bitemporal state◐commit history ≈ transaction time (AS OF); no valid time
F2Contradiction-preserving—conflicts are merge errors to resolve; one truth per branch HEAD
F3Typed argument edges—no claim model
F4Evidence anchoring—no evidence model
F5Non-destructive revision◐full history but rewritable (gc, squash; auto-GC default in 2.0)
F6Schema-late vocabulary—DDL required before writes
F7Query-time alignment—exact relational semantics
F8Identity-as-hypothesis—primary-key identity
F9Claim standing—no scoring
F10Hybrid retrieval + memory API◐beta vectors + FTS + official MCP; no recall fusion API
F11Verified LLM extraction—agents write via SQL, unverified
F12Process provenance◐content-addressed commits with author/message
what it has that donto lacks
  • Git semantics on tables (branch/merge/diff/push-pull as SQL procedures)
  • Cell-level three-way merge
  • MySQL wire compatibility
  • Data pull requests with web review UI
  • Mature commercial hosting
~23k stars, $23M+ raised; Dolt 2.0 (May 2026) benchmarked faster than MySQL, beta vectors, official MCP server
Apache-2.0; DoltHub/DoltLab hosting; Hosted Dolt commercial
#15

TerminusDB

versioned DBmedium relevance

“Git for data”: JSON documents over an RDF graph with immutable commit history, branch/merge/diff, schema validation, and GraphQL/WOQL datalog.

0✓ 6◐ / 12

Why ranked here: The closest philosophical neighbor among versioned graph stores — but it versions at the dataset level (commits) where donto versions at the claim level, and it enforces consistency where donto holds contradiction.

Feature detail + what it does better
TerminusDB — feature-by-feature verdicts
F1Bitemporal state◐transaction-time travel via commits; no valid time
F2Contradiction-preserving—schema validation enforces consistency
F3Typed argument edges—hand-modelable only
F4Evidence anchoring—commits record author/message, not evidence spans
F5Non-destructive revision◐append-only layers, but squash/reset discard history
F6Schema-late vocabulary◐schema-first closed-world; v12 allows untyped JSON blobs
F7Query-time alignment—no read-time folding
F8Identity-as-hypothesis◐VectorLink suggests scored duplicate candidates; merges manual
F9Claim standing—no standing
F10Hybrid retrieval + memory API◐vector sidecar + MCP via DFRNT tooling; no fusion API
F11Verified LLM extraction—no extraction
F12Process provenance◐per-commit provenance, content-addressed layers
what it has that donto lacks
  • Whole-dataset git collaboration (branch/merge/rebase/push/pull/clone)
  • Closed-world schema validation on every commit
  • WOQL datalog + auto-generated GraphQL
  • Succinct immutable data structures
~3.3k stars; v12 (Dec 2025) under new stewardship — revival and continuity-risk signal at once
Apache-2.0; stewardship moved to DFRNT in 2025 (hosted + enterprise)
#16

Senzing

entity resolutionmedium relevance

The specialist real-time entity-resolution engine: principle-based matching with explanations, no training or tuning, embeddable in your own process.

0✓ 5◐ / 12

Why ranked here: Not a substrate — it solves exactly one slice (identity), better than anyone on resolution quality, while sharing donto’s non-destructive philosophy. More plausible as a component donto embeds than an alternative. donto’s identity layer is embryonic by comparison.

Feature detail + what it does better
Senzing — feature-by-feature verdicts
F1Bitemporal state—current-state resolved view
F2Contradiction-preserving◐conflicting source values retained inside entities
F3Typed argument edges—disclosed/derived relationships only
F4Evidence anchoring◐record-level provenance; structured records, no spans
F5Non-destructive revision◐originals kept; record deletes supported
F6Schema-late vocabulary—preconfigured person/org feature schema
F7Query-time alignment—resolution recomputed at ingest
F8Identity-as-hypothesis◐closest in field: never fuses records, auto un-merges on reversal — but serves ONE canonical view, no per-query threshold
F9Claim standing—match scoring, not standing
F10Hybrid retrieval + memory API—entity search APIs only
F11Verified LLM extraction—not an extraction system
F12Process provenance◐per-record source provenance + explainable match keys
what it has that donto lacks
  • Real-time ER at billions of records, millisecond latency
  • Sequence-neutral entity-centric learning
  • Zero-training principle-based matching
  • Watchlist-grade fuzzy name/address comparators
  • Explainable match output
Jeff Jonas (ex-IBM G2); the de-facto ER engine, widely OEM’d into MDM/fraud products
Proprietary SDK, priced by source-record count; your data stays in your DB
#17

Palantir Foundry (Ontology)

enterprise platformmedium relevance

Foundry’s Ontology maps integrated enterprise data to governed object types, links, and actions — an operational digital twin powering apps and AIP agent workflows.

1✓ 5◐ / 12

Why ranked here: The clearest philosophical foil: Foundry curates ONE operational truth, donto holds ALL contested truths. Competes for “where does org knowledge live” budgets; unbuyable for small teams.

Feature detail + what it does better
Palantir Foundry (Ontology) — feature-by-feature verdicts
F1Bitemporal state◐dataset transactions give transaction-time versioning; no claim-level valid time
F2Contradiction-preserving—one canonical operational truth; conflicts resolved upstream
F3Typed argument edges—links model domain relationships
F4Evidence anchoring◐object→dataset→source lineage is strong; no span contract
F5Non-destructive revision◐versioned datasets; objects are mutable operational state
F6Schema-late vocabulary—ontology governed upfront — the philosophical opposite of emit-free
F7Query-time alignment—alignment is design-time
F8Identity-as-hypothesis—ER baked into pipelines, merged canonical records
F9Claim standing—not a claims model
F10Hybrid retrieval + memory API◐AIP agents + object search; not a memory API
F11Verified LLM extraction◐AIP pipelines with evals; span verification unverified
F12Process provenance✓best-in-class lineage — exceeds donto here
what it has that donto lacks
  • Enterprise governance (ACLs, audit, compliance) at scale
  • End-to-end pipeline + lineage tooling beyond donto’s
  • Operational app building + writeback
  • Forward-deployed engineering
Public company, multi-billion revenue, deep government + commercial adoption
Proprietary enterprise platform; opaque pricing, enterprise-scale contracts
#18

Stardog

graph platformmedium relevance

Enterprise knowledge graph centered on data virtualization — querying external databases in place as graphs — with query-time OWL reasoning and the Voicebox LLM interface.

0✓ 6◐ / 12

Why ranked here: Its query-time-reasoning philosophy rhymes with donto’s defer-to-read stance — but it is schema-forward data-fabric middleware, and it removed its versioning feature.

Feature detail + what it does better
Stardog — feature-by-feature verdicts
F1Bitemporal state—versioning feature was removed (v7 era)
F2Contradiction-preserving◐stores arbitrary triples; reasoning is inconsistency-tolerant
F3Typed argument edges—edge properties annotate, no argumentation
F4Evidence anchoring—BITES links docs to entities, not spans to claims
F5Non-destructive revision—standard mutable store
F6Schema-late vocabulary◐any IRI allowed; product pushes ontology-driven modeling
F7Query-time alignment◐closest in class: query-time reasoning resolves logical equivalence at read — but logical only, not similarity-based
F8Identity-as-hypothesis—owl:sameAs hard identity
F9Claim standing—nothing comparable
F10Hybrid retrieval + memory API◐FTS, GeoSPARQL, Voicebox NL Q&A; no memory API
F11Verified LLM extraction◐Voicebox grounds answers in the KG; no extraction faithfulness
F12Process provenance◐edge-property provenance metadata
what it has that donto lacks
  • Virtual graphs — query Snowflake/Oracle in place, zero-copy
  • Query-time OWL DL reasoning with explanations
  • Integrity constraint validation
  • Federated query optimization
~15 years; finance/defense/manufacturing data fabrics; trillion-triple federation claims
Proprietary; free 1-year renewable license; Stardog Cloud
#19

Ontotext GraphDB

graph platformmedium relevance

The market-leading enterprise RDF triplestore: forward-chaining OWL reasoning, SPARQL 1.1, and (v11) GraphRAG/vector integrations.

0✓ 7◐ / 12

Why ranked here: Competes for enterprise-KG budget and now markets GraphRAG — but every donto invariant would be a custom app built on top of it.

Feature detail + what it does better
Ontotext GraphDB — feature-by-feature verdicts
F1Bitemporal state◐data-history plugin gives transaction-time travel, off by default; no valid time
F2Contradiction-preserving◐stores contradictory triples; OWL reasoning treats inconsistency as error
F3Typed argument edges—RDF-star annotates, no semantics
F4Evidence anchoring—model-it-yourself
F5Non-destructive revision◐history plugin when enabled; DELETE is normal
F6Schema-late vocabulary◐any IRI, but the value prop is ontology-driven
F7Query-time alignment—equivalence materialized at load
F8Identity-as-hypothesis—owl:sameAs smushing
F9Claim standing—nothing comparable
F10Hybrid retrieval + memory API◐vector via Elasticsearch connectors + NL interface; no memory API
F11Verified LLM extraction◐text-to-graph tooling exists; no span verification
F12Process provenance◐named graphs + DIY PROV
what it has that donto lacks
  • Standards-grade SPARQL 1.1 + RDF4J
  • Forward-chaining OWL2 reasoning with configurable rulesets
  • SHACL validation
  • Clustered HA + connector ecosystem
  • Mature workbench + consultant ecosystem
~20 years mature; BBC, pharma, finance installed base
Proprietary (free edition requires a license since v11); part of Graphwise
#20

AllegroGraph

graph platformmedium relevance

Distributed multi-modal (RDF + vector + JSON document) graph database marketing itself as a neuro-symbolic AI platform with LLM functions inside SPARQL.

0✓ 6◐ / 12

Why ranked here: Its neuro-symbolic + vector marketing overlaps donto’s pitch surface most among triplestores — architecturally still a mutable, resolve-at-load graph DB.

Feature detail + what it does better
AllegroGraph — feature-by-feature verdicts
F1Bitemporal state◐temporal-reasoning library models valid time in data; no transaction-time travel
F2Contradiction-preserving◐stores conflicting triples without semantics
F3Typed argument edges—quints can annotate; no model
F4Evidence anchoring—no claim→span contract
F5Non-destructive revision—mutable store
F6Schema-late vocabulary◐schema-free RDF; ecosystem assumes ontologies
F7Query-time alignment—logical reasoning, not similarity
F8Identity-as-hypothesis—owl:sameAs + batch ER tool
F9Claim standing—nothing comparable
F10Hybrid retrieval + memory API◐native vectors + FTS + LLM-in-SPARQL; agent-memory positioning emerging
F11Verified LLM extraction◐LLMagic generates triples; no verification stage
F12Process provenance◐named-graph provenance possible
what it has that donto lacks
  • RDF + vector + JSON docs in one engine
  • LLM functions callable inside SPARQL
  • Temporal/geospatial/social analytics libraries
  • FedShard horizontal sharding
  • Prolog rule engine
Franz Inc, decades mature; pharma/intelligence/healthcare niches
Proprietary; free edition capped at 5M triples; AllegroGraph Cloud
#21

SQL:2011 temporal tables

bitemporal DBmedium relevance

Native temporal-table support in MariaDB (true bitemporal), IBM Db2 (the most complete), SQL Server (system-time only), Oracle (via Flashback) — the “just use the database” objection.

1✓ 2◐ / 12

Why ranked here: Covers exactly one of twelve dimensions (time), with far better tooling. The fine irony: donto’s own host, Postgres, is the one mainstream DB without native temporal tables — donto implements its bitemporality itself.

Feature detail + what it does better
SQL:2011 temporal tables — feature-by-feature verdicts
F1Bitemporal state✓Db2 + MariaDB ≥10.4: full bitemporal on both axes
F2Contradiction-preserving—temporal PKs exist precisely to forbid conflicting simultaneous assertions
F3Typed argument edges—no claim model
F4Evidence anchoring—rows not anchored to provenance text
F5Non-destructive revision◐automatic history capture, but admins can purge; retention auto-deletes
F6Schema-late vocabulary—fixed relational schema
F7Query-time alignment—exact-match joins
F8Identity-as-hypothesis—identity = primary key
F9Claim standing—no scoring
F10Hybrid retrieval + memory API—no memory layer
F11Verified LLM extraction—none
F12Process provenance◐who/when audit logs
what it has that donto lacks
  • The full SQL ecosystem (BI, ORMs, drivers)
  • Transparent history capture with zero app changes
  • Enforced temporal integrity constraints
  • Mature HA/replication/PITR ops
  • Vendor compliance certifications
Standardized 2011, battle-tested enterprise audit/compliance workloads everywhere
Mixed: MariaDB GPLv2, others proprietary; Postgres has NO native support (extensions only)
#22

RDFox

graph platformlow relevance

Oxford Semantic’s in-memory RDF + Datalog reasoning engine — incremental materialization of inferences as facts and rules change; acquired by Samsung (2024) for on-device AI.

1✓ 4◐ / 12

Why ranked here: The classical-KG posture donto rejects: deductive closure over a curated consistent ontology. More plausible as a complement — a reasoning lens over a donto export — than a substitute.

Feature detail + what it does better
RDFox — feature-by-feature verdicts
F1Bitemporal state—current-state store only
F2Contradiction-preserving◐triples coexist; reasoning flags inconsistency as error
F3Typed argument edges—nothing native
F4Evidence anchoring—hand-modeled
F5Non-destructive revision—incremental retraction (deletion) is a headline feature
F6Schema-late vocabulary✓arbitrary RDF predicates at write
F7Query-time alignment◐equivalence folded at materialization (write) time
F8Identity-as-hypothesis—equality reasoning hard-merges resources
F9Claim standing—no standing
F10Hybrid retrieval + memory API◐Lucene FTS + experimental vector similarity
F11Verified LLM extraction—no extraction
F12Process provenance◐native explanation trees for derived facts
what it has that donto lacks
  • Incremental Datalog materialization (millions of inferences/sec, updated on change)
  • OWL 2 RL + SWRL rules, stratified negation
  • Explanation trees for inferred facts
  • Edge/on-device footprint
Powers Galaxy S25 on-device personalization; Festo, Dow Jones, Siemens; v7.6 June 2026
Commercial/proprietary; in-memory on-prem, cloud, or on-device
#23

Diffbot Knowledge Graph

data productlow relevance

A pre-crawled, ML-extracted knowledge graph of the public web — 10B+ entities, 1T+ facts, refreshed every 4–5 days — sold with extraction and query APIs.

0✓ 4◐ / 12

Why ranked here: A read-mostly external data product — complementary (a source to extract FROM) more than competitive.

Feature detail + what it does better
Diffbot Knowledge Graph — feature-by-feature verdicts
F1Bitemporal state—rolling refresh snapshots
F2Contradiction-preserving—builds canonical deduplicated entities
F3Typed argument edges—fixed fact ontology
F4Evidence anchoring◐facts carry origin URLs; not user-controlled spans
F5Non-destructive revision—records overwritten on refresh
F6Schema-late vocabulary—fixed Diffbot ontology
F7Query-time alignment—entity linking at build time
F8Identity-as-hypothesis—hard-merged canonical entities
F9Claim standing◐per-fact confidence scores
F10Hybrid retrieval + memory API—query APIs, not a writable memory
F11Verified LLM extraction◐mature ML extraction with confidences; no span verification exposed
F12Process provenance◐origin URLs + crawl metadata
what it has that donto lacks
  • The asset itself: a maintained 10B-entity web graph nobody has to extract
  • Web-scale crawling infrastructure
  • Entity enrichment from a name or URL
Operating since ~2008; stable enterprise base for market intelligence
Proprietary SaaS, credit-based pricing
#24

Quine / thatDot

streaming graphlow relevance

A streaming graph interpreter: event streams become a versioned property graph, with standing queries that fire the instant a pattern completes.

1✓ 2◐ / 12

Why ranked here: A different problem (real-time stream detection), but the best prior art that an event-sourced fully-versioned graph ships in practice — and inspiration for standing contradiction queries.

Feature detail + what it does better
Quine / thatDot — feature-by-feature verdicts
F1Bitemporal state◐full transaction-time versioning with atTime queries; no valid time
F2Contradiction-preserving—property graph, no claim semantics
F3Typed argument edges—absent
F4Evidence anchoring—absent
F5Non-destructive revision✓event-sourced per-node journals; replay any historical state
F6Schema-late vocabulary◐schemaless properties; no alignment
F7Query-time alignment—absent
F8Identity-as-hypothesis—opposite: identity is a deterministic function of data
F9Claim standing—absent
F10Hybrid retrieval + memory API—out of scope
F11Verified LLM extraction—out of scope
F12Process provenance—out of scope
what it has that donto lacks
  • Standing queries — continuous incremental pattern matching over unbounded streams
  • High-throughput streaming ingest
Niche but real adoption in fraud/security event pipelines
Source-available (Commons Clause); commercial thatDot for clustered scale
#25

LangMem (LangChain)

agent memorylow relevance

LangChain’s SDK of memory primitives for LangGraph agents — extraction tools, background consolidation, prompt optimizers — storing JSON documents in BaseStore.

0✓ 3◐ / 12

Why ranked here: Included for the LangChain name — a thin, lightly-maintained primitive SDK that even LangChain’s own docs now route around.

Feature detail + what it does better
LangMem (LangChain) — feature-by-feature verdicts
F1Bitemporal state—created/updated only
F2Contradiction-preserving—consolidation explicitly resolves contradictions and deletes outdated memories
F3Typed argument edges—flat JSON documents
F4Evidence anchoring—stores conclusions, not spans
F5Non-destructive revision—updates overwrite in place
F6Schema-late vocabulary◐free text or fixed user schemas
F7Query-time alignment—consolidation merges eagerly
F8Identity-as-hypothesis—no entity model
F9Claim standing◐importance/strength retrieval weighting only
F10Hybrid retrieval + memory API◐pgvector semantic search; no FTS fusion or official MCP
F11Verified LLM extraction—no verification
F12Process provenance—none
what it has that donto lacks
  • Procedural memory / prompt optimization (rewrites the agent’s own system prompt)
  • Deep LangGraph ecosystem distribution
~1.5k stars; still 0.0.x after 17 months; current LangChain docs route around it
MIT OSS; storage via any BaseStore (pgvector in production)
04

What the field does better than donto

the honesty section

Proof discipline is the brand: a comparison that only flatters its author is marketing. These are real gaps, named with their winners.

Managed cloud + compliance

No hosted offering, no SOC 2 / HIPAA. Zep, Mem0, Pinecone, and Foundry all sell this on day one.

wins here: Zep, Mem0, Foundry
Ecosystem + SDKs

No polished multi-language SDKs, framework integrations, or talent pool. Neo4j’s ecosystem and Mem0’s 58k-star community dwarf donto’s.

wins here: Neo4j, Mem0, LangChain
Standards compliance

No SPARQL, no OWL reasoning, no SHACL, no federation. The RDF world’s twenty years of tooling doesn’t plug in directly — donto’s answer is exports as lenses with loss reports, which is honest but young.

wins here: GraphDB, Stardog, AllegroGraph
Retrieval scale + latency

donto’s embedding fabric is bge-small + HNSW inside Postgres on a 4-core box. Dedicated vector DBs do billions of vectors at single-digit-millisecond latency.

wins here: Pinecone, Qdrant, Weaviate
Identity-resolution quality

donto keeps identity as hypothesis (the right model), but its matcher is embryonic. Senzing’s principle-based ER at billions of records is decades ahead on match quality.

wins here: Senzing
Rule reasoning

No Datalog engine, no incremental materialization, no deductive closure. RDFox computes millions of inferences per second; donto computes none.

wins here: RDFox, Datomic, Stardog
Streaming + standing queries

donto’s contradiction detection is batch; Quine fires standing queries the instant a pattern completes in a stream.

wins here: Quine / thatDot
Shipped judgment loops

Hindsight’s reflect loop with observation freshness trends is live today; donto’s JUDGE/STEER loops are partially built (standing v1 just landed).

wins here: Hindsight
Policy-carrying provenance

Gotham propagates classification as mandatory access control into every derived artifact — dossiers auto-classify to their highest-content level, chat redacts per viewer. donto’s Trust Kernel has the same design on paper but is present-and-unenforced.

wins here: Palantir Gotham
Multi-instance replication

Nexus Peering replicates full per-record history across instances and even across different classification schemes, disconnected-tolerant, with human conflict queues. donto’s federation is an M9 research spike.

wins here: Palantir Gotham
05

Methodology

how this page was built

Researched 2026-06-11 by four parallel research agents over vendor documentation, GitHub repositories, papers, and third-party comparisons; synthesized and edited by hand. “Partial” always carries a justification (hover matrix cells or expand a card). Where a capability could not be verified it is scored down, not up. Benchmark numbers are quoted with their caveats — most agent-memory scores conflate reader and memory quality, and several are vendor-run. Vendors: if we got something wrong, tell us and we’ll fix it — this page is regenerated from a reviewed data file, not prose. Palantir Gotham was added 2026-07-02 with a dedicated deep dive.