A Million Lines

I have written elsewhere about what the last four years cost me — that is The Transmutation of Meaning, and it is the honest version, so I won't repeat it here. I have also written down the idea the whole time was chasing: the thesis, and the calculus underneath it. This post is the third thing, the one a reader can put their hands on: the artifacts. The code that survived.

What I was actually building#

The short version, because the long one is elsewhere: I spent seven years at Amazon building planning, scheduling, and control systems for a workforce of roughly a million people, then left to point the same machinery at software itself.

Console One was meant to be "the network as one computer" — a single program that held, inside its own API, version control, deployment, process management, and resource contracts, and could deploy copies of itself across machines. StoryLens was supposed to be the simple follow-up — connect AI to your tools, summarize, report — and instead re-derived the exact same kernel from the opposite direction. Shared Office is the third pass, the one where the kernel finally got extracted from the products and stood on its own.

The thing I didn't expect — and the reason any of this is worth publishing — is that it was always the same object. Three products, three starting points, one recurring shape. Each library below worked in isolation; for years, none of them worked together. That gap, the problem within the problem, is what the calculus finally closed, and closing it is what made the keepers identifiable.

Why most of it isn't here#

The better part of a million lines is mostly scaffolding, dead ends, and the same idea typed out five times until it was right. Open-sourcing all of it would be noise. The cut was simple in principle and brutal in practice: a library earned its place only if it does exactly one thing, stands on its own, and teaches something true even to someone who never reads the rest.

Naming the kernel is what made that judgment possible. Once I could see the shape the whole corpus had been approximating, the approximations fell away, and what was left was a small set of primitives that kept re-deriving themselves no matter which direction I started from. Twenty-two of them are now public under github.com/console-one. Here is what they are.

The kernel#

The center of everything is a type language. sequence is the kernel I kept rebuilding until it was small enough to defend — twice, and both versions are in the repo. v1 was the first crystallization, where a type could carry a deadline, a confidence, and a price. v2 is the one I finally believe in: one lattice, one operation, and every feature — gates, budgets, backlinks, scheduling — a rule you mount rather than code you add. It runs about a thousand tests on zero dependencies, and it is the evaluator the thesis kept demanding: a plan that means the same thing on a laptop's SQLite and a cloud's Postgres.

fieldtype came before it — a CUE-inspired structural type system where the type is the fold function, so there is no separate ORM and no query engine; the type evaluates itself. scope is the smallest version of the same instinct aimed at a single question: can one constraint kernel serve access control, typing, gates, and lifecycle at once? Its answer — three-valued verdicts with a per-verdict policy — is where I learned that escalating a blocked decision to whoever owns its resumption is its own distinct operation. And substrate is the one that worked end to end: the original Office Space, the proof that a team's memory, its calendar, its scheduler, and an agent's context window are four reads of one append-only log.

Cost, control, and execution#

guardrail is the literal guardrail of the thesis: identity-keyed resource budgets that discover their own dependencies and commit atomically — the answer to "how do you keep a fleet of agents from quietly bankrupting you." compile is where I learned that a budget is a price, not a cap: it renders an object graph under a token ceiling by deciding, for every shared sub-expression, whether to inline it at each use or hoist it once and reference — constrained optimization, not truncation.

runtime turns a typed value into a running, addressable, subscribable process by wiring together three libraries that know nothing about each other, and it taught me two things I keep quoting back to myself: persistence is subscription, and a type's constraints are its schedule. process is the substrate beneath that — long-running computations you can pause, resume, cancel, and seek, that replay their history to whoever subscribes late.

Versioned data#

source is an event-sourced version-control engine generic over content type, built for stateless serverless runtimes where Git, CRDTs, and OT each assume something you don't have. It taught me that deterministic replay is a provenance rule, not a feature. patchkit is the polymorphic layer above it — any data structure, the same five operations — and the part that still matters most: every mutation carries its own inverse, which is the prerequisite for ever genuinely changing your mind in a system that refuses to lie about its past.

cell I am leaving up as a fossil. It composed the three libraries above into a versioned cell, and I deleted it downstream for re-implementing the substrates beneath it. That deletion became a law I now hold tightly: do not invent a fourth primitive when three composed ones will do. sequenceutils is the companion belt to the kernel — the agent loop, the index policies, the transport, the React hooks — kept outside the kernel on purpose, so the core stays small enough to hold in your head.

Language and structure#

These are older, mostly archived, and several of them are quietly the reason I believe features should be vocabulary rather than subsystems. parser is a pushdown parser whose grammars compose at runtime — a guest language parses on the host's own stack, no sub-parsers — which is how you embed one language inside another without forking the engine. segment generalizes that into a single addressing primitive across formats; the as operator in the shipped product is its one-boundary special case.

disambiguator is a probabilistic decision-tree executor that evaluates whichever branch prunes the most expected work first — the seed of the idea that inference order is itself a decision under budget. walker walks a tree once and fires per-path handlers, a one-pass answer to multi-path extraction. And namespace is a temporal artifact index: address anything across identity, version, and stage in one path, with live-versus-pinned fallbacks — the distinction that became "give me the latest" versus "give me exactly this version" in everything I built after.

The plumbing#

The smallest pieces, and the ones most likely to help a stranger with an unrelated problem. address gives one object many simultaneous identities — tenant, environment, version, parent — in a single round-trippable string. wire is a structural codec with delta encoding that independently re-derived the same hoist-versus-inline decision I'd found in compile, which is how I knew the pattern was real and not a coincidence. subscription is an observable-promise hybrid: a value that might already exist or might arrive later, that replays to late subscribers and back-pressures when overwhelmed. And collections and multimap are exactly what they sound like — observable queues, heaps, index maps, multimaps — the unglamorous floor the rest of it stands on.

An invitation#

None of this is the whole of Shared Office. That is a product, and most of a product is the boring, specific work of making one thing reliable for one kind of person. This is the layer underneath — the frameworks that made it, and the ones that made Console One and StoryLens before it.

I am putting them in the open for the plainest reason I have. I have spent a long time being right in private, and I have learned the hard way that being right in private is the same as being wrong. So if you read the code, or the calculus, and you think the shape is wrong — a primitive that shouldn't exist, a rule that's missing, an abstraction that doesn't earn its place — I would rather hear that than almost anything. Open an issue or a pull request on any of the repositories, or email me. I will engage with it in good faith, and if you show me I'm wrong, I will be genuinely delighted — because being shown wrong in public is the only version of this that was ever worth anything.

I would love nothing more than a collaborator who proves me wrong. That is not humility. It is the whole point.