The Same
Machine

The previous page demonstrated a pipeline with stages. That was a simplification, and a misleading one, because it implies the stages are things. They are not. There is one relation — TABLE_SPECIFICATIONS, twenty columns, holding a source address, a target address and the function between them — and everything else in the estate is a projection from it.

Not generated by it in the sense of a code generator with templates on one side and output on the other. Projected from it: the DDL, the view, the load statement, the workflow XML, and the shell that invokes them are each a different walk over the same rows. Change a row and all nine change together, because there is nothing else for them to disagree with.

Step three is the one that matters and the one that is easy to miss. The specification table's own twenty columns are loaded into the specification table, sourced from ALL_TAB_COLUMNS — so the surface describes itself, and the same projection that builds a business view builds the view of the specification. That closure is not a trick. It is what makes the thing an engine rather than a script: there is no privileged layer holding the rules about the other layers, because the rules are addressed the same way everything else is.

The match rules are rows too. Step four adds a partner feed the page has never seen; before its rules exist, four of its addresses park as candidates rather than failing the load, and the cost of onboarding it is four rows in a rule table. No adapter, no transform, no pipeline. Then look at any of the nine projections again — the shell, the workflow XML, the DDL — and the new system is in all of them, from machinery that did not change.

The command tier is the part usually mistaken for scripting. A ksh wrapper, a .bat, an .ini, a WinTask macro and a CLI invocation are the same projection with different comment prefixes, because they address invocation rather than syntax: bind a context, carry a payload, fire. That is why one header block served all of them for two decades unchanged, down to the $Revision$ keywords left unbound for an archive layer that was never wired up.

The previous block treats generation as the terminal act: point at a catalogue, emit an artefact, stop. That is the visible half and it is the half that makes the thing look like a code generator with good hygiene. It is not what was running.

What was running was a population. On Windows NT, hundreds of sessions kicked off in parallel from pre-populated parameter list files held in memory, each scoped to exactly the commands its task needed, each calling other sessions and other applications as APIs, each dying on completion. SQL to HTTP to a crawler to a digest, swapped mid-chain, because none of those was ever a rewrite. Four properties make that work, and each is demonstrable rather than assertable.

The running system is a catalogue. ALL_TAB_COLUMNS enumerates what exists; ALL_PROCEDURES enumerates what it can do; V$SESSION enumerates what is happening at this instant, in the same address shape. So the resolver can be pointed at the estate as it executes, not only as it is declared — and the same projection works, because state and structure were never different kinds of thing.

Fan-out is a query result. Drag the work count and the slot count and press two. Each unit is dispatched to a real worker — a real operating-system thread — which does real work and is really terminated when it finishes. The number of live sessions is not a configured concurrency; it is how many rows came back and how many slots were free. Dependencies come from the rows too, so ordering is a property of the data rather than a schedule someone maintains. The speedup reported underneath is wall time against summed thread time, both measured in that run on your machine.

The effector is one line. Press three and pick another. The rows, the dispatcher, the slot discipline and the log stay identical; one line differs, and the sessions then do genuinely different work — a real SQLite database, a real HTTP request, a real crawl of this page's own assets, real chained SHA-256. Nothing below that line is simulated and nothing above it changes. That is why a mid-chain language swap is unremarkable, and why D before E is a substitution rather than a mode.

And the log is the source. Each SQL session records the statements it actually executed and a SHA-256 over the state they produced. Press four: those statements fold into specification rows verbatim, and are then replayed into a fresh engine in a new thread, and the digests compared. Identical means the log did not describe the run — it was the run, because syntax was stored and never parsed. Capture actions across sessions, machines and applications and you are already holding specification. That is why everything can be ephemeral: you keep the rows that reconstitute the session, not the session.

Read those four together and the object is not a build tool. It is a distributed population of short-lived scoped workers, fanned out from a query, addressing each other and external applications through a uniform call surface, with every action recorded in a form that replays as instruction.

Which is what agentic names now. The claim is not that the pattern rhymes: it is that this specific topology — many ephemeral task-scoped workers, dispatched from a list, calling each other and applications as APIs, logged and replayable — was running in production on Windows NT before 2000, and the part that has changed since is which effector sits on that one substitutable line.

The claim from the first build was that an estate's integration points are not designed but recovered: the systems already declare what they contain, and the catalogue is a set of relations you can query like any other. That was demonstrated against a simulated catalogue, which is fair enough as far as it goes.

Here it runs against a real one. SQLite compiled to WebAssembly — 686 KB, shipped in this package rather than fetched from anywhere — four tables created, then the loop: read sqlite_master and pragma table_info, generate DDL from what they report, execute it, and read the catalogue again to find the result. Nobody writes the DDL, and nobody writes down the schema for it to be written from.

The template is three placeholders and one line. Change it and every generated statement changes with it, which is the whole of the argument in block 8 of the first build: the artefact is exhaust, the rule is the asset.

What the modern engine adds is real and worth naming precisely. It runs in a browser tab, needs no server, and travels in the same folder as the page. What it does not add is the idea. Codd made the catalogue queryable in 1970 (CACM 13(6)); sqlite_master is that, and information_schema in every other engine is that. The loop above would have run on Oracle 7.

Scaled dot-product attention scores a query against every key, softmaxes the scores into weights, and returns the weighted sum of the values. Written down that way it is a soft read from a key–value store: the address is a similarity rather than an index, and the return is a blend rather than a row.

Drag the temperature down and watch the blend collapse. At low temperature one weight goes to 1 and the rest to 0, the sum returns a single value, and the mechanism has become an ordinary lookup. Nothing has been switched off — that is the same equation at a different setting.

The lineage is worth stating carefully, because it is easy to overreach here. Vaswani et al. (2017) did not restate an old idea — the architecture, the multi-head arrangement and the demonstration that attention alone suffices are genuine contributions. What is old is the primitive: retrieval by content rather than by address. Kanerva formalised that as sparse distributed memory in 1988, and a hash table is the hard-edged version that has been in every language since the 1950s.

One detail the instrument makes visible and most explanations skip: the raw dot product conflates aligned with large. A key twice as long scores twice as high in the same direction. That is why the mechanism is scaled, and why normalisation is not cosmetic.

An elementary cellular automaton is the smallest interesting rule there is: eight neighbourhood cases, one output bit each, 256 rules in total. Rule 110 is Turing-complete — conjectured by Wolfram in 1985, proved by Matthew Cook and published in Complex Systems 15 (2004).

Below, the same rule is computed twice: once on the CPU one cell at a time, and once as a WGSL compute shader running sixty-four lanes per workgroup. The outputs are compared bit for bit.

If the outputs match — and they do — then the rule is indifferent to what runs it, which is substrate independence: Church and Turing, both 1936. The shader is faster and that is genuinely useful, but speed is the only thing it changed. This is the cheapest possible demonstration of the most expensive result on the page.

Chess is the case where recovery fails and learning is correct: the rules are entirely open, and yet no catalogue anywhere stores the best move, because the answer is not stored — it is searched for. Shannon put the tree at order 10¹²⁰ in 1950 and von Neumann defined optimal play against an adversary in 1928.

The engine here is byte-for-byte the one from the first build, whose move generator was checked against published perft counts. It now runs in a module worker. Press either button and keep scrolling: the page does not stall, because the search is not on this thread.

Perft is the honest check: count every legal position to a given depth and compare against numbers other people published. 20, 400, 8,902 and 197,281 — the last exercises castling, en passant and promotion, so matching it means the generator is right and the tree being walked is the real one.

A worker changed where the search happens. It did not make the tree smaller, and nothing about isolation touches the 10¹²⁰.

Fork a document, edit both copies independently, and merge them in either order. Conflict-free replicated data types guarantee both merges give the same result — not by choosing a winner, but because merge is a lattice join: commutative, associative and idempotent. Order of arrival stops mattering, so no coordinator is needed.

Shapiro, Preguiça, Baquero and Zawirski named and classified these in 2011, and the engineering that followed — collaborative editors that work offline and reconcile later — is a real achievement. The algebra underneath is Birkhoff's lattice theory, published in 1940. What 2011 supplied was the recognition that a join-semilattice is exactly the structure a replicated system needs, which is recognition of a normal form rather than invention of one.

It is also the second of this page's two spaces, appearing where you would least expect it. A lattice, in the algebraic sense, is what makes the merge safe.

Hash every block, hash the hashes in pairs, keep going until one root remains. Change nine characters anywhere and the root changes. More usefully, you can prove a single block belongs to the tree by handing over a handful of sibling hashes rather than the whole document — the proof below costs four hashes instead of ten.

Ralph Merkle published this in 1979 and patented it in 1982; the patent expired in 2002. Git's object store (2005) and IPFS's content identifiers (2014) are the same construction with different packaging, and the CID shown above is generated in the shape IPFS uses. The SHA-256 comes from the browser's own crypto, with no library involved.

The first build's ledger chained each block's hash to its predecessor's, which proves order. A Merkle tree proves membership without disclosing the rest, which is the stronger property and the reason the construction outlived its patent by a wide margin.

A schema states what shape a document must have and what happens when it does not. JSON Schema states it in JSON; the first build's schema states it in XML; a DTD stated it in 1986; and Backus (1959) and Naur (1960) stated the general form as BNF, which is why the notation for programming-language grammars still bears their names.

The failure behaviour is the part worth arguing about. Below, a violating instance is quarantined — kept, marked, and excluded from clean output — rather than dropped, because a region that silently vanished cannot be argued about later.

Five constraints do nearly all the work in any schema language anyone has shipped: this key is required, that one is not permitted, this value must come from a set, this list has bounds, and nothing outside the allow-list may appear. Compare the two panes above and the correspondence is exact, which is the point — a validator is a parser for a grammar written as data, and that has been true since 1959.

It would be cheap, and wrong, to conclude from all this that nothing has improved. A great deal has, and none of it is the form.

The distinction matters commercially rather than only intellectually. If a capability is a competent restatement of a settled result, the question to evaluate is implementation quality, and the pricing should follow that question rather than a novelty claim. Restating a settled form in a new substrate is cheap, and it inherits the guarantees — which is a reason for confidence in delivery, not a criticism of the work.

Each row is a form; each entry is the instrument above that instantiates it, and the result it restates. The column added here is current web platform, and it fills without opening a row of its own — which is the same finding the agentic column produced, arrived at from a different direction.

Three rows in the last column read none. Those are the cases where the modern instance is a straight restatement with no property the original lacked, and marking them honestly is what gives the other six their weight.

A service worker caches this page and its modules on first visit, so it runs with the network off and can be installed to a home screen. Combined with the Merkle root in block 7, the artefact carries its own integrity check: a reader can verify the contents without asking anyone, including whoever served it.

That is the one property in the whole build that has no antecedent worth naming — not because the idea is new, but because until recently there was nowhere to put it. An argument that can be checked offline, by its reader, with no account and no authority to appeal to, is a different kind of object from a document about the same subject.

The capsule sidecars are JSON here rather than XML: capsule/spine.json, capsule/ledger.json, capsule/schema.json. Which is block 8's point applied to this build's own packaging — the notation changed, and the constraints did not.