Graphonomous is an autonomous semantic/evidence graph that continuously constructs, tests, relates and explains a model of what a system understands. Not a database, though it stores; not a compiler, though it has compiler-shaped machinery inside it; not an interpreter, because execution lives elsewhere. It is the semantic self-model of a ComputeDriven system: read from the registries that hold the system’s truth at pinned commits, sealed as a WallRiderLang world under a vocabulary it declares as data, certified through TRVM, and held downstream of every authority it reads. What it believes, why, what contradicts it, what depends on it, and what would prove it wrong — that is the model, and the model is meant to get simpler as it learns.
The stack has converged on three parts that each own one thing. Press one.
the world these three run in: an operating system whose backup is the user's machine, and the compute surface above it
ComputeDriven →WallRiderLang describes understanding. A world is a content-addressed description; a vocabulary is a profile row; meaning is a hash.
WRL →TRVM reduces and derives understanding. It is the execution and reduction engine, and it mints the certificates Graphonomous carries.
TRVM →Graphonomous stores, connects, explores, tests and evolves understanding: the semantic self-model of a ComputeDriven system, read from the registries that hold its truth.
Graphonomous →Super is the operating environment around all of this — the surface that lets humans and artificial beings actually use it. Its blueprint gives every agent a memory that survives an engine swap, and Graphonomous is what is meant to fill that slot. Today Graphonomous reads Super's evidence at a pinned commit; the rest is designed and not built.
Super (CD) →It is downstream of authority by design. It observes, relates, derives, diagnoses, ranks and proposes; the registry, factory or adjudication that owns a fact decides whether a proposal becomes canonical. It never silently decides truth and never becomes another authority. A normal graph database says: here are the relationships you stored. This one is heading toward: here is what I currently believe the relationships are, why I believe them, what observations produced them, what contradicts them, what depends on them, how they changed, and what experiment could tell us whether they are wrong.
A compiler constructs a model of a program so that the program can be transformed. Graphonomous constructs a model of a system’s understanding so that the understanding itself can be transformed. The semantic projection is the IR. The rows on the right are marked by what exists in the tree today; the last one is not ours by design.
What is being compiled is not source. It is what the system currently knows · where that knowledge came from · what depends on what · what contradicts what · what observations support it · what would falsify it · what simpler explanation could replace it.
Observation becomes evidence, evidence becomes structure, structure yields dependency and contradiction. From there the loop is designed and not yet built: a hypothesis, the counterexample that would kill it, an experiment the factory runs, new evidence, and a reduction to the smallest explanatory structure that still preserves every observation. A compiler would call that optimization, a database normalization, a prover derivation, a scientist a theory. Graphonomous means to treat all four as one operation. Solid stages exist; dashed ones are designed.
The one figure that already points that way: on the largest world, every derived fact is reachable by an explanation that is a traversal over stored records, checked by a second implementation that shares no logic with the first, and the 7 acceptance questions the lane holds itself to are answered the same way — never by prose.
The category we currently give it is an autonomous semantic evidence system, and the interesting word is autonomous. Compiler passes, interpreters, provers, query engines, dependency solvers, optimizers and eventually code generators can all become motors operating over the model; none of them is the model.
It is downstream of authority by design. It observes, relates, derives, diagnoses, ranks and proposes; the registry, factory or adjudication that owns a fact decides whether a proposal becomes canonical. It never silently decides truth and never becomes another authority. Each step below is one command in the lane, refuses in its own vocabulary, and leaves behind an id the next step is held to. Press a step. The right-hand column of every panel is the largest projection’s own id for that step, read from the tree and re-derived by the check.
A snapshot names every repository it reads by commit, tree and blob — 7 of them for the largest one, Super (CD) at 7651697 among them. A blob that has moved is refused, never re-read. Reading Super's evidence is the first half of a loop whose second half — Super carrying Graphonomous as every agent's memory — is designed and not built.
4 adapters read those bytes and emit nodes, relations, assertions and source locations. What an adapter cannot normalize becomes a typed fault beside the records — 86 of them in the largest projection — not a guess.
The records fold into one content-addressed root. Shuffle the inputs, reverse the adapters, build again: the same root, and a Python twin re-derives it from the manifest alone.
The semantic world is submitted to WallRiderLang as a Semantic IR 2.0 artifact under a profile Graphonomous declared as data — 24 roles, 32 kinds, 103 admissible pairs. WRL's kernel mints the world id and every relation and revision id. Graphonomous submits; it never mints.
A certificate is minted through TRVM over the claim, its aggregate and the chain of code identities that produced it. It says under which verifier coordinates the projection reconstructs — never that it is "still valid".
A checker re-derives every plane from the directory and writes nothing. Across families, a consistency pass names what two normalized sources disagree about — 4 findings on the largest world, the sharpest being one file read at two different blobs.
One row per shipped projection. Bars compare nodes, relations and typed faults across the rows; the numbers beside them, and the three ids beneath, are read from each projection’s own directory. Two rows share statements: the revision id of a statement is the same in every world it appears in, and its allocation id never is — what a statement is does not depend on the world, where it is allocated does.
What an adapter cannot normalize becomes a typed fault beside the records — 86 of them in the largest projection, by code. A fault is a fact about a source; a finding, 4 of them on the same world, is what two normalized sources disagree about. Neither is repaired silently and neither is hidden.
Graphonomous has no query language of its own. Its vocabulary — 24 roles, 32 relation kinds, 103 admissible (source role, target role) pairs — is a static row in WallRiderLang’s profile table, and the graph is submitted to WRL as a Semantic IR 2.0 artifact. The two-object world on the right seals. Each button applies one edit to a fresh copy and shows what WRL answered, in WRL’s own words: the code and message were produced by running the encoder, and the check runs the same six edits again.
[WRL_UNDECLARED_ROLE] object 'receipt_3Asha256_3Aabc' has role 'OPINION', and profile 'graphonomous.semantic.v2' declares OBLIGATION, ENFORCEMENT_PROPERTY, CLAIM, LAW, MECHANISM, DEFINITION, REPRESENTATION, PROFILE, ASSUMPTION, WITNESS, FALSIFIER, FINDING, EXPERIMENT, RECEIPT, ARTIFACT, ADJUDICATION, EVIDENCE_STATE_TRANSITION, ROUND, CELL, REGISTRY, SOURCE_LOCATION, ARGUMENT, DEFEATER, INSTRUMENT
[WRL_UNDECLARED_KIND] relations[0] has kind 'LIKES', and profile 'graphonomous.semantic.v2' declares STATES, IMPLEMENTS, DERIVES_FROM, REDUCES_TO, REFINES, SPLIT_FROM, SUPERSEDES, RETRACTS, REQUIRES, WITNESSES, SUPPORTS, FALSIFIES, ATTACKS, TESTED_UNDER, SCOPED_BY, ASSUMES, CLOSES, OPENS, PRODUCED_BY, ADJUDICATED_BY, LOCATED_IN, MEMBER_OF, BINDS, CITES, INDEPENDENT_OF, CONFLICTS_WITH, EQUIVALENT_TO, DEFINES, REPRESENTS, CROSS_CUTS, STATE_TRANSITION_OF, DISCHARGED_BY
[WRL_UNDECLARED_ENDPOINT_PAIR] relations[0] joins (CLAIM -> RECEIPT) under kind 'WITNESSES', which profile 'graphonomous.semantic.v2' admits only as (WITNESS -> CLAIM), (WITNESS -> OBLIGATION), (WITNESS -> EVIDENCE_STATE_TRANSITION), (RECEIPT -> CLAIM), (RECEIPT -> OBLIGATION), (RECEIPT -> EVIDENCE_STATE_TRANSITION), (WITNESS -> ARGUMENT)
[WRL_UNDECLARED_POLICY] relations[0] carries policy "anything.at.all", and profile 'graphonomous.semantic.v2' declares 'graphonomous.semantic.rules.v0'. The policy is sealed into this relation's revision identity, so one the profile never declared would be an undeclared rulepack minted into a rev- under a profile that admits it nowhere else
[WRL_V2_WORLD_MISMATCH] this artifact states semantic_policies = {"film_schema":"film.v0.7","rulepack_id":"graphonomous.semantic.rules.v0"}, and the world it encodes derives {"rulepack_id":"graphonomous.semantic.rules.v0"}. These fields are functions of the profile and the objects -- a stated copy that disagrees is a second source of truth, and the stated one is the one a reader believes; a key the profile does not derive at all is a claim about a runtime the profile never made
[WRL_UNSUPPORTED_PROFILE] profile "graphonomous.semantic.v9" is not one this encoder declares (forge.world.core.v1, graphonomous.semantic.v0, graphonomous.semantic.v1, graphonomous.semantic.v2)
# the world every edit is made to — seals to
# sem-e717109f49233a79fd29b34d8521096a66dc05cd2bdcbca22a91b285649c8ee3
{
"ir_version": "2.0",
"profile_id": "graphonomous.semantic.v2",
"semantic_policies": {
"rulepack_id": "graphonomous.semantic.rules.v0"
},
"objects": [
{
"object_id": "receipt_3Asha256_3Aabc",
"role": "RECEIPT",
"static_config": {
"lid": "receipt:sha256:abc",
"attrs": {}
},
"ports": [
"node"
]
},
{
"object_id": "claim_3Acrosswalk_3AE_2D48",
"role": "CLAIM",
"static_config": {
"lid": "claim:crosswalk:E-48",
"attrs": {}
},
"ports": [
"node"
]
}
],
"relations": [
{
"identity_seed": {
"variant": "named-initial",
"relation_name": "rel:WITNESSES:receipt:sha256:abc:claim:crosswalk:E-48"
},
"revision": {
"domain": "semantic",
"kind": "WITNESSES",
"orientation": "directed",
"texture": "solid",
"endpoints": [
{
"role": "source",
"terminal": {
"object_id": "receipt_3Asha256_3Aabc",
"port": "node"
}
},
{
"role": "target",
"terminal": {
"object_id": "claim_3Acrosswalk_3AE_2D48",
"port": "node"
}
}
],
"attributes": {},
"policy": "graphonomous.semantic.rules.v0"
}
}
]
}The whole submission, the seal with kernel-minted ids, and the six refusals with real artifact bytes: Programming Graphonomous with WRL.
The largest snapshot names every file it reads by commit, tree and blob, and 4 adapters read those bytes and nothing else. Super (CD) is one of the repositories, at 7651697: today the graph reads Super’s evidence at that commit and can be held to it, and that is all that is built. The intended loop is larger. Super’s blueprint gives every agent a memory that survives an engine swap, and Graphonomous is the thing meant to fill that slot: every agent under Super carrying Graphonomous as its memory, Super admitting what an agent did as receipts, and Graphonomous re-importing that admitted state deterministically. None of that runs yet, on either side — the lane is read-only by ruling until its cross-registry consistency work stops for adjudication — and this page will say so until it does.
Those two halves belong in one sentence, and separating them is how a page starts lying. The lane’s own suite passes, every shipped projection re-verifies from its own bytes, and none of it is in any published package. The status block says which is which.
A gate is either approved with its evidence, its reviewer and its date, or it is pending. There is no third state, and the publication gate refuses an artifact whose ledger claims approval without all three fields.
records/witness.json#tests_total. Reviewer: node --test through tools/test_repro.mjs (Node 25.2.1). Date: 2026-09-05.records/witness.json#worlds_sealed. Reviewer: bin/g0.mjs, driven by tools/test_repro.mjs. Date: 2026-09-05.Two pages came before this one. The first was 215 KB and stated most of its figures in the present tense with nothing behind them. The second was generated and gated, and described an earlier Graphonomous — an MCP memory engine — whose page is now kept under old_scrap/ and not served. These came off:
455 tests — A test count for the earlier engine at some earlier commit, published in the present tense. That engine's page is gone from this domain and its figures were never re-measured here.29 actions — The earlier engine's machine modules declared more actions than its page printed, and two of them were missing from the table entirely. Neither the table nor the engine is on this page.29 individual tools — Same stale denominator, in the sentence that argued why that engine's machines existed.29 MCP tools — Same stale denominator, attached to a pass-rate claim about that engine.macOS or Linux — Published as an install requirement. Only linux-x64 has a release asset; the other advertised targets all return 404 and the postinstall exits non-zero. The largest single audience for this page could not install it, and the page said they could.No other agent memory system does this — A claim about every other system in a field, with no survey behind it. Nothing on this site establishes what other systems do.96.6 — A retrieval-accuracy figure attributed to a third-party system with no citation, in a comparison table this site cannot witness.Can a memory get sharper from being used? — The question this page asked until 2026-09-05. It described an earlier Graphonomous, an MCP memory engine whose graph changed shape from outcomes. That engine is not what this page describes; its pages are kept under old_scrap/ and not served.npm i -g graphonomous — An install command for that earlier engine. The package of that name on the npm registry still resolves and still installs on one platform; nothing described on this page is in it, and this page does not ask you to run it.five loop-phase machines — The earlier engine's architecture, printed as the page's central claim. Not a claim about what this page describes.Can what a system understands be made queryable, falsifiable and provenance-linked? — The question this page asked for one day in September 2026, between the memory-engine page and this one. It was true and too narrow: it described the graph's properties and said nothing about the graph carrying a model of the system, or evolving it.The fix is structural rather than careful. This page is generated: every figure on it is emitted from records/witness.json, each entry names the command that produced it, and launch-gate.mjs refuses to publish an artifact that reinstates any string above outside this paragraph. A number can no longer be typed onto this site by hand.
A page may only ask you to do what its evidence has earned. This one is in the tree and tested, so it may ask you to read and to run the tests, and nothing more.
v2/ in the repository: the adapters, the projector, the WRL world builder, the TRVM certificate. handoff/STATUS.md is the only file that says what is DESIGNED, IMPLEMENTED, TESTED or FROZEN, and handoff/DECISION_LOG.md is every decision with its alternatives.Run the testscd v2 && npm run test:full-tree in a checkout with the pinned sibling registries beside it. Expect 182 of 183, 1 skipped by design. A different number is the most useful thing anyone could send us.Every figure on this page was measured on one machine by the people who built the thing. A reader who runs the suite elsewhere and reports the verdict — the same or different — is the shortest path this domain has to the next rung, the one nobody here can award themselves. A result, a stack trace, or a figure on this page you think is wrong: same channel, all three welcome.
It is a real <form> with an action and method="POST", so it submits with JavaScript disabled; /contact.js only upgrades it to an inline reply, and that reply prints sent only when the endpoint actually answers 2xx. There is still no email address here, deliberately. Anything better filed as a bug goes to the issue tracker.