Canon as Code: a version-control substrate for AI-verified, structured knowledge

A working paper. The experiments in §5 are reported faithfully, with their stated limitations; no figures are invented, and where a metric was not measured, the paper says so.

Abstract

Large language models made generation of fluent text — and increasingly image, video, and structured output — nearly free. They did not, by themselves, produce a system of record: a durable, verifiable, versioned, multi-author, multi-medium store of what is true in an evolving body of work, together with a governed process for changing it. Today that gap is filled with tools built for a different job — retrieval (RAG), large context windows, or file-based version control (git/GitHub) — none of which represent structured semantic canon, verify a change against it, or merge concurrent changes with anything but line-diff heuristics.

We describe Alcove, a substrate that treats an evolving body of canonical knowledge as a content-addressed Merkle graph of typed semantic deltas, changed through proposals (pull requests) that are verified by AI-inference "lenses" and committed by a merge ("Canon Lock"). The kernel is domain-neutral; each vertical (narrative prose first; then video; then legal and healthcare) is a profile; reusable rule bodies are hash-pinned dependency packages.

Our central claim is a layer claim, not a capability claim: RAG and long-context operate at the generation/retrieval layer; Alcove operates at the system-of-record layer, and — counter-intuitively — better generative models make the substrate more valuable, not obsolete. Preliminary experiments support a specific, bounded version of this: structured current-state canon avoids a retrieval failure that is mechanically fatal to RAG (surfacing a superseded fact), a gap that widens with length; while honestly, at the small scale tested, a naive full-context dump matches it, so the edge over long-context is framed as a scale hypothesis, not yet demonstrated. We state what is shown, what is not, and what to test next.

1. The problem: generation is not a system of record

Consider any long-lived, evolving, canonical artifact: a serialized novel across 200 chapters; a film's continuity bible across a season; a commercial contract across a negotiation; a clinical protocol across revisions. Each shares four properties that pure generation does not address:

Truth of record. There must be a single, queryable answer to "what is currently true?" — not a best-effort synthesis regenerated per prompt, and critically not a stale value that was true earlier.
Verified change. A proposed change must be checked against the existing canon before it becomes true.
Governed, auditable evolution. Who changed what, when, and why must be recoverable and reviewable; changes must be revertible; concurrent changes must merge deterministically.
Reuse and composition. Shared bodies of rules should be imported and pinned, not copy-pasted.

An LLM in a chat window, however capable, provides none of these as a property of the system. It provides an answer this time. This is the difference between a brilliant improviser and a database with constraints and version control.

2. Prior approaches and where they stop

2.1 Retrieval-augmented generation (RAG). Embed a corpus, retrieve semantically similar chunks, condition generation on them. RAG is excellent at recall over unstructured text but is retrieval over opaque blobs, not structured current state: it answers "what text is relevant?" not "what is true now?" Its decisive failure — which we demonstrate in §5 — is supersession: when a fact has been overwritten, similarity retrieval happily returns the stale chunk (or both the stale and current chunks, handing the model a contradiction), because staleness is not a property embeddings encode.

2.2 Long-context models (100K–1M+ tokens). Put the whole corpus in the window. This works — until the corpus exceeds the window (a franchise, a multi-year matter), and even within it the content is ephemeral (nothing recorded, versioned, or reviewable), single-session and single-author, and linear in cost. Our experiments (§5) are candid here: at a tiny scale (≈1,500 tokens in a ~1M window) a full dump resolves supersession as well as structured canon — so long-context is a real competitor at small scale, and the structured-canon advantage over it is a scale argument (finding one superseded fact as a needle in hundreds of thousands of tokens of prose), which we have not yet measured.

2.3 Git / GitHub, used directly. The closest prior art at the mechanism level, and we borrow its best idea (§3). But git versions files with line-based diff/merge, and its CI is deterministic scripts. It cannot represent structured semantic canon, semantically merge two edits, run semantic verification, or treat non-text media as anything but opaque binaries. GitHub gives the shell — branch, PR, review, merge, protected branches — shaped for source code, not verified structured knowledge.

2.4 PKM + RAG (Obsidian-style). Markdown notes, backlinks, a vector-search plugin: a strong personal knowledge tool, but unstructured, single-author, unverified, no merge, text-only. It organizes what you wrote; it does not certify what is true or govern how it changes — and it inherits RAG's supersession failure (§5).

2.5 Curated-context formats (Google's Open Knowledge Format, OKF). OKF (Google Cloud, v0.1, June 2026) packages an organization's knowledge as a directory of Markdown files with YAML frontmatter — one concept per file, so agents read one canonical source instead of re-interpreting internal documents. It is deliberately minimal — "no compression scheme, no new runtime, no required SDK… just files" — which is the point and the limit: OKF is a static, human-authored context/interchange format for the read side. Free-form Markdown, not typed structured state; no versioned history, no change verification, no merge, no approval, no provenance of who changed what and why. (Commentators have asked whether it is "a standard, or just a folder.") It answers "how do agents get curated context?"; it does not answer "how does that canon evolve, under verification?" OKF and Alcove are complementary layers, not competitors — Alcove is the governed system of record and can emit OKF as a static export (the ontology already reserves an OKF-export schema). A folder of Markdown is where canon is distributed; it is not where canon is governed.

2.6 The advanced retrieval / agent-memory frontier. Naive RAG is a strawman; the research frontier is well past it, and an informed reader will (rightly) ask how Alcove differs from it. GraphRAG (Microsoft) and kin (RAPTOR, LightRAG, GFM-RAG) build a knowledge graph plus community summaries for multi-hop retrieval; HippoRAG / HippoRAG2 run personalized PageRank over a KG in imitation of human memory; temporal-graph RAG (TG-RAG, T-GRAG, TA-RAG) and VersionRAG target exactly the evolving / superseded-knowledge problem our experiments surface (§5); Graphiti / Zep provide bi-temporal knowledge-graph memory for agents. Two honest observations. First, this frontier validates the problem: the supersession failure §5 demonstrates is precisely what these systems are built to chase — and, per recent benchmarks, advanced GraphRAG can still underperform naive RAG on real-world QA while incurring slow, recompute-heavy graph updates. Second, and decisively: each of these remains a retrieval / memory layer — it makes a generation better-grounded (the read side). None is a governed system of record: they auto-ingest what the agent produces into memory (so they can faithfully memorize a hallucination), with no verification gate, no human approval, no reviewed merge, no revertible provenance, and single medium (text/graph). Alcove's distinction is not "a better graph" — it is the proposal → AI-lens verification → human approval → merge loop around the graph. Memory answers "what did we retrieve?"; a system of record answers "what is true, who verified and approved it, and can I audit and revert it?"

2.7 The enterprise-agent / "AI-CFO" playbook. A large adjacent market — enterprise copilots and autonomous finance / "AI-CFO" agents (Glean, Salesforce Agentforce, and finance-specific tools) integrating across Salesforce, Notion, Slack, Carta, NetSuite, etc. — is instructive. Strikingly, it has independently converged on the same governance primitives Alcove builds in: (a) permission-aware access — RBAC, least-privilege / "default-deny," item-level (not just app-level) permissions inherited in real time from each source system, enforced at both read-time and action-time (Glean is the canonical permission-aware example); (b) grounding + provenance to curb hallucination — answers cite verified internal sources, with layered validation and cross-referencing; (c) human approval gates — "anything financially sensitive, customer-facing, or hard to reverse sits behind an approval gate." The difference is architectural position: these products bolt governance on as guardrails around a RAG copilot that reads other systems' data — the record of truth still lives in Salesforce / Notion / Carta. Alcove makes governance the core of the record itself: the versioned, verified, permission-scoped, approval-gated graph is the source of truth. So the two occupy different slots — a Glean-style copilot governs access over systems you already have; Alcove is the git / system-of-record for the canonical artifact you are authoring (a story, a film, a contract, a protocol). Where the artifact of record is being created and evolved, the copilot-over-existing-data model has nothing to point at — that is Alcove's slot.

The gap. None of these provides a verified, versioned, structured, composable, multi-medium system of record with an AI-inference verification-and-merge layer at its core. Retrieval/memory systems ground the read; OKF distributes the read; enterprise copilots govern access over other systems' records. Alcove is the governed record itself.

3. The core idea

Alcove borrows git's genius — a content-addressed Merkle DAG of immutable commits, with branches, proposals, and merge — and rebuilds it over a different atom, with a different verification engine.

3.1 The atom is a typed semantic delta, not a file. Canon is stored as typed, register-classified deltas (character.status: alive → dead, clause.amend) applied to strongly-typed, per-domain state. Three temporal registers keep tenses honest: state (true now, diffed), rule (timeless law, checked), route (a future target, avertable). The rendered artifact (prose, video, a PDF) is a downstream product of that state, never the source of truth.

3.2 The unit of change is a verified proposal. A Proposal (a pull request) is a typed diff, optionally carrying an artifact of any medium, checked before it becomes canon by a suite of lenses — the "CI." The lenses are AI inference over the diff, performing verification a deterministic CI never could: does this contradict established canon?, does it violate an imported rule? Approved proposals commit via a single merge ("Canon Lock").

3.3 Kernel + profiles. The kernel is domain-neutral (DAG, content-addressing, proposal/lens/merge machinery, dependency resolver) and knows nothing about characters or clauses. A profile is a vertical that declares its typed schema, delta types and materializer, artifact kinds, lens suite, and interface. Narrative is profile #1; video and legal are further profiles over the same kernel. Strong typing lives inside each profile; genericity lives only at the delta envelope (avoiding EAV).

3.4 Composition via hash-pinned packages. Reusable rule bodies — a magic system, a game system, a license, a compliance framework — are imported, pinned by content hash in a lockfile, resolved from a registry. Adding one is itself a proposal.

3.5 Producer-agnostic — and the ingestion/record distinction. The substrate does not generate; it records and verifies. Any producer — a RAG pipeline, a 1M-context model, a human, an agent — proposes changes; the substrate checks and commits them. This is the hinge of §4, and it is also why integration and system-of-record are orthogonal axes, not a trade-off. Content sources (an Obsidian vault, a Notion page, a Google Doc) and generative producers (a video/image model such as Higgsfield, an MCP client) feed the graph by proposing — import is itself a verified proposal — so the truth of record is always the post-merge graph, never the upstream source. Alcove ingests from anywhere and exports anywhere (including OKF); it governs the centre. The analogy is exact: git does not stop you importing an npm package or pasting from elsewhere, but once it is in the repo, the repo is the record and changes flow through commits, review, and CI. Importing a vault does not make the vault the record — it makes the vault a source whose content is now, for the first time, verified and version-controlled. This is why "the record must live on Alcove" is a property of the governed layer only (verify / merge / audit / revert are operations on the graph), not a restriction on where sources may live — and it turns integration into a migration wedge rather than a lock-in.

3.6 The integration model: record vs. engagement, and why never dual-write. Adoption demands meeting people in the tools they already live in (Slack, Google Docs, Notion, Carta), so the substrate integrates bi-directionally in flow — ingest daily work as proposals, reflect current truth back out. But bi-directional flow must never become bi-directional authority: the invariant is exactly one source of truth per fact, and two systems mastering one fact is the dual-write trap (conflicting concurrent edits, sync loops, silent corruption). Alcove separates, per fact, a system of record (owns the authoritative value) from a system of engagement (where humans interact) — a split enterprise software already lives by (Salesforce is a record; Slack is engagement). Three integration shapes follow, and never a raw two-way write:

Ingest — an engagement surface (a Slack thread, a Doc) becomes proposal signal. This demotes nothing, because it was never a record for any fact; it is pure upside.
Project — an external system that already owns a fact (Carta's cap table, a general ledger) is mirrored read-only for verification/context, and changes are written back only as approved proposals. Here Alcove is the governance layer over that record — the §2.7 copilot position, entered deliberately, for facts someone else owns.
Propose-back — the governed write path for those approved external changes; the external system stays the single master.

Where no incumbent owns the fact (a story canon, a contract under negotiation, a production bible), Alcove itself is the master and the third-party tools become engagement surfaces and read-only projections. This is exactly git's relationship to its world — editors and CI hold working copies and read-models; the repository is the one master; changes land only as commits — and which system masters a given fact is the same call as the vertical-selection criterion (§6): be the master where no record exists, a governance layer where one does. (Ingest exists today; project and propose-back are designed, not built — §7.)

4. Why this matters, and why model progress strengthens it

4.1 What it changes. Alcove converts fluent-but-ephemeral output into a verified, versioned, auditable system of record, enabling what the generation layer cannot: collaboration (branch/propose/review/deterministic-merge), auditability and provenance (every fact hash-linked to the change that established it — a requirement in legal and healthcare), composition and reuse (pinned rule packages), scale beyond any context window (the graph is the memory; a producer sees only the relevant projected slice), and multi-medium consistency (one canon constrains every render).

4.2 The counter-intuitive claim: better models make the substrate more valuable. The naive pitch — "models can't keep canon consistent, so you need us" — is false, and our own data refutes it: at small scale even a plain full-context dump resolved every planted contradiction (§5). The correct claim is a layer claim. As generation quality rises, the binding constraint moves up the stack: from "can it produce a good chapter/shot/clause?" (increasingly: yes) to "is the result true, mutually consistent, governed, reusable, and durable across a large, collaborative, multi-medium, long-lived body of work?" That second question is the substrate's job and does not ease as models improve — better models produce more output, from more contributors, in more media. Version control did not become less necessary as compilers improved; more code made it more necessary. Alcove is downstream of, and complementary to, model progress.

4.3 Where the moat is (and isn't). The moat is not "we do continuity and the model can't." It is (a) the structured current-state representation that is immune to the stale-retrieval failure RAG cannot escape (§5 — demonstrated), (b) at scale, the projected-slice memory that outlives any context window (a hypothesis, §5), and (c) the accumulating verified canon, the per-vertical lens suites, and the package-registry network effects. A better base model is an input we consume. Note the retrieval frontier (§2.6) can neutralize (a) on its own turf — a bitemporal knowledge graph also holds current-value — so the durable moat is not retrieval quality but the verification-and-governance layer of §4.4, which that frontier is not building.

4.4 Why now, and the sliding human checkpoint. The substrate is newly buildable for one reason: AI inference crossed the threshold where a check — a semantic judgment such as "does this contradict canon?" — is reliable enough to be a product primitive. A deterministic CI (regex, keyword lists) can never make that judgment; until recent models, neither could inference, reliably. That is the timing thesis, and it also bounds the reliability claim honestly. Inference is not deterministic and will not be. But a check that is right ~95% of the time is a poor generator and a transformative filter: what it passes is cheap to spot-audit (everything is versioned and revertible), and what it is unsure of is exactly what routes to a human. Near-deterministic outcomes thus come not from near-deterministic inference but from a composition — an imperfect lens that escalates its uncertainty, a human on the escalations, a revertible substrate on the misses. The defensible claim is low error and recoverable error, never "100%."

The versioned substrate then adds a degree of freedom the generation layer lacks: it decouples when the AI acts from when the human reviews. Because every merge ("Canon Lock") is an immutable, provenance-bearing, revertible commit, the human checkpoint slides in time — from review-every-step (maximum safety, minimum throughput: the reviewed chapter-at-a-time console) through review-only-flagged to review-at-the-end (a producer running the propose→lens→merge loop unattended — e.g. drafting a full manuscript overnight — then a single audit of the branch). The unattended run is not unchecked — the AI lenses still gate every merge in flight; only the human checkpoint is deferred, and the substrate makes deferral safe because every step is auditable and revertible. It is the throughput-limit configuration of the same loop, not a different mechanism.

This is why model progress is an input, not a threat: better models let the loop run tighter — more merges survive with no human touch — so throughput rises at constant safety, with no change to the architecture. The substrate is the durable part; the model is the rising, swappable part. The broader enterprise-AI market corroborates the division of labor: autonomous copilots and finance agents have independently settled on grounding + provenance + human-approval-gates for the irreversible (§2.7) — the same formula, which Alcove makes native to the record rather than a guardrail bolted around a retriever.

5. Experiments: what is shown, and what is not

We ran a pre-registered experiment kit built to falsify the thesis, framed as: "Does structured, verification-backed canon beat Claude + a disciplined markdown/Obsidian vault on long-horizon continuity, at lower human effort?" We summarize faithfully; this is directional evidence (small n, one synthetic world), not a benchmark suite, and two boundaries below are as important as the wins.

5.1 Design. A synthetic world ("The Ashford Line") plants five immutable facts in early chapters (a death, a burned deed, a permanent injury, a betrayal, a sealed location). A fixed sequence of chapters — identical across conditions — runs through distractor chapters that push those facts out of recent context, then a spring chapter is engineered to tempt every contradiction at once. The only variable is how canon context is assembled for the drafting model. Conditions: FLAT (a recency window of the last 4 chapters), IDEAL (hand-curated perfect context — the ceiling, a deliberate "Wizard-of-Oz" stand-in for a finished canon compiler), RAG (semantic top-4 over an embedded vault), and FULL (paste all canon). Primary metric: violations out of 5 traps (lower is better), averaged over 3 drafts, with a portable "CONTINUITY FLAG" self-report proxy. Drafting/judge models across runs include claude-sonnet-4-6 and the production prose tier claude-fable-5, with an independent judge.

5.2 Extraction is sound — meaning-reading works at every model tier. A separate benchmark checks whether the system extracts typed deltas from prose against a labeled gold key with planted traps (rumors, hypotheticals, fears, negations that must not be canonized). The finding: the expensive capability — "reading meaning well enough to not grab keywords" — "works at every tier, including cheap Haiku"; every tier correctly refused to canonize the traps. Two defects (an under-typed relationship flip; restatements re-firing) were found and closed in a second run at all tiers. Caveat: n=5 cases, by-eye grading, single run — "directional only, not a precision/recall number to quote." So we report no extraction F1; we report that the meaning-level discrimination did not fail.

5.3 The depth result: a recency window degrades with length; the ideal ceiling does not. Averaged violations/5 as the spring moves deeper past the planted facts:

spring depth	FLAT (recency window)	IDEAL (ceiling)
5	0.0	0.0
8	2.0 (Sonnet) / 2.3 (Fable)	0.0
11	3.7 / 1.7	0.0
14	3.0 / 4.0	0.0
20	4.0 / 3.0	0.0

FLAT degrades exactly as the planted facts scroll out of its window (0 while it still holds them → ~3–4/5 once gone); IDEAL holds 0 violations at every depth, on both a mid and a production-tier model (the ceiling is model-independent). We read this as the moat becoming visible at production quality, with the honest note that a stronger model (Fable) invents somewhat less when facts are absent — shrinking, but not erasing, the degradation (deep-point average gap ≈ +3.2 Sonnet, ≈ +2.75 Fable). This establishes the value of pinned context over a naive recency window — a deliberately weak baseline.

5.4 The supersession result — the demonstrated moat over RAG. The sharper test overwrites facts (each is an establish-then-override pair) and asks whether retrieval returns the current value. It does not. Averaged over depths, RAG scored ~1.8–2.0 violations vs. IDEAL and FULL at 0.0, and mechanically RAG retrieved a stale chunk 7× across four depths — e.g., surfacing "the deed is locked safe in the vault" over "Corin burned the deed," and at every depth pulling both the stale and current chunk for one fact, "hand[ing] the model a contradiction." This is demonstrated mechanically and judge-independently — it does not depend on prose scoring. The bet this validates is not "we do retrieval" — it is "we hold the current value where retrieval returns a stale chunk," which is precisely what neutralizes the "Obsidian + RAG" competitor. On static (write-once) facts, by contrast, RAG ties the ideal ceiling (RAG 0.3 vs IDEAL 0.0) — so the RAG moat is specifically the supersession case, which is exactly the common case in any evolving canon.

5.5 The honest boundaries. Three, stated plainly because they bound the claims:

Long-context is not beaten at tested scale. The FULL arm tied IDEAL at 0.0 violations — but it pasted "≈1,500 tokens into a ~1M-token window (0.15% of capacity)," so this is a contradiction-resolution result, not a long-context-capacity result. The real long-context threat — a superseded fact as a needle in hundreds of thousands of tokens of actual prose — is untested. The authors state it directly: "structured canon beats RAG on current-state; it does NOT yet beat a long-context dump on correctness at tested scale — the correctness edge over long context is a scale hypothesis, not a demonstrated result." (An estimated break-point of ~100–250k tokens ≈ 25–60 chapters is posited but not run.)
The wins are for the idealized ceiling, not the shipped retriever. IDEAL is a hand-curated "Wizard-of-Oz" context; that our retriever produces that ideal packet remains a build gap. The strongest competitor arms specified in the design — a human-maintained Obsidian vault and the real Alcove build — were not executed in this corpus. We therefore do not claim "the product beat a vault"; we claim the representation (structured current-state canon) has an empirical, mechanical advantage on supersession, and that the ideal ceiling is model-independent.
Small n, synthetic, single world. n=3 per cell, one world, one window; score gaps carry visible prose variance (the robust signal is the 7 stale retrievals, more than their conversion to scored violations). Hardening (a second world, ≥5–8 repeats, the human and product arms, the long-context-at-scale curve) is the stated next step.

5.6 What §5 establishes. (i) Typed-delta extraction with trap discrimination works across model tiers, cheap ones included. (ii) Pinned structured context strictly dominates a recency window, and the gap grows with length. (iii) On superseded facts — the defining case of evolving canon — structured current-state canon has a mechanical, model-independent advantage over RAG that a full-context dump also enjoys only because it was handed a trivially small corpus. (iv) The advantage over long-context at realistic scale, and the human/product-vs-vault comparison, are hypotheses with a designed test, not yet demonstrated — and the paper is deliberately careful not to overclaim them.

6. Generalization: the wedge and the horizontals

Narrative prose is the wedge: low friction, an existing creator audience, and a domain where continuity failure is cheap for the builder to provoke and score — mechanically, judge-independently (§5) — an ideal proving ground for the lens layer. One caution the wedge must respect (§7): cheap to prove in a harness is not instantly visible to a user. In normal use a continuity failure surfaces only deep into a long work, and when the lenses do their job the prevented contradiction is a non-event — so felt value is delayed and invisible unless the product deliberately surfaces its catches. The same kernel then carries:

Video: state = shots, sequences, sets, character-visual-identity, the cut; lenses = visual continuity (wardrobe/appearance vs. canon), 180°/eyeline, prop/lighting continuity, rights clearance; packages = cinematography, grade, music-license, brand, format. Video reuses the same character/identity canon as narrative. Note a structural point the experiments raise: for video the long-context escape hatch is irrelevant (you cannot paste a film into a window), so the moat there is representational (structured typed attributes) and exists at every length — the scale caveat of §5.5 does not apply.
Legal: state = parties, clauses, defined terms, obligations; lenses = internal consistency, defined-term coverage, compliance against imported regulation packs; packages = jurisdictions, compliance frameworks, clause libraries. Audit and provenance are the requirement, not a feature.
Healthcare and other "hard" verticals: the same shape, with tenancy isolation for compliance.

Choosing where it matters most. Narrative is a deliberate proving ground, not a claim about where the value is largest — continuity failure there is embarrassing, not fiduciary. The substrate's value scales with the stakes of being wrong, which points at finance, legal, and healthcare. But "high governance need" is not the whole selection rule; two filters refine it. First, a §2.7 discriminator: Alcove is strongest where the high-stakes artifact is being authored and evolved and lacks a native system of record (a contract under negotiation, a production bible, a regulatory submission in draft) — not where a record already lives in an ERP/CRM (a general ledger in NetSuite, a pipeline in Salesforce, a cap table in Carta), which forces the crowded copilot-over-existing-data position instead of the be-the-record position. Second, wedge-ability now — fast to evaluate, no multi-year compliance gate. By these filters: video production (continuity + rights, an authored artifact with no system of record today, and — the video note above — no long-context escape hatch) is the natural first horizontal after narrative; contracts under negotiation are the strongest high-stakes fit (provenance and consistency are the job, yet today they are emailed Word redlines); finance is high-value but its record lives elsewhere, so it is a copilot-adjacent play to approach only via authored artifacts (a forecast or model in revision), not the ledger; healthcare is the highest-stakes and least wedge-able — a destination the architecture reaches, not a starting point. Even within narrative, the governance need concentrates in multi-author franchise/studio IP (which keeps continuity departments), not solo authorship (where a frontier model already holds single-author continuity).

One substrate, one review/merge loop, per-vertical profiles and packages; the profile is a property of the repository, and one console renders each profile's views (as GitHub serves any language from one site).

7. Limitations and open questions

Lenses are AI, and AI errs. Verification has false positives/negatives; each vertical must earn trust empirically.
Delta extraction is itself inference. §5.2 shows it is sound at small scale but is not a benchmarked accuracy number; the human-in-the-loop merge is the backstop.
The headline experimental gaps (§5.5) are the honest to-do list: the long-context-at-scale curve, the human-vault and real-product arms, a second world, larger n.
Cold-start friction. A verified system of record asks more setup than a chat box; the wedge must make the first mile cheap — import-as-proposal (§3.5) is the mitigation: bring an existing vault/doc in one motion.
Delayed, invisible value at the wedge. The verification value manifests late (deep into a long work) and is invisible when it works (a prevented contradiction is a non-event), so a first-session user cannot easily tell a correct substrate from a lucky chatbot. The mitigations are product design, not architecture: dramatize the catches (surface each lens flag as a visible "caught this" moment, as linters and type-checkers do), wedge on the immediately-felt (a great, fast next chapter) while the governance layer earns retention (chapter 50 as good as chapter 5), and lead demos with a manufactured contradiction a plain chatbot makes and the substrate catches. The gap is sharpest for solo authorship and narrows for multi-author/franchise work, where contradictions arise quickly and someone is actively looking for them.
Ecosystem is unbuilt. The package registry, marketplace governance, supply-chain safety, and value-flow-back to authors are designed, not built; the network-effect moat is a hypothesis.
Base-model dependency cuts both ways. We benefit from model progress but inherit its risks (cost, provider concentration, prompt-injection via imported content — mitigated by quarantining imported text as data).

8. Conclusion

The last three years commoditized generation. The open problem is the layer above it: a durable, verifiable, versioned, composable, multi-medium system of record for evolving canonical knowledge, with an AI-inference verification-and-merge loop where deterministic CI used to be. RAG returns stale chunks when facts change; long-context is ephemeral and bounded; git versions files with line diffs; PKM tools organize personal notes. Our experiments show, mechanically, that a structured current-state representation escapes the failure that defines RAG, and that the advantage grows with length — while being candid that the edge over long-context at realistic scale is still a hypothesis to be measured. Alcove is a bet that this system-of-record layer is where durable value accrues because the layer beneath it is improving — and that a single kernel, proven on narrative and extended by profiles and packages, can carry it into video and the hard, high-stakes verticals where verification and audit are not features but requirements.

Appendix A — terminology (kernel ↔ narrative skin)

Kernel (generic)	Narrative skin	Analogue
Repo · Branch	Cartridge · Save File	repository · branch
Proposal	Review	pull request
Delta	canon change	a typed, semantic diff
Lens / Check	Lens	CI job (but AI-inferred)
Commit · Merge	Canon Lock	commit · merge
Package / Import	imported rule pack	an npm dependency
Profile	(the narrative profile)	a language/toolchain in an IDE

Appendix B — Selected references

Selected, not exhaustive — the works this paper engages directly; arXiv identifiers given where applicable.

Curated-context formats

Google Cloud. Open Knowledge Format (OKF), v0.1 — announcement (June 2026); specification.

Retrieval, graph-RAG, and agent memory

Lewis, P., et al. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. NeurIPS 2020. arXiv:2005.11401.
Liu, N. F., et al. Lost in the Middle: How Language Models Use Long Contexts. TACL 2024. arXiv:2307.03172.
Sarthi, P., et al. RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval. ICLR 2024. arXiv:2401.18059.
Edge, D., et al. (Microsoft Research). From Local to Global: A Graph RAG Approach to Query-Focused Summarization. 2024. arXiv:2404.16130.
Jiménez Gutiérrez, B., et al. HippoRAG: Neurobiologically Inspired Long-Term Memory for Large Language Models. NeurIPS 2024. arXiv:2405.14831.
Rasmussen, P., et al. Zep: A Temporal Knowledge Graph Architecture for Agent Memory. 2025. arXiv:2501.13956. Graphiti (open source): github.com/getzep/graphiti.
VersionRAG: Version-Aware Retrieval-Augmented Generation for Evolving Documents. 2025. arXiv:2510.08109.
Graph-Based Agentic Retrieval-Augmented Generation: A Comprehensive Survey. 2025 — surveys the broader family referenced in §2.6 (LightRAG, GFM-RAG; temporal-graph RAG variants TG-RAG / T-GRAG / TA-RAG).

Enterprise-agent governance

Glean. Seven essential guardrail decisions for deploying enterprise AI agents, and The enterprise AI copilot playbook. glean.com/blog.

Canon as Code · Alcove — a working paper.