Trible.Space

One ground truth.
Immutable, signed, yours.

A content-addressed knowledge graph: every fact immutable and cryptographically signed, every merge conflict-free — and all of it on infrastructure you own.

Try on GitHub Read the book

The hard part isn't storing data.
It's trusting it.

It gets overwritten.

Updates destroy the past. What you read today may not be what was written yesterday — and nothing tells you what changed.

It drifts into copies.

Every tool keeps its own version. They diverge, they conflict, and reconciling them becomes a project of its own.

You can't verify it.

You trust the database because you have no choice. No proof of who wrote a fact, when, or whether it has been tampered with.

Facts that don't move.
Merges that don't fight.

A knowledge graph where every fact is immutable and signed, identity comes from content, and any two copies merge without conflict — by construction. Verifiable. Sovereign. Yours.

Facts are immutable.

Nothing is overwritten — facts are added, never changed. History comes free, and what you read is exactly what was written.

Merges are conflict-free.

Synced data only ever grows, so any two copies merge to a single outcome — no conflicts, no coordination — in a file, an object store, or a DHT alike.

Every fact is signed.

Identity is content-addressed and cryptographic. Verify who wrote what without trusting the store — or us.

Monotonic globally.
Mutable locally.

Sync only ever sees append-only facts, so peers can't conflict. But locally, compare-and-set gives you real mutable state — move a branch, change your current view — without ever weakening that guarantee.

Write a fact.
Query it anywhere.

Add a fact in one store, read it from another — the merge can't conflict.

Writer — add a fact
kb += entity! {
    work::title: "Fix auth timeout",
    work::status: "done",
    work::signed_by: &agent_a,
};

// Commit to the workspace.
ws.commit(kb, "resolve auth timeout");
Reader — query it
// Everyone reads the same ground truth.
let catalog = ws.checkout(..)?;
let done = find!(
    (title, author): (Inline<_>, Id),
    pattern!(&catalog, [{
        @ work::status: "done",
          work::title: ?title,
          work::signed_by: ?author,
    }])
);

The Ecosystem

Three open-source projects, one shared substrate.

TribleSpace

The substrate. Content-addressed knowledge graph with conflict-free merges, cryptographic signing, and worst-case optimal queries.

Faculties

The tools. A shared workspace for AI agents — kanban, wiki, files, messaging, memory — all in a single file.

GORBIE

The interface. A minimalist notebook for Rust — no server, no file format, just native code and egui.

Systems decay from the bottom up.

Every fix layered on a broken foundation becomes its own debt. So we built the foundation right — trust, history, and portability as properties of the data, not features bolted on after.

Content-addressed identity.

An entity's name comes from its content, not a central authority — so the same fact is the same fact in a local file, an object store, or a DHT, and anything merges with zero coordination.

Verify it yourself.

Every fact is cryptographically signed. You never have to take the store's word for it — or ours. Check the signatures.

Worst-case optimal queries.

A real query engine — patterns, joins, graph paths — that reorders by cardinality and doesn't fall over on graph-shaped questions.

Data sovereignty, by construction.

One canonical, open format on infrastructure you own. No cloud, no lock-in, no proprietary export to beg for. Yours because of how it is built.

Open Core. Free to Start.

Built in Bremen. Deployed everywhere. MIT / Apache-2.0.

Star on GitHub Talk to Us