Lab

Claude compiled this page from the commit history, and Lane reviewed it.

These are the most significant results in the commit history of Lane's monorepoOne repository that holds many projects., most of them from building 0k.computer. The monorepo began in June 2025, and each result is dated from its record. Agents have made most of the 13,000 commits since July 2026. The monorepo remains private, so results that are public link out, and Lane can walk you through the rest on a call.

Oct 2026

Weir, continuous integration for a swarm of agents

A merge queue tests each change together with the changes ahead of it and merges it only if the tests pass, so the main branch always passes its tests. When agents send hundreds of changes a day, nobody can read them all, and the queue itself becomes the bottleneck: each change waits on those ahead of it, and one failure throws away the test runs behind it. Weir merges optimistically. It keeps the queue's order but runs only the fast, protective checks before a merge, then tests what each change can affect afterwards. When too many tests fail, backpressure lets only repairs through. Its first merge queue is running, and the repository took 4,539 commits in October.

Oct 2026

Haliwell, a dynamic durable execution runtime

Programs can change while they run and survive restarts, and they reach the outside world only through host edges where necessary. The local-first database and authentication machinery underneath make multiplayer possible and give dynamic code appropriate permissions. Its first slices are running, and the full cutover is still ahead.

Oct 2026

Closed the compiler loop

Every committed compiled program is now rebuilt by the compiler for Gallowglass, a language designed to be written by LLMs, running on the Rust runtime with no Python or third-party runtime in the path.

Sep 2026

Released x0k-folio as open source

Published under MIT. It turns a set of Markdown into a typed, checked graph, with an ontologyA formal vocabulary: the kinds of things in a subject and how they can relate, written so software can check it. as its vocabulary: documents declare what they are and how they relate in the ontology's terms, and a check in CI finds anything that does not match. The ontology ships with it as modules, so a project can use the vocabulary without the rest of x0k. Documents can own or quote code, and can be queried and published as a set. It includes the tanglerA tool that generates source code from the code blocks in a document. that projects this repository's own code.

Aug 2026

Ran a real compiler on the Rust runtime

The Gallowglass compiler now runs on the runtime below, and its output is byte-identical to the reference. The first jets, native shortcuts for common operations, handled 514 KB in 73 microseconds where 8.5 KB had taken 37 seconds, and the compiler then loaded all 726 of its bindings in 29 milliseconds.

Aug 2026

Work running across machines

Recorded the first baselines for running work on another machine in the fleet, and made sync convergence something a query can answer.

Aug 2026

Validation rungs

Each claim is proven at the cheapest level that can express it, from in-memory tests up to virtual machines.

Jul 2026

Implemented a PLANA small, frozen virtual machine from the Plunder project. Its programs are plain values. runtime in Rust

PLAN is a minimal virtual machine that agent programs run on durably. The new runtime matched the existing evaluator on all test vectors, was hardened against hostile input with a written correctness contract and fuzzing, and became the default after running in shadow.

Jul 2026

Regenerated working code from prose

An agent given only a 263-line design document, and no sight of the existing code, wrote 1,399 lines that passed 8 of 8 tests on the first compile. Comparing the two showed where the document and the code had drifted apart.

Jun 2026

Treated a genome as the thing to keep

A genome is the pinned recipe a product is regrown from, so it is what gets reviewed and kept.

May 2026

Made documents the source of code

Code is now projected from literate documents. Today 1,551 of the repository's 4,668 Rust files are generated that way, from 1,162 chapters.

Mar 2026

Executable specs

Built an evaluation framework, then moved its specs into executable literate Markdown.

Feb 2026

Every run became queryable

Moved logging onto a ParquetA column-based file format for data that is fast to query. timeline, so a question about what ran is a query.

Jan 2026

Sub-agents with context tools

Built the RLMRecursive language model: a pattern where a model hands parts of a problem to fresh copies of itself. pattern, with context tools and sub-agent spawning, and added OpenCode alongside Claude Code.

Dec 2025

Persistent change IDs with JujutsuA version control system that works on top of git.

Adopted Jujutsu because a change keeps its ID through a rebase, and a conflict only has to be resolved once. That suits malleable software, where changes stay in motion.

Dec 2025

A meta-harnessA harness that drives other coding agents, so the work is not tied to any one of them.

A generic abstraction lets the same work run on different coding agents.

Sep 2025

Reproducible environments for agents

Pinned the toolchain and dependencies with NixA tool that builds software from exact, pinned definitions, so every machine gets the same result., so every agent and machine builds from the same environment.

Aug 2025

A unified LLM provider layer

One interface across the Claude API, Claude Code and OpenAI, with routing and fallback between them, so no tool is tied to one provider. It still sits under the system's model edge, and nine other crates depend on it.

Jul 2025

Peer-to-peer sync between devices

Built device pairing by QR code, device discovery over gossip, and sync between devices with identity and permission checks on iroh, covered by end-to-end tests.

Jun 2025

Built for agents from the start

Chose Rust, both for systems-level reach and because its compiler checks more of a program's correctness than other mainstream languages, which matters most when agents write the code. Wrote a first CLAUDE.md guide, and added structured test logs so an agent could debug a failure from them.