Most computing platforms in wide use today were designed before machine learning became a primary computing paradigm. The file system assumes data has a location. The API assumes a call has a correct answer. The interface assumes the person will do the interpreting. Onto this deterministic substrate we have now grafted models — probabilistic, contextual, always partially wrong — and the graft shows everywhere: in the prompt boxes bolted onto apps, in the confidence theater of chat interfaces, in systems that can reason about the world but can't remember what they learned yesterday.
The industry's response has been to keep retrofitting. Add a vector database beside the relational one. Add an inference endpoint beside the REST endpoints. Wrap the model in enough deterministic scaffolding that it behaves like the software we already know how to operate. This works, in the way that running a car engine on a horse cart works. It also quietly caps what the technology can become.
What retrofitting costs
Consider what a model actually is: a representation of the world that improves with evidence, degrades without it, and is never finished. Now consider what our platforms assume software is: versioned artifacts with fixed behavior, released, then replaced. The mismatch isn't cosmetic. A system that learns continuously has no natural place in a world of releases. So we freeze the model, ship the freeze, and throw away the thing that made it interesting — its ability to keep adapting to the person in front of it.
The interface mismatch is worse. Deterministic software earned the right to present results as facts, because given the same input it produced the same output. Models inherited the presentation without the property. A probability dressed up as an answer is a small lie, and interfaces built on deterministic assumptions tell it constantly. The fix isn't a confidence percentage in gray text. The fix is platforms whose primitives understand that every output carries uncertainty — and whose interfaces are honest about it by construction, not by disclaimer.
We froze the model and shipped the freeze — and threw away the thing that made it interesting.
Starting from the model
AI-native computing, as we're pursuing it, means inverting the design order. Start with the model's nature — probabilistic, continuous, personal — and derive the platform from it. We think memory should become a first-class primitive, not a database bolted on: what the system knows about you, inspectable and revocable, accumulating across every interaction rather than resetting at each session boundary. Computation should become anytime and interruptible, because inference is a budget, not a transaction. And the interface layer should shrink, because a system that genuinely understands context needs to ask so much less.
The Ring is our first working argument for this inversion. It has no retrofit surface at all — no app to check, no prompt to fill. The intelligence isn't a feature inside the product; the product is being designed as a body around the intelligence. Sensing feeds on-device interpretation today, where the person's data belongs. Building that into a persistent representation — and eventually letting that representation drive behavior — is the primitive we're building next. It's a small platform, deliberately. Small enough to get the primitives right.
The history of computing is a history of substrates: batch gave way to interactive, desktop to web, web to mobile. Each shift looked optional until the software built natively on the new substrate embarrassed the software ported to it. We think the model-native shift is the same kind, and that the embarrassment phase is closer than it looks. The platforms worth building now are the ones that assume the model was always there.