The eleven boards of the explainer, in order. The concepts page walks the important ones; this page is the whole canvas, for reading end to end. Boards 7 and 8 are the timeline and the direction: what shipped, what is in progress, and what each step lets an agent newly ask.
1 · LPG vs DPG
LPG vs DPG
LPG · Labeled Property Graph
DPG · Domain-Parameterised Graph
instance graph
instance graph
type graph
type graph + semantics
FUNCTION createOrder { file, line }
FUNCTION saveOrder { file, line }
FUNCTION
FUNCTION
QUERY meaning is rewritten in every query, for every domain
{ emitter: resolver:http, rule: route_match, file: web/api.ts, line: 42, basis: site } → tier DERIVED(emitter + rule, at query time)
CLASS Orderinterface · TS
CLASS Orderstruct · Go
Orderone node
HTTP_CALLS
HANDLED_BY
CALLS
evidence cell
http_model rule
quotient: walks see one node
FACTread at a site
DERIVEDpaired by a resolver
HEURISTICa guess
an answer inherits the tier of its inputs (provenance semiring): weakest along a path, best across alternative paths
identity = ten rules (package_name, message_fqname, http_model, …), each with its own tier. SAME_AS is a star: each member points at the class centre; weight 0 in PPR, never carried, acts only through the quotient
4 · Space and time
Space from the DPG, time from git
space · the DPG inside one snapshot
time · git DAG of snapshots
MODULE web/api.ts
MODULE server/orders.go
MODULE server/db.go
HTTP_CALLS valid a1f3 → c9e0 · timeline.gmap sidecar, last --revs
HTTP_CALLS
IMPORTS
co-change · read at query time
a1f3
b72c
c9e0
d410
e55a
this snapshot
git is the time axis (a DAG of snapshots); the DPG is the space axis (what is inside one snapshot)
neither lives in an edge cell: co-change sits in the history snapshot and is read at query time (ranking, glia cochange, the cochange_no_edge gap); validity spans live in the timeline.gmap sidecar
5 · Stacked domain graphs
Stacked domain graphs: structure yields information
each layer is its own DPG; glue edges join shared concepts; one walk crosses layers and the answer falls out of the shape
DERIVED · doc likely stale api/orders.md(via DOCUMENTS)
FACT · rebuild db-lib, api-server
LINKS_TO
HANDLED_BY
CALLS
DEPENDS_ON
DOCUMENTS
IN_TARGET · planned
IN_TARGET · planned
blast radius of saveOrder, read off the structure
no layer knows the others. The glue edges are the pushout: the shared concept exists once in the knowledge graph, so a walk from one layer reaches the rest. The tier of each result is the weakest edge it crossed.
6 · Many graphs, many layers
Many graphs in a layer, many layers in one knowledge graph
three repos (three languages) in the CODE layer, glued to each other and to docs, data and deploy. One order placed end to end.
docs · today inside the code domain
code · three repo graphs, one layer
data · planned domain
deploy · planned domain
web · TypeScript
api · Go
worker · Rust
PAGE api/index.md
PAGE checkout.md
PAGE runbook.md
COMPONENT CheckoutPage
ENDPOINT POST /orders
ROUTE POST /orders
FUNCTION createOrder
FUNCTION publishOrder
MESSAGE_TYPE OrderCreatedGo
FUNCTION handle_order
MESSAGE_TYPE OrderCreatedRust
TABLE orders
TOPIC order.created
SERVICE web
SERVICE api
SERVICE worker
LINKS_TO
DOCUMENTS
name match
CALLS
HTTP_CALLS
HANDLED_BY
CALLS
EMITS
SAME_AS
HANDLED_BY
WRITES · SQL
PUBLISHES_TO
CONSUMES
DEPLOYS
DEPLOYS
DEPLOYS
INGRESS
shipped: three repo graphs glued by HTTP_CALLS and SAME_AS (quotient), and DOCUMENTS inside the code domain. Planned: WRITES, PUBLISHES_TO, CONSUMES, DEPLOYS and the data / deploy domains. Dashed boxes are repo graphs; bands are domains; the whole thing is one DPG.
a change to the Go OrderCreated struct now reaches: the Rust consumer, the topic, the worker deployment, and checkout.md. Weakest edge on each path sets the tier.
7 · Uplift and features timeline
Uplift and features: from LPG to DPG
above the rail: what ships. Below: the question an agent can newly ask. Solid = shipped, dashed = planned.
Profile as data 0.5.0 CODE_TABLES / DomainTables 0.5.1 to 0.5.3 · 6 MCP tools 10 identity rules, quotient walks VS Code, plugin, MCPB
DPG formalised the model named cell {emitter, rule, file, line, basis} tier computed at query time toy-domain test proves the seam
0.5.4 · in progress embeddings + semantic tiers goal layer (TRACES), placement bazel targets: first non-code domain incremental, multi-repo watch
0.5.5 · proof precision rate on real repos agent before / after at scale calibrated confidence decide/ and glia judge
Glue + typing glue kinds in both profiles type graph + triple check stacked layers above code time read inside the walk
~0.5.7 · the bar purpose → specs → code walks the walker: tasks, intents use-dependent plasticity "a new era dev tool"
early 2026
Jun 2026
Sep 2026
now · Oct 2026
0.5.4
0.5.5
direction
~0.5.7
where is X, who calls X, what breaks if X changes
same answer every run, inside a token budget
TS, Go and Rust read as one program; any agent, one install
how sure is this, and where did it come from
what is this about, where should this change go
how good is it, measured, not claimed
what does this touch outside the code, and since when
why does this exist, which decision does it serve
GATE before any uplift claim: a clean with / without repo-graph A/B on SWE-bench Lite. Cycle 4.0 = 22/323 on 14B Q4, 18 of 22 in Django. No measured lift number exists yet.
each step changes the question, not just the feature. LPG answers "what"; the DPG steps add "how sure", "across what", "when", and finally "why".
8 · Future features and direction
Direction: many domain graphs, one knowledge graph
code is one domain among many that say what is to be made, why, how, because, and what went wrong. Each item below becomes a packet only with a registered test.
how a domain relates to code
stacked graphs · measured
llm uplift · the graph as substrate
1 · same entities, another zoom function → module → build target → service → deployment
2 · facts about code, no entities of their own history, tests, docs, ADRs, decisions, issues
3 · linked domains, own entities infra, DB schemas, API contracts, runtime; joined by identity or contract
4 · separate domains video, molecules, policy, legal citations, biology pathways; same engine, own profile
linking N domains costs N + K: one resolver per key type, one tiered joiner
purpose law, policy, intent
milestones plans, requirements
specs · tasks goal layer, 0.5.4
code the DPG today
explains, does not predict compiled down into the layer below. Earns its place when it changes: law amended → requirements wrong → code to change. Impact from above.
predicts change requirement ids shared by 16 to 19% of co-change pairs vs ~1% at random. A plan naming its files: recall@10 0.890.
co-changing files are siblings under a shared upper node; the vertical edges live in other layers
today · dense sigil text, 40 to 70 tokens per entity vs 150 to 200 ranked, located, tiered answers; context packed to a token budget
next · 0.5.4 · per-node vectors, glia embed, semantic tiers beside the lexical answer gate FB.6: beats a random-vector control on 5 of 6 repos, BM25 on 3 of 6
further · graph structure fed to the model directly latent projection, graph-aware attention (CGM); steering through task framing, the lever the latent experiments found
calibrated decisions · decide/, glia judge: a small local model making typed calls always HEURISTIC, never deciding truth; clarification queue instead of silent guesses
ranking never decides: rankings and vectors reorder rows, never add or hide a FACT / DERIVED row
biology as the design source · glia let neurons talk; glia lets agents talk to a structured graph and to each other
multicellular nodes typed cells on every node: code, intent, doc, test, fail, constraint, decision, conv, attn, position, vector
spreading activation PPR over the graph, after HippoRAG's hippocampal-indexing model of memory. Shipped.
use-dependent plasticity edges strengthened by the work that crosses them: weight × (1 + β × co-change support). Engram's learning from use, at repo level.
pruning shows inefficiency where independent gains converge is the real shape; what each prunes (hub floods, edges no work crosses) marks the waste
consolidation fold, don't forget: corrections written back as cells, at sleep
the missing walker the graph models the territory, nothing models the person walking it: task → intent → touched → outcome. Co-change is its fossil record.
also open: type graph + triple check · cross-domain glue kinds · visual domains through the same vector contract · e-graphs for identity · bi-temporal edges · evidence calibration (noisy-OR / Dempster-Shafer) · succinct structures at monorepo scale · data lineage as a domain · dominators, RuntimeZone, LSP
0.5.4 ships only when every track lands and tests · 0.5.5 is proof (precision on real repos, agent before / after at scale, calibrated confidence) · around 0.5.7 the bar: a new era dev tool
9 · World domains as the why
World domains as the why: the reason the code exists lives outside it
finance, law, biology, chemistry, manufacturing: each its own domain graph with its own profile, same engine. Glue edges point down into the code that implements them. Direction, not shipped.
world layers · category 4 domains, own entities
FINANCE · carry HAS_RULE · identity: calendar id
LAW · carry CONTAINS, AMENDS · identity: citation
BIOLOGY · carry HAS_STEP · identity: KEGG id
CHEMISTRY · carry REQUIRES · identity: CAS no.
MANUFACTURING · carry HAS_STATION · identity: asset id
REGIME ASX settlement
RULE settle T+2 business days
CALENDAR AU trading days
ACT AML/CTF Act 2006
SECTION s 43 threshold reports
OBLIGATION report cash ≥ A$10,000
PATHWAY glycolysis
ENZYME hexokinase
REACTION glucose → G6P
PROCESS Haber-Bosch
CONSTRAINT 400 to 500 °C · 150 to 300 bar
HAZARD H₂ flammability
LINE SMT line 3
STATION reflow oven
TOLERANCE profile ±5 °C
code · the DPG today
FUNCTION settlement_date()
FUNCTION · seed flag_threshold_txn()
FUNCTION simulate_flux()
FUNCTION clamp_setpoint()
FUNCTION validate_profile()
HAS_RULE
USES
IMPLEMENTS
CONTAINS
IMPOSES
REQUIRED_BY · citation
HAS_STEP
CATALYSES
MODELS · KEGG id
REQUIRES
CARRIES
CONSTRAINED_BY
HAS_STATION
SPEC
ENCODES · text match
why does this exist? walk up from flag_threshold_txn: REQUIRED_BY s 43 → CONTAINS → AML/CTF Act 2006. Answer tier DERIVED (the citation resolver set it).
the world changed: Act amended (AMENDS edge, new validity span) → s 43 obligation now wrong → flag_threshold_txn and its tests are in the blast radius. Impact from above.
same evidence cell on every world edge, tier from emitter + rule. One resolver per key type: citation (law), id lineage (KEGG, CAS), table row (calendars), scoped id (asset ids), text fallback. World nodes are compiled down into code, so they explain change rather than predict it, and earn their place when they move.
10 · Full example: world to deployment
Full example: an ammonia plant control system, world to deployment
four world domains above, three repos in three languages, data and deploy below. One regulation changes; the walk finds everything that is now wrong. World layers and cross-domain glue are direction, not shipped.
world · own domains, own profiles
docs · inside the code domain today
code · three repo graphs
data · planned domain
deploy · planned domain
MANUFACTURING · asset id
CHEMISTRY · process / CAS id
LAW · citation
FINANCE · contract id
hmi · TypeScript
control · Rust
analytics · Go
PLANT ammonia unit 2
ASSET reactor R-101
STATION PLC-7 setpoint loop
PROCESS Haber-Bosch
CONSTRAINT 400 to 500 °C · 150 to 300 bar
HAZARD runaway above 520 °C
REGULATION WHS (MHF) Regs
CONDITION licence: safety case
REQUIREMENT alarm on T > 520 °C within 2 s
CONTRACT gas supply, take-or-pay
SCHEDULE price by hour
TARGET min cost at rate ≥ 95%
PAGE SOP: setpoint change
PAGE runbook: alarm response
COMPONENT ReactorPanel
ENDPOINT POST /setpoint
ROUTE POST /setpoint
FUNCTION clamp_setpoint
FUNCTION · hit publish_alarm
MESSAGE_TYPE AlarmRust
MESSAGE_TYPE AlarmGo
FUNCTION report_incident
FUNCTION optimise_setpoint
TIMESERIES reactor_telemetry
TOPIC plant.alarms
TABLE incidents
SERVICE hmi · edge
SERVICE control · PLC gateway
SERVICE analytics
HAS_ASSET
CONTROLLED_BY
REQUIRES
CARRIES
IMPOSES
SPECIFIES
PRICES
DRIVES
OPERATED_FROM · asset id
CONSTRAINED_BY · id
REQUIRED_BY · citation
OBJECTIVE · text
DOCUMENTS
DOCUMENTS
CALLS
HTTP_CALLS
HANDLED_BY
CALLS
EMITS
SAME_AS
HANDLED_BY
WRITES
PUBLISHES_TO
CONSUMES
WRITES
DEPLOYS
DEPLOYS
DEPLOYS
the regulation changes: MHF Regs amended, alarm within 1 s. New validity span on the REQUIREMENT; everything in teal is now in the blast radius: publish_alarm, both Alarm types, the topic, report_incident, the incidents table, the runbook, two deployments.
why does clamp_setpoint cap at 500 °C? walk up: CONSTRAINED_BY → Haber-Bosch constraint, CARRIES → runaway hazard; sideways: the LAW requirement names 520 °C. Two world domains, one function, both answers tiered DERIVED.
weakest edge sets each answer's tier: the FINANCE objective is HEURISTIC (text match to a contract PDF), so anything reached through it is HEURISTIC too. Stable keys (citation, asset id, process id) are what let a world domain be DERIVED rather than guessed.
11 · Compared with other graph models
Compared with other graph models
model
an edge carries
schema
semantics
provenance
time
RDF triple store, Semantic Web
a predicate IRI only; attributes on an edge need reification or RDF-star
optional, global ontology (RDFS, OWL)
logical entailment; one global meaning for a predicate
named graphs; per statement at best
none built in
LPG Neo4j, Cypher, GQL
a type plus key-value properties
none, or optional constraints
none; meaning is rewritten in each query
whatever you put in a property; no rule
none built in
Typed attributed graph graph grammars, Ehrig et al.
a typed edge plus attributes
a type graph; the instance is typed by a homomorphism
none; rewrite rules act on structure only
none
none
Hypergraph HypergraphDB, set systems
one edge joins any number of nodes
optional
none
none
none
DPG glia
a type, cells, and an evidence cell: emitter, rule, file, line, tier
a type graph per domain; domains glued by a pushout
a domain profile: entry, carry, weights, identity; swappable
every edge; tiers compose into the answer
git beside it: validity spans, co-change edges
DPG = typed attributed graph (type graph, typing homomorphism) + LPG cells + a semantics profile per domain + evidence on every edge + git as the time axis. Typed graphs give it the formal spine; LPG gives it the data shape; the profile and the evidence are the new parts.