🤖 AI

Eigenius: A Typed Knowledge-Graph DBMS with Epistemic Stratification and Institution-Mediated Reasoning

Eigenius is an open-source, typed knowledge-graph DBMS that unifies dependent type theory, institutional integration boundaries, and immutable storage to enforce epistemic status as a structural invariant, thereby replacing fragile, ephemeral AI research scripts with a machine-walkable, audit-ready evidence graph capable of verifying scientific conclusions and detecting discrepancies.

Original authors: Hans-Martin Will, Allen L. Brown Jr., Matthew Fuchs

Published 2026-08-06

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Hans-Martin Will, Allen L. Brown Jr., Matthew Fuchs

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Detective's Dilemma: Why We Need a Better Way to Track Truth

Imagine you are a detective trying to solve a massive mystery. In the old days, you might have scribbled clues on sticky notes, taped photos to a corkboard, and written your conclusions in a notebook. If someone asked, "How do you know the butler did it?" you could flip through your notes and show the chain of evidence. But what if your notebook was just a collection of loose, temporary notes that could be erased or rewritten at any moment? What if your "evidence" was a script that ran once and then vanished, leaving no trace of how it reached its conclusion?

This is the current state of how scientists and, increasingly, artificial intelligence (AI) "scientists" are working. They are using powerful tools to run complex experiments and write code, but the "proof" of their work often lives in fragile, temporary files. When an AI tries to learn from this, it's like trying to solve a mystery with a board full of invisible ink. The paper we are about to explore, Eigenius, argues that we need a new kind of "detective's ledger." It proposes a system where every single piece of information, every calculation, and every conclusion is permanently stamped, typed, and linked together in a way that can never be faked or lost. It's about building a database that doesn't just store facts, but stores the warranty for those facts—the proof that they are true.

The Paper: Building a "Truth Machine" for Science

The paper introduces Eigenius, a new kind of database designed specifically for the age of AI scientists. The authors, Hans-Martin Will, A. L. Brown Jr., and Matthew Fuchs, argue that the current way we store scientific data is too messy for machines to trust. Today, scientific arguments are often just "ephemeral webs"—temporary links between scripts and stories that are hard to audit. If an AI agent tries to read these, it can't be sure if the math was done correctly or if the data was changed along the way.

Eigenius fixes this by treating data like a high-security vault where every item has a permanent, unchangeable ID card. Here is how it works, using some fun analogies:

1. The "Epistemic" ID Card (Knowing What You Know)
In Eigenius, every piece of data gets a specific "epistemic status" tag. Think of this like a color-coded badge on a detective's file:

Declared: "I say this is true because an authority said so." (No proof yet).
Observed: "I saw this happen with a machine." (Real-world evidence).
Derived: "I calculated this from other facts." (Math done by the computer).
Verified: "I have a formal, machine-checked proof that this is 100% true." (The gold standard).

The system forces you to pick a badge for every piece of data before you can save it. You can't just dump a number in; you have to prove where it came from. This turns the "audit question" ("How do you know?") into a structural part of the database itself, rather than something you have to guess later.

2. The "Institution" Bridge (The Universal Translator)
Science uses many different languages. One lab might use Python, another might use a math tool called Lean, and a third might use a statistics program. Usually, connecting these is like trying to translate a book from English to French to Japanese and back to English—errors creep in, and the original meaning gets lost. This is called the "polystore bottleneck," and it gets really expensive (mathematically speaking, it's an $O(N^2)$ problem, meaning it gets messy very fast).

Eigenius introduces Institutions. Imagine these as specialized "embassies" or "translation booths" inside the database. When data moves from one system to another, it doesn't just get copied; it gets translated by a strict, typed protocol called a comorphism. The system checks the translation before it saves it. If the math doesn't match perfectly, the translation is rejected. This ensures that when data moves between different scientific tools, it arrives exactly as it left, with no lost meaning.

3. The "Lean" Proof (The Magic Spell Check)
For pure math, Eigenius uses a powerful tool called Lean 4. Think of Lean 4 as a spell-checker that doesn't just check for typos, but checks if the entire sentence makes logical sense. In Eigenius, this checker runs inside the database itself. When a scientist claims a mathematical theorem is true, the database doesn't just take their word for it; it runs the proof through its own internal "spell-checker" to verify it. If the proof holds, the claim gets the "Verified" badge. If it fails, it's rejected. This happens instantly, without needing to call an outside computer, which makes it fast and secure.

4. The "Immutable" Chain (The Unbreakable Ledger)
Everything in Eigenius is stored in a content-addressed way. Imagine a library where every book is identified not by its title, but by a unique fingerprint of its actual words. If you change even a single comma in a book, its fingerprint changes, and it becomes a completely different book. This means the history of the data is a chain of these fingerprints (a Merkle tree). If anyone tries to sneakily change a past experiment, the fingerprint won't match, and the system will know immediately.

The Big Test: Rewriting a Famous Study

To prove this system works, the authors didn't just build it; they used it to redo a famous scientific study published in the journal Nature. This study was about a specific enzyme (WRN helicase) and its role in cancer. The original study was written using fragile scripts and temporary files.

The team took the original data and rebuilt the entire argument inside Eigenius. They turned the "ephemeral scripts" into a solid, permanent "evidence graph."

The Result: All 52 of the study's derived conclusions held up when checked against the pinned data.
The Surprise: The process uncovered four discrepancies between the original paper's text and its actual data. For example, the original paper said a sample size was 54, but the data showed it was actually 51 because some rows were missing. Another error involved a statistical calculation that was off by thirteen orders of magnitude (that's a huge difference!).

These weren't just "oops" moments; they were recorded as machine-checkable facts, side-by-side with the original claims. The system showed that by forcing every step to be a "typed resource," the hidden errors in the original study became impossible to ignore.

Why This Matters

The paper suggests that as AI agents start doing more science on their own, we can't rely on messy, temporary files. We need a "kernel" (a core engine) that owns the type system, the storage, and the translation rules all at once. Eigenius proposes that by making the "audit trail" a permanent part of the data structure, we can build a scientific foundation that is robust enough for machines to trust.

The authors admit this is a prototype and that there are still open questions, like how to perfectly prove that their "typed merges" always work. However, their experiment with the Nature study suggests that this approach is viable. It turns the scientific method from a story we tell into a chain of evidence we can walk through, step by step, with a machine checking every link. It's not just about storing data; it's about storing the warranty for the truth.

Technical Summary: Eigenius: A Typed Knowledge-Graph DBMS with Epistemic Stratification and Institution-Mediated Reasoning

1. Problem Statement

The emergence of autonomous "AI Scientists" utilizing the Model Context Protocol (MCP) to drive research loops has exposed critical limitations in current scientific data infrastructure. Existing systems rely on ephemeral scripts and narrative prose, creating fragile pipelines where manual auditing is possible for humans but insufficient for autonomous agents requiring cryptographically secure, fully walkable proof chains.

Previous attempts to formalize machine-auditable science, such as the 2008 Pharos project, failed to scale because they relied on a federated architecture. Pharos stitched together disparate subsystems (SQL Server, DataNet, HOL theorem provers) via opaque, custom bridges. This approach lacked a unified kernel, resulting in:

Ontological fragmentation: Schema and instance data lived in different categories.
Lack of structural invariants: Cross-system translations were ephemeral and not formally checked.
Polystore bottlenecks: Integrating $N$ systems required $O(N^2)$ pairwise adapters.
Inability to unify reasoning: Empirical justification logic and formal mathematical proofs were handled by separate engines without a shared type system.

The core challenge is to build a database architecture that treats the "audit question" ("what do you know, and what is your warranty?") as a structural invariant of the data model itself, rather than a property reconstructed across subsystem boundaries.

2. Methodology and Architecture

Eigenius is an open-source, typed knowledge-graph DBMS built on a unified mathematical kernel. It replaces federated stacks with a single architecture that tightly couples the type system, storage engine, and integration protocol.

Core Pillars

Dependent Type Theory (EigenTT): The kernel uses a dependent type theory (CIC family) woven through the core. Schema and data are unified; declaring a class is simply committing a resource. The unit of commit is a layer—an immutable resource set with a parent pointer. Layer identity is content-addressed (SHA-256 of canonical CBOR), forming a Merkle commitment to graph history.
Epistemic Stratification: Every resource carries an epistemic status enforced as a strict commit-time invariant. The system distinguishes between:
- Declared: Authority without evidence (checked for well-formedness).
- Observed: Recorded with external provenance.
- Derived: Produced by typed computation.
- Verified: Carries a formally re-checked proof term.
  This stratification is based on justification logic, where warrants are not all factive, acknowledging that scientific claims rely on observations and conventions that cannot be discharged by a prover.
Institution-Mediated Reasoning: To integrate external reasoners (ODE solvers, theorem provers), Eigenius adapts Goguen and Burstall institutions as a strongly typed generalization of stored procedures.
- Comorphisms: Cross-system translations are modeled as comorphisms—strongly typed ETL pipelines executed natively inside the engine.
- Commit-Time Checking: Translations are statically checked at commit. If a transformation $m: S \to T$ does not match the payload types, it is rejected like a schema violation.
- Materialization: Unlike traditional federated databases where translations are ephemeral, Eigenius materializes the output of a comorphism directly into the graph as a durable, content-addressed resource.

Formal Verification Integration

To handle pure mathematics, Eigenius solves the challenge of verifying opaque proof payloads without incurring Inter-Process Communication (IPC) overhead:

In-Process Checking: The kernel links a minimal Rust term checker (nanoda_lib) directly into the binary.
Dependent Pairs: A verified claim is stored as a dependent pair $(P, t)$ , where $P$ is the proposition (native to EigenTT) and $t$ is the proof payload (opaque Lean 4 bytes).
The Binding Problem: At commit, the kernel performs a three-part check: (1) proof validity via the in-process checker, (2) mirror correspondence (mapping Lean constants to chain class IRIs), and (3) anchor consistency (hashing the source archive).

Query Language (EigenQL)

EigenQL is a typed stratified Datalog with aggregation and two specific clauses for institutional settings:

FIBER: Dispatches execution to an external institution mid-query.
INTO: Pins the external engine's response back into the chain at a named IRI, triggering the commit pipeline.

3. Key Contributions

The paper outlines four primary contributions:

C1: Unified Data Model: A self-describing typed-graph model that unifies empirical justification logic and formal mathematical proof. Epistemic status is a structural base class enforced at commit. Formal verification is handled via an embedded in-process term checker that binds opaque proof payloads to the schema without IPC.
C2: Institutional Integration Protocol: The introduction of institutions to the database world as strongly typed generalizations of stored procedures. Cross-system translations (comorphisms) are statically checked at commit and materialized as durable resources.
C3: Elimination of Polystore Bottlenecks: By lifting a shared, strongly typed Intermediate Representation (IR) natively into the graph's schema, comorphism transformations between systems sharing that IR collapse to pure identity, eliminating the $O(N^2)$ adapter cost.
C4: End-to-End Replication: A full recomputation and re-encoding of a published Nature study (Chan et al. on WRN helicase), moving from fragile scripts to a materialized evidence graph.

4. Results and Evaluation

The prototype, written in Rust with RocksDB storage and a gRPC API, was evaluated through microbenchmarks and a macro-evaluation.

Microbenchmark (Ingestion): The system ingested WordNet and UMLS lexicons (9.19M chain resources). It sustained approximately 5,200 validated resources per second on a single core. The commit gate is the primary cost, with structural class layers loading at ~28k/s and rigorously type-checked lexical entries at ~4k/s.
Macro-evaluation (Nature Study Replication): The system re-ran a high-profile study involving genome-wide dependency screens, wet-lab validation, and in vivo models.
- Consistency: All 52 derived conclusions held from pinned data.
- Discrepancy Detection: The recomputation surfaced four machine-checked discrepancies between the paper's prose and its data, including a corrected sample size ( $n=54 \to 51$ ) and a pseudoreplication error where the honest $p$ -value differed by thirteen orders of magnitude.
- Auditability: Every analysis class in the paper runs live; assumptions are inspectable resources rather than prose caveats.

5. Significance and Claims

The paper claims that Eigenius provides the necessary database kernel to support the next generation of AI-driven scientific research. Its significance lies in:

Structural Invariants: It turns data provenance and epistemic status from post-hoc reconstructions into structural invariants of the data model.
Agent-Ready Infrastructure: It addresses the "agent inversion," where autonomous agents require a tight loop of type-checking and testing (a "compiler" and "test suite") for scientific reasoning, which ephemeral scripts cannot provide.
Unified Epistemology: It successfully unifies two domains of scientific epistemology—justification logic for empirical science and formal verification for mathematics—within a single engine.
Verifiable Audit Chains: It enables a "closed audit chain" where an auditor can re-walk the entire proof path from a verdict back to the raw data and proof terms using only the graph, without contacting intermediate middleware.

The authors acknowledge limitations, including the decision to abandon Wasm for containerized substrates to support heavy native libraries, and the ongoing need to mechanize the validator and comorphism type-checker. The ultimate goal is to enable an AI Scientist to traverse, mutate, and verify scientific graphs without human intervention.