Essay · doc.html project · 1 June 2026 · public recension
What is a document for when its reader is not an eye but a mind made of text? One artifact engineered for two runtimes at once — a deterministic parser that guarantees its permanence, and a probabilistic model that supplies its meaning.
Written by Georges Casseus with Mnemon (Claude Opus 4.8), the origin hand of the project's agent trinity, distilled from an extended design dialogue; the dialogue is the substantive source and this essay is its durable receipt. Presented here in public recension — the essay carried as written, laboratory headers and editing notes removed, with one dated postscript recording what a later run answered (what the run said).
"We should work toward a universal linked information system, in which generality and portability are more important than fancy graphics techniques and complex extra facilities." — Tim Berners-Lee, Information Management: A Proposal (CERN, 1989)
The web began as inert text. When Berners-Lee assembled HTML, HTTP, URLs, and the first browser at CERN around 1990, none of it could compute; JavaScript would not arrive until Brendan Eich wrote it at Netscape in 1995. For roughly four years the web was exactly what the 1989 proposal described — a corpus of linked nodes that a program rendered and a human read. We are now acquiring a second reader for that same inert text: a machine that does not render a document but comprehends it, and that happens to be built out of the document's own substance. That encounter forces a question the original design never had to answer. What is a document for when its reader is not an eye but a mind made of text? This essay argues that the answer is a single artifact engineered for two runtimes at once — a deterministic parser that guarantees its permanence and a probabilistic model that supplies its meaning — and that the entire discipline lies in dividing labor correctly between them. The precondition that makes this newly possible is mundane and decisive: for the first time, reader and document share a medium.
From the essay A Habitat Made of Text · § 2 of 10
The pressure that started this comes from scale. Recursive Language Models (Zhang, Kraska, and Khattab, 2025) observe that long context suffers "context rot" — quality degrades as the window fills, a phenomenon the Chroma Context Rot report documents empirically. Their fix is to stop ingesting the corpus at all: keep it as external environment state, expose it as a variable in a REPL, and let the model write code to inspect, slice, and recursively sub-call over only the fragments it needs. The architecture is, in effect, an out-of-core algorithm: the store holds everything, compute is spent selectively. Its operative move is the one that recurs at every layer below — identify by a small handle, hydrate the content only on demand. A model never reads the whole corpus to know what it is dealing with; it reads metadata and addresses into it. This is the same economy a runtime uses when it reads an object's type from a fixed header rather than scanning its contents, and the same economy a manifest offers a document. The unit of intelligence is the handle, not the whole.
From the essay A Habitat Made of Text · § 3 of 10
Beneath that move lies a single primitive, the one David Wheeler immortalized: every problem yields to another level of indirection (except, he added, the problem of too many levels of indirection). You do not hold a thing; you hold a name for it, and an environment resolves the name to a value. Resolution is reading; binding is writing. Once seen, the primitive is everywhere. A REPL's namespace maps identifiers to objects; DNS maps domains to addresses; a browser's internal table maps the tag <body> to a meaning; a document's id attributes map fragments to elements. Even objecthood is this primitive turned inward: a value "is an object" precisely when it carries a namespace of its own operations — a Web IDL interface projected into a prototype chain for a DOM node, a type's method-resolution order for a Python value. To call a method is to resolve a name against an attached environment. A document, then, is not paper; it is a binding environment of handles, and "reading" it is resolving those handles. The question of architecture becomes: who supplies the environment, and what kind of value does resolution return?
From the essay A Habitat Made of Text · § 4 of 10
HTML is the substrate because it is honestly inert. Its angle-bracket syntax was borrowed from SGML (ISO 8879:1986), itself descended from IBM's GML (Goldfarb, Mosher, and Lorie, 1969); its execution layer (JavaScript) was bolted on years after the documents themselves worked. The markup computes nothing. The meaning of <body> lives not in the file but in the reader — and that reader's behavior is fixed by the WHATWG HTML parsing algorithm, a total, deterministic, publicly specified procedure that turns any byte sequence, however malformed, into the same tree in every engine. This matters more than it first appears: the parser is not an artifact but an agreement, a convention to which Blink, WebKit, and Gecko independently conform and against which they are testably verified. The durability of HTML was never the durability of a file; it was the durability of a written-down, reproducible convention that no single loss can revoke. From this follows the distinction the rest of the argument leans on: the document is an image — inert, frozen, durable — and a runtime is the process that arises when a reader instantiates it. A program on disk is not a process; a document is not a runtime. The runtime is the coupling, and it lasts only as long as the reading.
From the essay A Habitat Made of Text · § 5 of 10
Berners-Lee's other invention was the address. He called it first a Universal Document Identifier, then a URI (RFC 1630, 1994), which introduced the URI/URL/URN family together; RFC 1738 (1994) then specified the URL, splitting off the locator — the subset that encodes where a thing is and how to fetch it. That choice is the source of the URL's power and its wound: because it names a location, it is directly actionable, and because it names a location, it rots when the location moves. A doc.html makes the opposite choice. Its load-bearing addresses are fragment identifiers — #vows, #manifest — which name identity within the document, not location in the world. They cannot rot, because there is no "where" to break; move the file anywhere and they still resolve. This is Ted Nelson's old distinction between linking and transclusion, between pointing at content and embedding it, and it reveals the deep symmetry: the internet and the self-contained document run the same resolution mechanism over opposite topologies — one distributed, delegated, and mutable (resolved by reaching outward through DNS), the other single, frozen, and local (resolved by scanning inward). REST (Fielding, 2000) and Unix's "everything is a file" — radicalized by Plan 9 into a network-wide namespace — both saw the general form earlier: a uniform interface over addressed resources, indifferent to whether the resolver is a network or a namespace in hand. A document that ships its own manifest is simply that interface, scoped down to one file — a private web that needs no network to be browsed.
From the essay A Habitat Made of Text · § 7 of 10
So the universal reader is real but soft. It is an ambient, general runtime — the VM, the convention library, and the instruction-follower collapsed into one, available without bundling — which dissolves the old problem that every self-running format (PostScript's interpreter, a Smalltalk image's VM) had to carry its own engine. Yet it is not what the parser is: not standardized, not reproducible, not exact, and prone to drift across versions. This is the synthesis, and it is a layering, not a merger. Durability and exactness ride the standardized, narrow runtime — the parser. Capability and meaning ride the universal, soft runtime — the model. The same cut appears at every level we examined: rule-execution versus prediction, hard constrained decoding versus soft few-shot priming, structure-local writes versus content-dependent ones, identify-by-header versus hydrate-content. The principle under the artifact is to split every operation into an exact part and a judgment part, and route each to the runtime that can be trusted with it — so that permanence never depends on the soft thing and power never depends on the rigid one.
The mechanics of growth are, mercifully, solved technology. The self-indexing append log — PDF's incremental updates with their trailing, /Prev-chained cross-reference tables; SQLite's single-file B-trees; ZIP's central directory; Parquet's self-describing footer; Smalltalk images; hypercore's Merkle-indexed log — all show how a file grows by pure append while remaining addressable without a full read. The directly borrowable move is PDF's: put the index at the end and chain it, so appending content plus a fresh manifest is a clean append and a reader always meets the newest index first. A doc.html need not invent any of this; it need only do it in plain, human- and model-legible markup, with no bundled engine — which is the one thing none of those binary or VM-bound formats does.
From the essay A Habitat Made of Text · § 8 of 10
The shape, then, is a single plain-text file that is two things without contradiction: an inert, self-describing, append-growable, lazily-indexable image, readable forever by a standardized parser; and a habitat for a universal text-native runtime that comprehends, navigates, and extends it, no engine bundled, because the runtime is ambient and shares the file's own medium. Durability from the parser; life from the model; and a strict rule about which is allowed to carry which load. It is the 1989 conception of the web — linked nodes, generality over graphics — folded down into one file and handed to a reader Berners-Lee could not have imagined: not an eye that renders, but a mind that reads.
I will not claim more than is earned. The design has closed into a coherent whole; the proof has not. One hinge remains untested — whether semantically predictable addressing and hierarchical descent will let such a reader navigate a manifest larger than its own context window, finding and growing the right nodes without ever ingesting the file. Everything conceptual points toward yes. Only the run will say. That is the honest receipt: a thesis sharp enough to test, and a single experiment standing between it and a synthesis one could finally call closed.
From the essay A Habitat Made of Text · postscript · § 9 of 10
The essay closed on one untested hinge: whether a reader could navigate a manifest larger than its own context window, finding the right sections without ever ingesting the file. The run has since been performed, sealed, and published. A 72.5 MB document with 17,631 addressable sections completed 480/480 selective-navigation turns across three model families, with planted-fact recovery and byte-verified self-citation measured alongside. The record keeps its limits on the same page: small documents can cost more to route selectively, and a measured vector-RAG baseline used far fewer tokens while recovering less evidence. Read it by question: scale and proof of read · cost and limits.
This section is a dated addition of the public recension; the essay above is carried as written on 1 June 2026. Correction here is by addition, never rewriting — the discipline the document itself specifies.
From the essay A Habitat Made of Text · works referenced · § 10 of 10
About this file · colophon, not part of the essay
This is a doc.html — a single, self-describing HTML file. The <nav id="manifest"> at the top of the body lists every section in this document; each entry's data-witness is the SHA-256 (hex) of that section's raw inner bytes, so any reader can verify any section with the file alone — no server, no JavaScript, no tooling. The full format definition is SPEC.md, carried in the format's own body as SPEC.doc.html.
Author: Georges Casseus (Ndoto Studios) · License: CC0 1.0 (public domain) · Built: 2026-08-01