Chat Is Where You Think. NEX Is Where You Know.
MammoChat was a governed chat surface for breast oncology from the day it launched — system prompt, CANON.md, inheritance chain back to MEDICINE, MAGIC 255 score closed. What it lacked was a distribution layer. A clinician opened MammoChat, got a response, closed the tab. The response was a governed output. It was not a governed artifact: no content hash, no author attribution, no COIN economy, no reader feedback loop, no peer-review state machine. The output dissolved when the tab closed — the same way chat outputs have always dissolved. On May 8-12, 2026, the NEX pattern closed this gap for four domains: CaseNex for peer-reviewed clinical cases, AnkiNex for governed flashcard decks, OmicsNex for variant interpretation bundles, OncoNex for tumor board decisions. The NEX pattern does not replace the chat surface. It adds a governed distribution layer to any chat surface whose outputs should outlive the session. CHAT is where a clinical AI thinks. NEX is where that thinking becomes an artifact another clinician can read, signal on, build on, and verify. The session ends; the NEX keeps going. The surface story is that NEX is a new product. The structural story is that NEX is the missing governance layer every chat surface always needed.
The Dissolution Problem
Chat outputs dissolve at tab close. This is not a UX issue — it is a governance issue. An output with no content hash has no provenance. An output with no author attribution has no accountability. An output with no peer-review state machine has no quality gate. The output existed. There is no way to prove what it said, who produced it, or whether the version a reader encountered was the version the author intended. Clinical AI that produces ungoverned outputs is the same liability at the moment of dissolution as it was at the moment of generation — the dissolution just hides the liability from view.
MammoChat before NEX was governed in its production path and ungoverned in its artifact path. The system prompt was attested. The CANON.md declared the axioms the model was expected to respect. The MAGIC 255 score was closed. But when the session ended and the clinician walked away from the browser, everything the model said vanished into the browser history of one person's machine. No other clinician could read it. No signal loop could tell the community which interpretations were well-received and which were contested. No COIN mint could compensate the community contributor whose case the model was reasoning about. The governance stopped at the session boundary. Everything past that boundary was dissolution.
This is the governance gap that preceded NEX. The gap was not invisible — it showed up in every architecture review as a missing artifact contract, a missing distribution primitive, a missing reader economy. The chat surface was already close. The CANON.md was already there. The compiler was already running. The gap was always the same thing: no governed pathway from session output to community artifact. A response that only one person read is not yet an asset. An asset has an address. An asset has readers. An asset has a signal loop that tells the author whether the asset is doing its job. NEX is the primitive that makes the response into the asset.
Two Layers, One Contract
The NEX pattern is a two-layer contract. The first layer is the CHAT surface: open-write, AI-assisted, community-powered. Users interact with the governed AI, the interaction produces a structured output — a clinical case, a flashcard deck, a variant interpretation, a tumor-board summary — and that output enters a peer-review queue. The second layer is the NEX surface: open-read, compiled, reader-economy-powered. Consumers read the governed artifact, send difficulty or feedback signals, mint COIN to authors. The two layers are contractually separate.
CaseChat is not CaseNex. The contract is explicit: community writes through CHAT, CANONIC governs through the compiler bridge, NEX distributes to readers, readers signal back to the compiler, the compiler refreshes the artifact, COIN mints to authors. The separation matters because it assigns different principals to different responsibilities. The community is the author. The compiler is the publisher. The reader is the consumer. COIN is the economy that connects them. None of these roles can be collapsed without collapsing the accountability structure that makes the artifact trustworthy.
The contract was formalized in memory entry project_casechat_casenex_via_laude.md: "CaseChat authors (open-write + peer-review state machine), CaseNex distributes (open-read + signal loop + reader economy), build-casenex-bundles compiler bridges; case JSON byte-identical across Galaxy." That sentence is the contract in one line. Everything else is implementation.
The Compiler Bridge
The compiler bridge is three phases: build-casenex-bundles, build-anki-decks, build-omicsnex-bundles. Each phase reads the governed content store, emits content-addressed bundles with MANIFEST files, and pushes artifacts to R2 for long-lived storage and D1 for query access. The MANIFEST file is not a catalog convenience — it is the provenance record that links every artifact to its author identity, content hash, epoch, and review state.
The content hash is load-bearing. Case JSON is byte-identical across the galaxy: the same case hash that lives in the CaseNex bundle lives in the LEDGER entry that minted COIN to its author, lives in the MANIFEST block that the reader's client verifies before rendering, and lives in the canonic-galaxy repo of the case's originating contributor. Content addressability is the property that makes the two layers compose without drift. The compiler bridge does not transform the artifact. It attests it. The reader reads exactly what the author wrote, and the content hash proves it.
build-anki-decks extends the bridge with a difficulty-signal aggregation step. Per card_id, the compiler aggregates signals from anki_difficulty_signals (the D1 table populated by POST /anki/signal/difficulty), computes a weighted difficulty score, applies the governed 40% threshold with a 10-review minimum floor, and emits WEAK-EVIDENCE.json — the list of cards flagged for community revision. The signal travels from reader to compiler in the same phase that refreshes the artifact. The feedback loop is not a separate system bolted on after the fact. It is built into the bridge.
The Economy
COIN mints per author per epoch, bounded by the MAGIC 255 ceiling: scopes times 255 per epoch. The ceiling is not an arbitrary cap — it is the governance invariant that prevents infinite supply inflation while preserving per-scope full-close semantics. A scope that has generated 255 COIN in an epoch has saturated its allocation. A new epoch opens when the content hash changes — when the community revises the artifact.
The difficulty signal is the first governed feedback loop from reader to compiler to economy. A card that 40% of readers flag as hard, with at least 10 reviews, surfaces in WEAK-EVIDENCE.json. The community sees the flag in the AnkiNex feed. A contributor opens the CaseChat surface, revises the card, submits it to the peer-review queue. The revision bumps the content hash. The new hash opens a new COIN epoch for that card's author. The economy is not decorative — it is the mechanism by which the community's collective signal forces artifact improvement and compensates the contributor who acts on it.
The worker-side per-epoch supply ceiling enforces the COIN_CEILING constraint: POST /anki/signal/difficulty validates the scope against COMMUNITY_SCOPES.generated.js before writing to D1, and the mint endpoint rejects mints that would exceed the ceiling for the current epoch's hash, returning skipped: 'CEILING' in the ledger entry. The ledger record of a ceiling rejection is itself evidence of the constraint working. PROV-011 claim 14's reduces-to-practice requirement is satisfied every time that rejection fires.
The Template
The NEX pattern generalizes across any CHAT scope whose outputs should persist as governed artifacts. The extension is four moves. First: declare the NEX scope in CANON.md with content_kind, author_model, and distribution_model — the three fields that specify what the compiler bridge should produce, who can author it, and how it reaches readers. Second: wire build-<scope>-bundles as a compiler phase in PIPELINE.toml. Third: add POST /signal/<scope> to the api.canonic.org worker, validated against the scope's COMMUNITY_SCOPES.generated.js entry. Fourth: wire the COIN epoch to the bundle hash so a content change opens a new mint window.
AnkiChat became AnkiNex. OmicsChat became OmicsNex. LawChat will become LawNex. The template ships in one session per domain because the moving parts are all governed: the compiler phases follow the same pattern, the worker endpoints follow the same validation logic, the COIN mint follows the same ceiling rule. A new NEX scope is a declaration, three wiring calls, and a deploy. The hard work was establishing the pattern the first time.
The conventional reading concluded that each NEX is a bespoke build. That is half right: the first one was, and every one after it is a four-line declaration that inherits the whole bridge.
What Four NEXes Mean
The conventional reading concluded that NEX is four new clinical products. That is half right: the four surfaces are real, but what shipped underneath them is one reusable governance primitive, and the primitive is the part that matters.
On May 12, 2026, four NEX surfaces went live: casenex.us, ankinex.us, omicsnex.us, onconex.ai. Each serves governed artifacts compiled from the corresponding CHAT corpus. Each has a signal endpoint. Each has a COIN epoch wired to the build hash. Each has a MANIFEST file that links every readable artifact back to the author identity, review state, and content hash that produced it.
The four surfaces together represent the first time in the platform's history that a governed AI output has been simultaneously traceable to its author, verifiable by its hash, and addressable by its reader. MammoChat responses dissolved at tab close. CaseNex cases do not dissolve. They are compiled, hashed, attested, published, and open to reader signal. The community that produced the content and the platform that governs it are connected by an auditable economy — the ledger records every mint, every signal, every revision, every new epoch.
The ledger record is not an afterthought. It is the thing that makes the two-layer contract auditable. Every COIN mint names the author slug, the content hash, the epoch boundary, and the event timestamp. Every difficulty signal names the scope, the card_id, and the daily-rotating one-way client hash — no per-learner telemetry, per SERVICES/ANKI/CANON.md, but enough signal to rank difficulty at population scale. The ledger chain proves, for any given artifact at any given date, who wrote it, what the community thought of it, and whether the economy rewarded the right person. That chain did not exist before NEX. It exists now because the compiler bridge emits it as a byproduct of every build.
The dissolution problem was not solved by building a better chat surface. It was solved by building the layer that the chat surface had always been missing — the governed distribution layer that turns a session output into a community artifact. Chat is where the thinking happens. NEX is where the thinking lands.
The four live surfaces are also a proof of the template's generalizability. They were not built as one-off products. They were built as four instantiations of the same four-move pattern, differentiated by content_kind, author_model, and distribution_model declarations in each scope's CANON.md. The fifth NEX will ship faster than the fourth. The tenth faster than the fifth. The pattern scales by accretion of governance — each new declaration inherits every part of the infrastructure that existed before it.
Sources
| Claim | Source | Link |
|---|---|---|
| Content addressing: a content hash is derived from the artifact, so identical artifacts always produce the same address and any change produces a different one | IPFS content addressing and Content Identifiers (CIDs) documentation | docs.ipfs.tech |
| Content-addressable storage verifies integrity and supports versioning because each modified artifact generates a new hash | Content-Addressable Storage (CAS), Abilian Innovation Lab | lab.abilian.com |
| Content-addressed hyperlinks form a generalized Merkle DAG underpinning versioned, tamper-evident storage | Benet, IPFS — Content Addressed, Versioned, P2P File System, arXiv:1407.3561 | arxiv.org |
| CaseChat to CaseNex service contract: open-write authoring, open-read distribution, compiler bridge | LEARNING: CaseChat to CaseNex via LAUDE (memory project_casechat_casenex_via_laude.md) |
— |
| AnkiNex difficulty-signal round-trip; 40% threshold, 10-review minimum, WEAK-EVIDENCE.json | LEARNING: STREAM_F_LOOP_CLOSED, SERVICES/ANKI/CANON.md | — |
COIN epoch ceiling: scopes x 255 per epoch; skipped: CEILING worker rejection as PROV-011 reduces-to-practice evidence |
LEARNING: ANKI_COIN_WIRED_PROV_011_EVIDENCE (S46) | — |
| CaseNex casenex.us live; AnkiNex, OmicsNex, OncoNex distribution surfaces live | MEMORY: project_session_S59_handoff.md |
— |
Chat Is Where You Think. NEX Is Where You Know. | ENGINEERING | BLOGS