Can Your Agent Outrun the Pace of Model Progress?

Every time a new model drops, my feed splits cleanly in two. Half the people are euphorically topping leaderboards, posting demos, and rewriting prompts at midnight. The other half are quietly panicking—panicking about the exact same thing: is the stuff I spent months grinding on about to get wiped out by a single update?

I’m in the panicking half. And I think that panic is healthy—a lot more honest than blind excitement.

The root of the anxiety: you might be standing in the model’s path

This anxiety isn’t melodrama. It has a very concrete source.

How much of your Agent’s capability today comes from “working around how dumb the model is”? To stop it from hallucinating, you wrote a long wall of prompt instructions. To make it look things up, you wired in a pile of tools. To keep it from forgetting, you built a memory system. That work is real, and it’s exhausting.

But here’s the catch: the next generation of models will likely turn all that “exhausting work” into “built-in.” The retrieval you stitched together with a tool chain? It ships with that natively. The reasoning stability you coaxed out of careful prompting? It has that by default. The moment that happens, the thing you so carefully built isn’t surpassed—it’s absorbed. It goes from being your moat to being a single line of fine print in the model’s release notes.

This is what people mean by “getting eaten by the model layer.” It’s real, and I’m not going to sugarcoat it. But it’s nowhere near as simple as “therefore building applications is pointless.”

The direction models get stronger and the direction good Agents create value are not the same line

Eventually something clicked for me: models are evolving, but what they’re evolving is general capability—stronger reasoning, longer context, fewer hallucinations. That’s a road heading toward a “smarter general-purpose brain.”

But a genuinely valuable Agent? Its value usually isn’t about being smart at all. It’s valuable because it understands one specific domain deeply, because it has accumulated proprietary data nobody else can get, because it has orchestrated a gnarly multi-step workflow into something that actually flows, because it has genuinely integrated with the customer’s old, messy legacy systems.

These two directions intersect, but they’re far from the same line. No matter how smart the model gets, it won’t automatically know which exact clauses trip up your law firm when it reviews contracts, or which landmines you’ve stepped on. It won’t spontaneously grow the workflow you ground out over three years with real users. Progress in general intelligence doesn’t fill the trench of domain depth.

So a model upgrade isn’t necessarily a threat to me. It can just as easily be leverage—the stronger the model, the more (and more complex) work my Agent can take on, and scenarios I didn’t dare touch before are suddenly in reach. It all comes down to one thing: am I doing my work at the boundary of the model’s capability, or am I standing on its shoulders building toward something higher? In the first case, every time it grows taller you get flattened. In the second, every time it grows taller you get lifted.

A ruler I actually use: model-dependent value vs. model-independent value

To turn all of this into something operational, I gave myself a ruler: split an Agent’s value into two piles.

One pile is model-dependent value—value that, at its core, is patching the model’s current weaknesses. The moment the model upgrades, this part depreciates, sometimes straight to zero.

The other pile is model-independent value—domain knowledge, a proprietary data flywheel, the orchestration of complex workflows, deep integration with existing systems, reliability hammered out through iteration in real-world scenarios, and higher up the stack, network effects, switching costs, brand trust. This value has basically nothing to do with which generation of model you’re on. Swap the model and it’s still there. Make the model stronger and it actually rises with the tide.

With that ruler in hand, the question that scared everyone finally has an answer: don’t ask “can I outrun the model?”—ask first “how much of my value is model-independent?”

If you do the split and find 80% of your value comes from the model itself—you’re just slapping a UI on an API call and doing a little prompt tweaking—then yes, you’re fragile, and every update compresses you. That’s not because you didn’t try hard enough; it’s because you’re standing in the wrong place.

Conversely, if you make that model-independent pile thick enough—thick data, thick workflows, thick integrations, thick trust—then model progress stops being a threat and becomes a tailwind. At that point, the right move is precisely to treat the model as an engine, not as the product. Engines are meant to be swapped: a new model comes out, you drop it into the foundation seamlessly, and the whole thing gets stronger. Your product is the car, the racetrack, the loyal customer base—not the engine itself.

The moat works the same way. What’s genuinely hard to copy is never the topmost layer of technology. It lives in network effects, in “the customer has embedded you so deeply into their daily workflow that the cost of switching off you is excruciating,” in the hard-won trust people place in you in healthcare, finance, and legal—domains where a single mistake is fatal. A model upgrade can’t touch any of that.

The most dangerous position, and the safest one

So after going around the long way, the picture in my head is actually simple—just two images.

The most dangerous position is a thin layer of wrapping. You’re plastered onto the surface of the model, and every inch it rises up, an inch of your living space gets scraped away. You think you’re surfing, but you’re really just floating on the crest—the moment the wave changes shape, you’re gone.

The safest position is a deep well. You commit to one vertical, dig down relentlessly, and reach a depth no one else can be bothered—or is able—to reach. How deep is deep enough? Deep enough that every time the model evolves, it only makes the water in your well more abundant—not your well redundant.

Models will keep getting stronger. We can’t change that, and we shouldn’t want to. The only thing we get to decide is where we stand. Are you the wrapper that can be scraped off at any moment, or the well that’s worth more the deeper you dig?

Stop agonizing over whether you can outrun the model. Look down at what’s in your hands: of all your value, how much of it is model-independent?

That number tells your fate better than any keynote ever will.