In graphs today, a relationship is at best a first-class citizen — a real object beside the nodes. That isn't far enough. A relationship isn't one citizen among equals; it is the First Citizen — and it doesn't just describe the world, it executes it.
What it is
Nobody collaborates from their own bank. Two parties — a person and a model, an agent and a system, one world and another — stand on opposite sides, each with their own ground under them, and nothing happens until someone crosses.
That's why The Intelligent Graph is bridgework, not a building — the span that carries the Collaboration Paradigm into implementation. Architecture gives you a place to move into: rooms, walls, a platform you're then stuck on. A bridge is no destination at all. You connect to it, cross it, and extend it — relationship-first infrastructure your people, models, and agents traverse and build onward from.
And a bridge isn't built to be admired. It's built to be crossed. Crossing is an action — and in the graph, the crossing is a traversal. That's why execution isn't a feature bolted onto the bridge; it's what a bridge is for: to collaborate, you cross. To cross, you traverse. A traversal executes.
A bridge is a relationship made traversable — and collaboration is the crossing.
Begin with being
Relationships in graphs today are treated two ways. In the RDF stack, they're buried inside predicates. In Neo4j, they're promoted to first-class citizens: real objects, with identity and properties of their own.
Building from the original definition of ontology: nothing exists until the very concept of existence exists — something exists, OR it doesn't. You need the OR before the thing. To exist is to be an element of a set, and membership is that OR — in, or out. The distinction comes first, and a distinction is a relation.
So relationships are not just first-class citizens. They are the First Citizen.
Relationships realize entities. Realization is an action. A relationship isn't glue between two real things — it is what makes them real, and a thing that does. Reticulation, not reification.
Vector to the mathematics
Inference — derive what follows from what's said — is only the first floor. An operation's order is the order of structure it reaches over:
Model the graph as a cellular sheaf: data on every node and edge, with rules for how they must agree. A view becomes a section; consistency becomes cohomology — H⁰ is what holds together (knowledge), H¹ is the contradiction that can't (the obstruction). Grounding is driving H¹ toward zero.
The full consistency engine is the direction, not a shipped feature — we build toward it in the open. Read the math →
What this lets us build
The field has caught up to the substrate: extractors, memory platforms, and context graphs now emit rich relationship layers natively. That layer is real — and it is fast becoming table stakes. But it only describes. Ask what any of it does and the answer is: it waits to be queried. The missing layer isn't the relationships — it's the execution model that makes them run.
What it does
Attach read-only to your source's native relationship layer — the graph it already emits.
Type each raw relationship into a traversable graph — keeping the original string, so re-typing later is a single traversal, not a re-import.
Behavior binds to the Kind of relationship traversed. The execution model is defined; the engine that runs it is being built in the open.
Provenance is a property, not a supernode. Every step is reversible by construction. We attach to your graph; we never restructure it.
Why it's different
The register ladder
The point of bridgework is that it connects. Every concept has a word an executive can use, a word the graph implements, and a word the mathematics proves — and they map cleanly onto one another. The Intelligent Graph is the middle rung: the representational bridge between the everyday and the formal.
| Colloquial · Professional | Representational · TIG | Mathematical · Formal |
|---|---|---|
| Participant | Node / Entity | Object / Element |
| Steward | Curator / Governor | Observer / Constraint |
| Community | Sector / Scope | Group / Subspace |
| Collaboration Space | Graph Space | Manifold / Topology |
| Relationship | Edge / Contract | Relation / Morphism |
| Bridge | Traversable Edge | Mapping / Functor |
| Representative | View / Projection | Section |
| Fold | Identity Merge | Quotient / Equivalence |
| Reticulate | Structure Formation | Sheaf Gluing |
| Traversal | Path | Composition |
A bridge is a relationship made traversable; an edge, a relationship made representational; a morphism, a relationship made formal.
TIG + Solstone
The Intelligent Graph pairs with Solstone — Jeremie Miller's local-first memory platform — to turn a passive capture stream into a structured, queryable, annotatable graph. Sol emits a native relationship layer — one that TIG's structural findings helped shape. TIG grounds that layer into a formal, executable graph and feeds curated identity and interpretation back, so the source gets smarter each cycle. The loop runs both ways, on the record. Built for teams who want their own graph, on their own machine — not a hyperscale deployment.
Open core
The core will be open source (Apache 2.0) — we're building it in the open. A commercial layer adds the operational and agentic capabilities teams pay for.
Who's behind it
Built by Michael Bauer — a 35-year through-line from rule-based expert systems to a billion-node production graph. → michaelbauer.com
Presenting at Neo4j NODES 2026 (Nov 12), featuring Solstone: "The Intelligent Graph."