The Museum of Execution — Vision, Second Edition

July 2026. The first edition of this vision was a conversation ("Hello World Execution Path") that ended with a spec for exhibit-001-elf-atlas. This edition is written from the other side of building it. The original thesis survived contact with reality. Something bigger was discovered along the way.

The original thesis, restated

Use hello, world as a microscope for the whole modern computing stack.

A trivial program becomes the narrative thread through everything: shell, ELF loading, virtual memory, syscalls, kernel, terminal, GPU, pixels, photons. Not toy diagrams (pretty but fake), not raw internals (true but unreadable) — the rare middle: real artifacts, real bytes, made narratable. The audience is patrons, not students: a thousand true fans funding a mapmaking expedition through the invisible machine.

The first edition's constitution still governs everything:

1. Every animation is trace-grounded, source-grounded, or explicitly labeled as conceptual.
2. The viewer can always ask "how do we know?" — and the answer is never "trust the animation."
3. Never let observed reality blur into explanatory reconstruction.
4. Every beautiful claim has a trapdoor down to evidence.

None of that turned out to be aspirational decoration. It became the actual engineering discipline of the project, enforced by machines.

What actually got built

The plan said: build one room in a two-pane ELF viewer, to "see what frontier models can do." What exists today is substantially more than that spec, and the delta is where the discovery happened.

The ELF Atlas — the instrument, the interactive ELF viewer engine — is live, and its first room is one committed, byte-canonical 16,984-byte PIE binary, dissected completely: every header, section, table, and padding gap accounted for in a coverage partition that a checker enforces (no byte unexplained). Two acts — the file as it sits on disk, and the ribbons that show what the loader does with it. Two scales — readable "map" floors, and a true byte-proportional view honest enough to show that 9,424 of the file's 16,984 bytes are padding. An inspector with typed struct views, a hex viewer, source-interleaved disassembly (DWARF line maps down to the lea/call puts@plt arithmetic that lands on "hello, world" in .rodata), strings, and relationship edges — .rela.plt patches .got.plt, sh_link threads the tables together, DT_NEEDED points at libc.so.6. The "living graph" the first edition asked for.

Around it grew things the first edition didn't anticipate:

• A state grammar. The entire Atlas is driven by one canonical, URL-addressable state object — view, scale, examine, select, illuminate, tab, entry. Every one of thousands of legal camera positions over the artifact has a name. This looked like an engineering convenience. It turned out to be the load-bearing invention (see below).
• Tours as data. A tour is not a video or a script; it is {title, steps: [{state, caption, highlights}]} — validated, replayable, exportable. The docent panel plays them; a scrollytelling story.html and a static article ("How a file becomes a process") are renderings of the same tour data through different pipelines.
• A conservation department. A behavior-fingerprint harness replays 95 canonical states plus the curated tour in headless Chrome and diffs normalized state, geometry, ribbon endpoints, and content hashes against a baseline in ~3 seconds. Fixture invariants (--check) prove the coverage partition against the canonical bytes. Verification gates, not eyeballs. This is what "trace-grounded" means when it grows teeth.

The discovery: rooms an agent can inhabit

The pivotal move was small on paper: put the Atlas behind a Cloudflare Worker and expose it over MCP. A visiting AI agent — any agent, anywhere — calls join_session with the code shown on a visitor's page, reads get_agent_guide (the wall text written for agents), and then drives the room live: apply_state to move the camera, play_step to narrate a beat, and export_tour to leave behind a shareable, replayable artifact of the conversation — while the human asks their questions in their own agent chat and watches the answers land in the room.

What this produced was not a feature. It was a new kind of medium — arrived at almost by accident, the way media usually are.

Consider what reading a technical book actually looks like today for anyone working seriously: you hit a passage, you screenshot the page, you paste it into a model, you ask your question. It half-works. The model sees a fragment; it doesn't have the book, the artifact the book describes, or any way to show you anything. The conversation is grounded in a photograph of a page.

Now invert every part of that:

• The narrative is still there. The curated tour is the authored spine — a real author's judgment about what matters and in what order. You can read it linearly, as a story, as an article, as a guided tour. Nothing about this medium abandons narrative; narrative is the front door.
• But the full territory is addressable. The book's "pages" are the thousands of legal states over the actual artifact. When you branch off the spine — "wait, what's actually in .got.plt before the loader runs?" — the docent doesn't answer from a fragment. It navigates. It has the whole artifact, byte-canonical, plus the guide, plus the relationship graph. Full context is native, not pasted in.
• The docent points by moving the camera, not by describing. "The state does the pointing, the caption confirms." An answer to your question is a place in the room, arrived at together, not a paragraph about a place.
• And the medium is honest by construction. This is the part with no precedent in "chat with your PDF." play_step is strict: a caption citing an out-of-range offset, a wrong index, a hallucinated section — rejected verbatim, no beat recorded. Every number in the guide is checkable against fixture facts. The agent-guide itself was hardened by cold-agent tests: hand a fresh agent nothing but the guide, and check whether the tours it produces are truthful. The docent cannot confidently gesture at something that isn't there. The trapdoor to evidence is a load-bearing floor.

This is the thing to say plainly: I have always wanted to talk to my books. Everyone who learns hard material has wanted this. What got built here is the first working answer I know of that keeps both halves — the authored narrative and the grounded, full-context conversation — in one artifact. The book is an environment. The reader walks through it. The docent walks alongside, and both of them can touch the actual bytes.

The first edition called the killer image "a single glowing path through a vast dark cutaway of the machine." That's still true for the eye. But the deeper killer feature turned out to be for the tongue: you can stop the tour anywhere and ask, and the answer comes from the territory, not the map.

Why the state grammar is the whole ballgame

Every property above falls out of one design decision: the Atlas's entire surface is a small, canonical, validated state object.

• It's the shared language between human, page, and agent — a URL a person can bookmark is the same sentence an agent speaks to move the camera.
• It makes tours data, which makes them exportable, diffable, replayable, and renderable into three media (live docent, scrollytelling story, static article) from one source of truth.
• It makes honesty enforceable — you can't validate prose, but you can validate a state against a fixture.
• It makes the Atlas testable — 95 fingerprinted states are only possible because states are enumerable.

Generalize this and you have the design rule for every future room and exhibit, and arguably for the future book as a form:

A room is a canonical artifact + a finite state grammar over it; an exhibit is validated narration authored on top. Anything that can be expressed that way can be read, toured, taught, and interrogated — by humans and agents together.

The first edition proposed a "normalized event graph" so contributors could build visualizations without reinventing ingestion. That instinct was right, but the real unit turned out to be one level up: not the event, but the addressable state over canonical evidence.

The updated map

The Museum of Execution remains the brand. The Execution Atlas remains the interaction model. What's new is the understanding that every room is also a conversable book, and the roadmap now runs on two rails at once: more territory, and deeper medium.

Rail 1 — more territory (the original episode ladder, intact):

1. The ELF awakens — built, live, verified. The artifact before awakening: the file that teaches the loader how to build a process.
2. The loader builds a world — execve, mappings, relocation in motion, the PLT resolving puts live. The ribbons view is already the overture.
3. The syscall trapdoor — write(1, "hello, world\n", 13) crossing the boundary.
4. Onward down the original line: kernel interior, tty, terminal, compositor, GPU, pixels, photons. Each one a finished jewel, never a half-mapped swamp.

Rail 2 — deeper medium (the new rail):

• The Reference Linux Archive (spec'd, next up): a build-id content-addressed store of prepared binary knowledge — per-function disassembly, DWARF source, call edges — for a pinned distro snapshot, queryable by agents over MCP, renderable as narrated exhibits through the existing story pipeline. End state: give the system a binary, ask questions about any call it makes — including into libc — and get back a truthful, narrated, shareable exhibit. This is the library wing of the museum: the docent's answers stop being bounded by one room's fixture and start being bounded by the whole archived corpus.
• Tours as a publishing format. One tour already renders as live session, story, and article. Keep pushing: tours exported by visitor conversations are new pages in the museum's guest book — the medium generates its own content.
• Cold-agent testing as editorial QA. The guide-hardening loop (fresh agent + guide only → judge the tours) generalizes into the quality discipline for every future room, exhibit, and archive entry. Documentation whose correctness is tested by whether a stranger-agent can teach truthfully from it is a genuinely new kind of writing.

The patron pitch, updated. The first edition said patrons need a "smallest dazzling proof": a 60–90 second trailer showing the shape of the ambition. The proof is now better than a trailer, because it's real and two-way: open the room, get a session code, and watch an AI docent — running anywhere — walk you through an actual binary, answer your actual questions, and hand you a shareable tour at the end. The promise is no longer "we will build the most beautiful and technically honest explanation of hello world ever made." It is that, plus: and you will be able to talk to it, and it will never lie to you, because it can't.

What this is now

The first edition closed by calling the hello binary "the first room in the museum." That room exists. It is byte-honest, machine-verified, deployed, and inhabited — the first room anywhere that a visiting AI can hold in its hands while talking to a human standing inside it.

The project set out to make the invisible machine visible. It has ended up somewhere further: making explanation itself into an environment — one medium where narrative, evidence, and conversation are the same object. That is what future books should be. That is what gets built next.

The cathedral was never the point. The point was that each room be real. The first one is. Keep going.