Transcription: 

We’ve been thinking that the idea that everybody will have an agent is just the surface level. Here’s the deeper level.

What’s actually taking shape underneath that idea is not about agents themselves, but about making capabilities reliable, structured, and callable. The agent is simply the interface layer. It is how humans will interact with systems—through conversation, through intent, through requests that feel natural. That part is real, and it will become ubiquitous. But it is not where the enduring value sits.

The deeper shift is that what you do is beginning to separate from how it is accessed. Instead of embedding your knowledge and workflows inside a person, or even inside a tool, those capabilities are being defined in a way that allows them to be invoked by other systems. Not loosely described, not dependent on interpretation, but explicitly structured so they can be called, executed, and verified.

This is where the analogy to the early web becomes more precise. The first wave was about visibility—take what you do and put it on a web page. That worked because it made information accessible. But what ultimately scaled the internet was not just pages; it was structured access to functionality. APIs, not just websites. We are now seeing that same pattern re-emerge, except the consumer is no longer just a human browsing a page. It is an agent acting on behalf of a human.

So the question is no longer just whether you will have an agent. The more important question is what your agent can access, what it is permitted to do, and how those capabilities are defined behind the scenes. That is the layer now coming into focus. Capabilities are being described in terms of inputs, outputs, requirements, and constraints, so that they can be reliably used across systems without bespoke integration each time.

Standards are beginning to form around this idea, and whether a specific protocol becomes dominant is less important than the direction itself. The trajectory is toward modular, discoverable, and callable capabilities that agents can use consistently. That shift reduces friction, increases reuse, and changes how systems are designed at a fundamental level.

The implication is straightforward but significant. Having an agent will not be a differentiator, just as having a website eventually stopped being one. The differentiation moves one layer deeper, into how well your capabilities are defined, how reliably they perform, and how clearly their boundaries are established. In domains where correctness matters—legal, accounting, financial advisory—this becomes even more critical, because the cost of ambiguity is not just inefficiency, but risk.

What we are witnessing right now is still early, and much of the visible activity is happening in developer environments where tasks are clean and outcomes are easy to measure. But the structure itself is not limited to software. It applies anywhere work can be defined, executed, and evaluated. As that structure spreads, it will begin to shape how organizations operate, how decisions are made, and how consistency is maintained.

So the real shift is not just that we are building agents. It is that we are beginning to build the layer beneath them—the layer where capability is defined, exposed, and governed. That is where the long-term leverage sits, and that is where the conversation is now moving.