Where this goes — building for the company, not the app

01The one asymmetry the whole plan rests on

Three inputs make a model better at one organisation's work. Two of them are getting cheaper for everybody, every quarter: model weights, commoditising fast as GLM, Qwen, Kimi, DeepSeek and muse go open-weight; and training compute, which anyone with capital can rent from a dozen vendors.

The third is outcome labels on real work — knowing whether an agent run was actually any good. That one is not commoditising, and it can only be produced where the work happens: at somebody's desk, in somebody's repo, against somebody's test suite.

The two inputs everyone can buy are getting cheaper. The one that can only be produced at the point of work is not.

That is the whole thesis. It is also why “we should host open models too” is the weakest part of any future plan for 8code rather than the strongest.

02Six layers, and the ones already built

Turning work into a better model takes six layers. Four of them exist in the repo today; two do not exist at all.

We hold 1, 2, 5 and 6 — the layers that are hard to copy and cheap to build. We lack 3 and 4 — the layers capital buys.

That ordering is deliberate, and it is the opposite of starting from GPUs. The desk comes first.

03What an organisation needs that a desktop app does not

• Labels a CTO believes. “npm test passed on a developer's laptop” is not one. “Merged, and not reverted in 30 days, and CI stayed green” is. A trace carrying a commit sha can be joined to the org's own git history forever; one that does not is a dead record the moment the worktree is cleaned up.
• Aggregation without exposure. Roll up graded outcomes across a team while the code, prompts and diffs stay on each machine. Today lessons are keyed by a per-install salted repo hash — good for privacy, and structurally impossible to roll up. Fixing that is a design decision to be made on purpose, not a bug to patch.
• Bring-your-own compute. They have GPUs or cloud credits. Adaptation has to run on their infrastructure before it ever runs on ours.
• Proof before spend. The holdout arm is not a nice-to-have; it is the purchase justification. Nobody funds a training pipeline on faith, and the interval work is what stops anyone being sold noise.

04Four things being decided now, because they are expensive later

• The trace schema is a public API, not an internal file format. If graded traces are the asset, their shape is the shape of the moat — versioned, documented, and never carrying a field that cannot be explained to a customer.
• Grading is pluggable. An org needs their CI, their review approval, their revert signal, their deploy outcome. That means an oracle registry where each oracle declares what it measures, what states it can return, and what it means when it is silent — not an if-chain over three built-ins.
• The scope hierarchy comes before the data. Run, repo, org, user — and what crosses each boundary is chosen rather than incidental. Retrofitting it later is a migration over data users cannot regenerate.
• Portability is a principle, and it gets said out loud. Your traces, your labels and your adapters are yours, exportable, in a documented format. It costs almost nothing now and it is the clearest thing to say to a security review.

05Sequencing — each phase's ticket is the previous phase's number

1. Get the delta.

   Applied versus holdout on real repos, with the interval. Nothing above this line is buildable on a null: if the delta is noise, every later phase inherits the nullity.

2. Enterprise-grade oracles.

   Commit identity, PR-path signal, revert detection. Turns “tests passed here” into “merged and survived” — the label an org will pay to have and cannot easily produce itself.

3. Team aggregation.

   An org-scoped ledger with a deliberate privacy boundary. The first multi-seat product, sold on the proof surface rather than the feature list.

4. Adaptation, on their compute.

   LoRA over the org's graded traces, running on the customer's GPUs or a rented lane. We own the pipeline and the evaluation; we rent the arithmetic. Promotion gated on the same holdout comparison — never ship a checkpoint that did not beat its control.

5. Hosted, if ever.

   Only once it is known which adaptations actually win, and only because customers ask for it to be run for them.

06The honest case against each part of this

• Hosting our own open-weight models is the weakest step, not the crown. It is the commodity layer, the most capital-intensive, and the one where every cloud and every lab competes on price. Doing it early would be playing their game with a thousandth of their funding.
• Enterprise is a different company. Multi-seat, security review, procurement, support. That is a sales organisation, and it is the point where the founder's job stops being building.
• The privacy story gets harder the moment you aggregate. Today “it stays on your machine” is nearly true — with the correction that driving Claude Code sends code to Anthropic. Org rollup makes it a real engineering commitment with a real attack surface.
• Distribution is the standing threat. Anthropic, OpenAI, Cursor and GitHub can each add outcome capture to a product that is already installed everywhere. They have the desk. The bet is that being model-neutral matters more than being first-party — which is a bet, not a fact.
• Every phase multiplies the previous phase's error. If the labels are subtly wrong, aggregation makes them authoritative and training makes them permanent. Four-state verdicts, ran flags and refusing to grade what was never measured are not fastidiousness — they are the load-bearing wall of everything above.

07The sentence the company is

Not “a better coding assistant”, and not “we host open models too”.

The measurement and adaptation layer for agentic engineering — the thing that turns an organisation's real work into a model that gets measurably better at that organisation's work, on whatever weights they choose, with proof, without the work leaving their control.

Model-neutral is the point, not a hedge. Every new open-weight model is a new candidate to route to and adapt, not a competitor. Commoditised weights and commoditised compute are tailwinds for a company whose asset is the label, and headwinds for a company whose asset is the engine.

08The question that still gates everything

Does the loop measurably improve outcomes on real repos — applied arm versus deterministic holdout — and by how much?

Every phase above is priced off that number. It is currently unmeasured, and no amount of architecture substitutes for it. That is the honest state of things, and it is why the app you can use today is the part that captures and proves — not the part that trains.