Let me begin with a claim I can't fully prove but increasingly believe: the way humans interact with AI will determine what the next generation of products becomes — not the other way around.
The conventional view treats interfaces as surfaces — the last layer applied to technology, like paint on a wall. I've come to think the causality runs in reverse. The way humans touch a system eventually reshapes how the system is built. The iPhone didn't merely remove the keyboard; removing the keyboard redefined what a phone was. We are at a similar threshold now, and almost no one is designing for it.
To explain why, I need to start at the bottom of the stack.
What a database grows
Here is a pattern that, once noticed, becomes impossible to ignore: every era's dominant products are grown by that era's dominant data structure.
The relational database — rows and columns — quietly shaped twenty years of software. What did it grow? CRM and ERP: the two most successful software categories in history, and underneath, the same organism. A predefined process with data poured into it. Structure first, data second. You design the pipeline; then you push the world through it.
Vector databases invert this premise entirely.
In a vector space, every piece of context is a discrete point — flat, unranked, belonging to no parent table. Structure is not designed upfront; it emerges from the weights between points. No one draws the org chart. The org chart grows.
We've already witnessed this inversion once, in recommendation systems. Keyword search could only find relationships between words. Modern feeds infer intent, derived from behavior. Consider the classic case: the correlation between buying diapers and buying beer. No keyword connects them. A behavioral chain does. The relevance had always existed — it simply couldn't surface until the underlying data structure allowed it to.
Structure used to be something we designed. It is becoming something we discover.
What this means for how organizations work
Now aim that idea at a company.
Today, when something consequential happens — a launch, a decision, a crisis — we pull people into a room and manually align context. Someone summarizes. Someone updates the document. Someone forgets. Context alignment is the most expensive ritual in modern work, and we perform it dozens of times a day without questioning it.
There is an alternative worth imagining seriously: context should surface around events, rather than be assembled in meetings.
When agents collaborate, their handoffs, decisions, and reasoning do not form a tree. An agent's outputs are versioned; its sessions run in parallel; its collaborations cut across every boundary you might draw. The shape is closer to a honeycomb than a hierarchy. Forcing it into folders is like filing a river.
Picture the alternative: an event occurs, and the relevant context rises on its own — weighted by decisions, by outcomes, by what actually mattered. The CEO doesn't excavate threads. The thread finds her. And the moment it catches her attention, she can reach directly into the session where the work is alive.
Geography offers the right metaphor. Context is terrain. Important things become mountains — not because someone declared them important, but because weight accumulated there. When the market shifts, the mountains move. The data comes first; the mountain forms after. Never the reverse.
What this means for the interface
If structure emerges and context surfaces, what should the interface of an AgentOS look like?
Not a dashboard. Not a tree view. Not forty buttons competing for a click.
Every designer of AI products should sit with this tension: humans hate reading structure, yet humans are extraordinary at reading terrain. We cannot bear nested bullet points, but we know at a glance which mountain is taller and which fire is closer. Our eyes evolved for landscapes, not spreadsheets.
The work of the interface, then, is not to display structure. It is to let the right things rise. Subtraction over addition. Emergence over arrangement.
This points to the resource that will actually matter. In an organization where agents do the work, the bottleneck is no longer labor, and it is no longer information. It is human attention — where it lands, and how quickly it can travel from noticing to acting.
Attention is the last scarce resource. The interface is how an organization spends it.
The bet
Assemble the three layers and they reveal themselves as one thing:
- A data layer where structure emerges rather than being designed
- An organizational layer where context surfaces rather than being aligned
- An interface layer where attention is spent rather than scattered
Build any one of them in isolation and you get a feature. Build them as a single system and you get the next computer — the one humans and agents will share. Perhaps it lives on a phone. Perhaps in VR. The container matters far less than the paradigm.
We are building toward this. I won't pretend it's all figured out — much of this is conviction running ahead of evidence, which is the only honest place a builder can stand.
But I'll end where I began, because I believe it more now than when I wrote the first line:
The interface is not the skin of the product. It is the seed.