Tree-D Interactive · Knowledge substrates for AI systems

01 / Memory

Memory: three surfaces, one substrate.

Nobody adopts a geometry engine. They adopt the thing that solves the problem in front of them. These are the three that carry the substrate in, ordered by how contested the knowledge is.

seraph-memory

An AI that remembers.

Plain solo recall

An MCP server that gives any assistant persistent, self-organizing memory. Talks to the engine over its C ABI, so there is no Python runtime in the path. Registered once, then available in every project.

Public Rust MIT

Agora

An AI whose memory cannot lie to itself or to you.

Contested knowledge

Every belief is stamped with the agent that asserted it. Conflicting claims are surfaced at write time, not three hops downstream. Any conclusion walks back to the document passages it rests on, and renders as a cited memo you can hand an auditor.

Public 13-tool MCP Workspace UI

Ergon

A swarm that does not repeat itself and can prove what it did.

Multi-agent work

A blackboard where the blackboard is a semantic geometry. Two agents converging on the same subproblem collide at write time, so duplicate work is caught with no coordinator, no message bus, and no queue. Failed attempts are first-class records that surface before anyone retries them.

Public 15-tool MCP Run + commons

Underneath all three

SERAPHone .sfg file

The same engine and the same file format carry all three products. A store is append-only and tamper-evident: nothing is overwritten, retraction is itself a recorded event, and every record is chained to its predecessor so any alteration breaks the chain at verification. Send the file to someone who has never seen your systems and they can open and verify it on their own.

This is deliberate sequencing. The product answers a felt problem, the Free tier lets it run immediately, and the substrate arrives underneath.

02 / Core asset

SERAPH

Vector stores answer what is similar. Graph databases answer what is connected. You query one for candidates and traverse the other for context, and the seam between them is operational overhead, consistency risk, and a conceptual mismatch.

SERAPH removes the seam. Content is not assigned to a taxonomy; each item lands adjacent to what it resembles, and the shape of the store emerges from the content itself. Applications can still declare exact relationships, held as an overlay that does not distort the geometry beneath. Most systems force a choice between emergent similarity and declared structure. SERAPH keeps both in one store with a clear boundary between them.

Queries compose a similarity walk, a lineage walk over how content arrived, and a walk over declared relations, in one continuous expression. The same store and the same query return the same result, in the same order, with the same scoring, every time.

NameSemantic Retrieval Architecture via Probabilistic Hashing

StoreA single fileTransferable, and verifiable by the recipient with no other system

IntegrityWatermark chainPer-record Ed25519 signing in Commercial and Enterprise, bound to a key the customer alone holds

ModalityEncoder agnosticText, images, audio, code, scientific and behavioral data

RuntimeNo external servicesNo database server, no separate vector index, no network calls

CompartmentsEnterprise tierBell-LaPadula enforcement, FIPS signing, classification markings folded into the chain, and an audit that verifies integrity without exposing content

ProtectionProvisional patent filedMethod preprint published and publicly citable

Free

The substrate itself

Emergent geometry, declared relations, deterministic pipelines, and the tamper-evident watermark chain, which covers both layers in every tier. Enough to build on.

Commercial

Provable authorship

Adds per-record Ed25519 signing under a writer key the customer alone holds, binding authorship to something provable even against us.

Enterprise

Compartmented control

Adds Bell-LaPadula enforcement, per-operator FIPS signing, classification markings folded into the chain, and an audit that verifies integrity without exposing compartmented content.

The license server is live and every install checks in with it, including Free. Adoption is measurable from the first install rather than inferred later.

03 / Code intelligence

Code: three surfaces, one substrate.

The same shape as the memory line. SymbolGraph turns a codebase into a graph the compiler resolved, so an agent stops burning context grepping and guessing and starts querying facts. Built and in daily internal use, on Neo4j, and not yet released.

Extension

Every language you already have a server for.

Extraction

A VS Code extension rides the Language Server Protocol, the same infrastructure behind go-to-definition, to extract every symbol, type, call, and import. No custom parsers to write or maintain, with dedicated extractors where LSP falls short, including C++ and Unreal Engine reflection macros. A React Flow view renders the same graph the agent queries, so you can trace a call path and watch the map update as you write.

Internal use LSP Webview

Tool surface

68 tools any assistant can call.

Retrieval

An MCP server exposes the graph over stdio. Resolve a symbol and get its real signature, callers, and callees. Compute the blast radius of a change before making it. Assemble a token-budgeted context pack for the exact function being edited, instead of paying for a search that returns the wrong file.

Built, unreleased MCP / stdio

Governance

Drift computed from code, not claimed in a stale file.

Assurance

Requirements, interfaces, invariants, and decisions are authored as graph nodes and bridged to the symbols that implement them. Implementation state and specification drift are derived from the code itself. The graph is the source of truth, and the documents and diagrams are projections of it.

Distinctive Spec as graph

Substrate

ZGraphin development

Today this line runs on Neo4j

ZGraph is the replacement, and is not finished. A native property-graph database in Rust: fixed-width records in a pointer-swizzled buffer pool, adjacency as sorted delta-varint chunks under 4 bytes per edge, so traversal is pointer-chasing rather than index lookups. On top sits ZQL, an openCypher-compatible language with a real planner, executed by a vectorized engine with worst-case-optimal joins. Snapshot isolation over a write-ahead log, persistent B+tree indexes that turn 24 ms scans into microsecond seeks, and graph algorithms callable from queries. Runs embedded as a crate or as a server with auth on by default.

Neo4j is a license, a JVM, and a deployment constraint that every customer would inherit. Removing it is a precondition of release, and the reason SymbolGraph is not out yet.

04 / Simulation

A third line, at the same depth.

Fe₂O₃D

Engine and editorRust · Vulkan

A 3D engine and editor written from the graphics API upward, whose bet is unification. One editable signed-distance field feeds rendering, global illumination, physics, fluids, audio occlusion, and navigation, instead of each subsystem keeping a private copy of the world. One reflection spine feeds serialization, the inspector, scripting, networking, and the agent tool surface. It simulates in f64 world space with camera-relative rendering, so worlds can be planetary without losing precision. Because that field is a first-class analytical object in real spatial coordinates, the same codebase serves as a digital-twin and GIS simulation platform, a second use created by the engine work rather than grafted onto it.

05 / Also built

Two that stand apart.

Neither belongs to the product lines above. Both are live, and both are linked, because working software is better evidence than a description of it.

Space Weather Dashboard

Real-time solar and geomagnetic conditions rendered on a 3D globe: solar wind, coronal mass ejections, geomagnetic indices, and aurora forecasts, drawn from public NOAA feeds with temporal playback.

Public and running. The shortest demonstration of the real-time geospatial rendering that Fe₂O₃D pursues at a very different scale.

Live CesiumJS Open it

Loom

A visual development environment for Python. Programs are composed as a node graph that generates real, readable source rather than running an interpreted sandbox. It reached beta with a full node library and a code-generation test suite.

Available to customers and maintained, and deliberately not a growth investment. Language models absorbed most of what visual programming offered, so the attention goes to the substrate work instead. It stays up because it works.

Available Not marketed Account required Open it

06 / Position

Why this is difficult to replicate.

Protected method

Filed, not claimed

Covered by a filed provisional patent and described in a published preprint. Documented enough to be examined, protected enough to be owned.

Portability

The file is the product

A store can be emailed, signed, notarized, or archived, and a third party who has never seen your systems can verify it in full. Nothing comparable ships as a single artifact.

Accreditation

Reaches compartmented environments

Bell-LaPadula enforcement, FIPS signing, and classification markings inside the integrity chain. A sealed store transfers between organizations and verifies on arrival, which a hosted service cannot do at all.

Commercial model

Open core, already running

Application layers are permissively licensed while the engine stays proprietary. Three tiers, a live license server, and a Free tier that lets the products run on first contact, so the substrate arrives underneath a working tool rather than behind a paywall.

Coherence

One idea, two markets

Verifiable structure instead of inference from text, applied to knowledge and to code. Two product lines, two substrates written at the storage layer, and no vendor license to renegotiate after a transaction.

Operator

One engineer, no payroll

Built by a single principal engineer working with heavy AI leverage, whose current work is modeling and simulation for government programs. Auditable, reproducible retrieval is a requirement drawn from that environment.

07 / Status

Where things actually stand.

Every product below is public and installable. Scope limits are stated with them, not omitted.

System	State	Detail
SERAPH	Live	License server running with three tiers. Free tier is usable on install, so the memory products run on first contact. Published as a Python wheel and self-contained FFI builds. No paid conversions yet.
SERAPH	Patent filed	Provisional application. Method preprint published and publicly citable.
seraph-memory	Public	Rust MCP server over the engine C ABI. Shared-daemon process model so one writer serves every session.
Agora	Public	Library, MCP server, and browser workspace. Every documented claim is backed by a deterministic test in the repository.
Ergon	Public	Library and MCP server, proven by deterministic simulations including 50-session write contention.
SymbolGraph	Unreleased	VS Code extension, graph webview, and a 68-tool MCP server, all built. Used daily against our own codebases. Neo4j-backed today.
SymbolGraph	Unreleased	Governance layer: specification authored as graph nodes bridged to implementing symbols, with drift computed from code rather than asserted.
ZGraph	In development	Storage engine and ZQL planner functional, with persistent indexes and callable graph algorithms. Replaces the Neo4j dependency.
Space Weather Dashboard	Live	Public real-time visualization on a 3D globe, drawing on NOAA space weather feeds.
Loom	Available	Visual development environment for Python. Open to customers and maintained, with no acquisition spend behind it.
Fe₂O₃D	In development	Rendering, physics, and SDF terrain in place. Editor and runtime developed together.

Deliberate scope

SERAPH is single-writer and ZGraph is single-node. Both are design choices rather than gaps, taken because the storage layouts that make them fast are the ones that make distribution a separate problem. seraph-memory currently targets Windows on x86_64. In Agora, authorship is recorded as queryable metadata while the chain remains tamper-evident; per-agent cryptographic signing is deferred to the federated model. SymbolGraph still requires Neo4j until the ZGraph migration lands.

08 / Services

Contract engineering underwrites the research.

Available for selective engagements in simulation architecture, graph and knowledge-system design, and platform work for regulated environments. The technology is the asset; services keep it independent of outside capital.

Discuss an engagement

09 / Contact

Start a conversation.

A technical brief, licensing terms, and architecture documentation are available on request. Say which system you are interested in and we will send material specific to it.

Request the brief

Emailcontact@tree-d-interactive.net

EntityTree-D Interactive LLC

LocationUnited States

SERAPHseraph-db.com

Sourcegithub.com/Tree-D-Interactive-LLC