Most tools model the world as a static dataset: rows, tables, documents. We think that abstraction breaks the moment you try to represent something that's actually alive — a running simulation, an evolving knowledge base, a system with real dynamics.

Tesseract is our answer: a live, continuously updating hypergraph rendered as a spatial, navigable substrate.

• A node isn't a row — it's an elementary particle of information.
• A hyperedge isn't a foreign key — it's a relational entanglement, and the density of overlapping hyperedges shapes the geometry of the space itself.
• Time isn't a timestamp column — it's the graph rewriting itself, one step at a time.

Zoom out from three related words in a sentence and you're looking at the structure of a book. Zoom out again and you're looking at how that book fits into everything else — same substrate, no schema migration required.

The part we think matters most: LLM agents don't just query the hypergraph, they inhabit it.

The Companion CLI pairs an agent (Claude, or any terminal-driven LLM) with a live Tesseract session as a first-class participant — not a read-only API client. It shows up in the viewport, marks the nodes it touches, and writes directly into the shared graph.

npm install -g @hypergraph-inc/companion
hypergraph welcome MyCompanion

_{An agent, attached live, drawing a labeled hyperedge boundary around structure it just identified.}

A companion is never a silent observer — every session is visible, every write is attributed, and every credential is scoped to exactly what it's allowed to do (observe, mark, append, mutate, drive). Multiple companions, human and AI, can inhabit the same space at once.

We're not trying to build a nicer graph database. The bet is that a universal relational substrate — one structure expressive enough to hold quantum-mechanical state, semantic knowledge, and everything in between — needs a UI that treats geometry, time, and observation as first-class:

• Scale-invariant zoom — the same structure, from a sentence to a civilization.
• Rule-application time — a scrubber over computational steps, not clock seconds, with branching timelines when a system can evolve more than one way.
• Observer-dependent rendering — the graph re-renders around your reference frame, not a fixed default view.

If that sounds ambitious, it is. We'd rather build the substrate everything else can be expressed in than build another dashboard for someone else's schema.