Your Life Compiles to One Language

Heterogeneous archives become joinable only when compiled into one text intermediate representation — closure bundles as translation units, the wiki as IR, agents as runtime.

Scott Farrell · LeverageAI · July 2026

You open a backup and find a Lotus Notes .nsf. You do not have Notes. Twenty years ago that file was a sealed tomb: find the product, the licence, the matching OS, fight the install, export something half-broken, then — maybe — read your own past.

Today a coding agent looks at the same file, synthesises a reader, and opens it. Notes is not a ZIP with delusions of grandeur; it is a proprietary storage model with a real native API surface.¹ Open-source projects have spent years reverse-engineering enough of the on-disk format to pull data out forensically.² That the agent can manufacture a tool at the tomb door is not a parlour trick. It is a change in the economics of personal archaeology.

Format extinction is ceasing to imply information extinction.

But opening every format is not the same as thinking across them. That is the real problem this piece is about.

The stack that will not join itself

A multi-decade personal or corporate archive looks like this:

These share almost nothing: formats, schemas, access methods, metadata, vendors, eras. You can RAG each silo. You can prompt harder. Microsoft’s own GraphRAG work states the limit plainly: baseline RAG struggles to connect the dots when the answer requires traversing disparate pieces through shared attributes.³ Fixed-size chunking makes it worse — guidance from Microsoft’s architecture centre warns that it is a poor fit where semantic understanding and precise context matter, because relevant material spanning chunks is easy to lose.⁴

The industry’s answer is usually “retrieve better.” That is still the wrong altitude when the representation difference itself forbids the join.

Semantic homogenisation

The move is not to make every system speak one vendor protocol. The move is to lower meaning into one thinking surface:

Call it semantic homogenisation. The sources remain heterogeneous. The bronze stays bronze. But once people, projects, events, claims, and edges live as text pages, the original source class stops controlling which connections are possible.

That is why a chain like rsync → Samba → Tridge → KnightCap → computer chess → Joel Veness → your own engine can become thinkable in one sitting. Documentation for rsync does not know your social life. Your email does not know Samba’s history. A chess results page does not know you are restoring a multi-terabyte RAID in 2026. Homogenisation collapses the representation difference so those edges can meet.

(Why text? Because that is where language models reason sharpest — a modality claim we treat as a one-line cameo here; the full argument lives elsewhere as Text Is the Model’s Home Turf.)

The wiki is the intermediate representation

Compilers do not ask every optimisation pass to understand C, Rust, Fortran, and Swift. They lower source languages into an intermediate representation, then work on the IR.⁵

You are doing the same thing to a life — or a firm:

The archive is source. The wiki is IR. The agent is runtime.

New agents become useful quickly not because each one is taught your biography from scratch, but because they compile against the same IR. Anthropic’s guidance on context engineering puts the economics bluntly: runtime exploration is slower than retrieving pre-computed data; structured note-taking / agentic memory is a first-class pattern.⁶ Offline indexing research in the same spirit shifts cross-document reasoning from every query into the index itself.⁷

RAG does not disappear. It demotes. High-recall search over raw residue remains a valid lane for single-document, well-formed lookup. Multi-hop synthesis and reused world understanding pay for compilation. The raw archive is not the memory. It is the territory. The wiki is the map agents can live in.

Semantic closure: the translation unit

Here is the grain mistake almost everyone makes: they hand the model a record.

A Lotus Notes response that says “Yep, agreed. Let’s do the second option.” is storage-complete and meaning-empty. The meaning lives in the parent document, the reply tree, and the related history. Bundle those deterministically and you get a meaning-complete object. Then — and only then — ask the model to compile significance and edges.

That unit is semantic closure: the smallest deterministic bundle whose meaning closes.

The same pattern shows up five times with different natural keys:

Where a natural key already exists, join on it before you reach for embedding similarity. Soft data can take SQL-shaped discipline: the folder name proves which conversations created the code, not merely which ones resemble it. That is the Soft Join move — provenance over resemblance.

Industry tooling already gropes toward hierarchical grain (parent-document retrieval returns small chunks for recall and parents for context).⁸ Closure is the stricter doctrine: choose the unit so meaning closes before the model is asked to judge.

Bundle-epistemics

Grouping is not a batching optimisation. It changes the quality of the evidence.

One spam email can look vaguely plausible. A cluster of three hundred similar messages screams: this whole branch is rubbish. The model is not being asked to be cleverer. It is being shown a closed bundle whose pattern is obvious at the right grain.

The join no single system owned

The proof that homogenisation is doing real work is a join that no source system could have made alone.

You are restoring files with rsync. The tool’s intellectual lineage runs through Andrew “Tridge” Tridgell — also Samba, also the chess engine KnightCap. Adjacent in the old Australian computer-chess scene: Joel Veness, and your own private engine. None of those systems held the full chain. The wiki (and the conversational reconstruction over it) does. That is not “search got better.” That is post-homogenisation geometry: person axis, software axis, time axis, present-context axis rotating until edges intersect.

You do not need a chatbot essay in the corner of the screen. You need the edges: Tridge · KnightCap · Joel · Chompster. Then the human brain floods. Recognition, not a lecture.

The two-stage discipline

Run this and stop inventing new frameworks every time a format appears:

1. Bundle until meaning closes. Deterministic structure first — thread, tree, project key, event cluster. Do not feed naked records.
2. Lower into shared IR. Claims, people, projects, events, typed edges, uncertainty, pointers back to bronze sources.
3. Run agents against the IR. Gmail, research, CV, router, dev — one compiled world, many runtimes.

Keep the bronze. The map is regenerable only over territory that still exists. Do not turn the graph into mush by linking everything to everything. Do not re-teach every agent your life when the IR already holds it.

Everything doesn’t need to be in context. Everything needs to be reachable through meaning.

RAG retrieves. A living wiki breathes: expanded from the world, recompressed into a worldview, then used to interpret the next event. Agents that inherit that past earn the right to be silent — and when they interrupt, you listen, because most noise never made it through a compiled baseline of what is normal.

That silence is a runtime consequence of the IR. How agents perceive moment-to-moment is a neighbouring article. This one is the compiler frame end to end: translation units, intermediate representation, runtime.

Your life will not join itself. Compile it into one language — then let the agents run.