The oldest gap in enterprise software just stopped being discrete. AI capability now arrives inside features that are already implemented, and no gate was built to hold it.
Every enterprise software customer runs less than they own. AI capability makes the gap worse and harder to see. The vendor ships, the customer implements a portion, and the distance between the two grows with every release. That is the oldest pattern in this industry and it has never been a scandal.
Twenty-five years ago I helped write a research note at Gartner predicting which SAP version would become a vintage release, the one customers land on and stay on long past the point where better options exist. That was ordinary work. Everyone could see the distance, and the only question was where it would settle. It settled where you would expect, with 39 percent of 35,000 SAP ECC customers having started the move to S/4HANA by the end of 2024, on a product first shipped in 2015.
We could forecast it because the gap was discrete. Somebody could work through the release notes and name exactly what was missing, which is why the usual remedies are discovery, training, and better onboarding.
That is what AI changed. Not the speed of adoption, which is the same as it has always been. Part of what now accumulates on the available side is not made of items, and no list reaches it.
Which means organizations are running less AI than they own, and cannot tell you how much less.
The Clay
Why implementation freezes what an organization believes it can do
Implementation is taking a lump of clay and shaping it to the organization. The clay is the product as it ships. The shaping is every configuration decision, every process the software gets bent around, every capability switched on and every one left alone, all of it against what the product could do in the year the project ran.
Everything built around that decision, the testing, the change management, the benefits case, assumed what we assumed: that what we were deciding about could be described. Then the organization lives with the shape, and the shape becomes normal.
The Gates Are Working
The purchase decision came out, the activation decision stayed in
The reflexive story is that AI arrives unbidden and ungoverned. In core systems of record, the documentation says otherwise.
On premise, the customer held the hardest gate in this industry. They held the bits. Version control and feature control were the same control, exercised by the same party at the same moment, which is how an organization sits on one release for a decade.
Cloud native splits them. The baseline arrives whether anybody wants it or not, and what remains to the customer is the switch rather than the version. Oracle ships mandatory quarterly updates no customer can skip, paired with an opt-in console for choosing which features to enable. SAP gates harder: Joule Base entitlement comes with eligible cloud subscriptions at no additional license cost, and turning it on is a project rather than a switch.
Note what that means. In the vendors that gate hardest, the capability is already paid for. The entitlement arrives, the gate stands where it always stood, and passing it requires a deliberate project that nothing on the calendar forces.
So the gap changed shape rather than closing. On premise, being behind meant running old code. An organization can now run entirely current code and be just as far behind, because the distance moved into activation.
That is the old gap with the purchase decision taken out of it. You are entitled to the capability and you are not running it. Closing the distance still costs a project, which puts you back at the question implementation teams have always asked: is the juice worth the squeeze. You price the work against the value, and you need both numbers.
What Accumulates Stopped Being a List
Declared capability and latent capability
Producing the value number has become hard in a way it was not before.
Microsoft documents this about its own products with unusual directness. It regularly enhances the underlying models powering Copilot, which brings performance improvements, more advanced reasoning, and expanded capabilities. Customers do not need to make changes to their environment. Existing controls, settings, and configurations are unaffected, and no administrative action is required. Model updates are explicitly not product feature changes, which travel separately through roadmap channels.
Not all of that is the same thing. Performance improvements make the same feature cheaper or faster, and vendors have shipped those forever. Nobody ever needed a gate for a faster response. The reasoning is different. That moves the ceiling on what the feature can do, and it arrives on the same release train, under the same notice, with the same instruction that no administrative action is required.
Read that as an operations note and it is reassuring. Read it as a governance statement and it says something harder: the ceiling on what an already-implemented feature can do moved, nothing appeared in a feature list, and nobody had to do anything.
That is not a gate being bypassed. The gate governs features, and this is not one.
So the available side now accumulates through two different mechanisms, not just at two different speeds.
Declared capability. The vendor says here is a new feature. This is the path every gate was built for, and it still works.
Latent capability. The vendor says the thing you already have can now do more. There is real governance and real engineering discipline behind this on the vendor side. What there is not is a feature for the customer’s gate to hold, because the gate was built to admit or refuse discrete things and this is not one. It is a change in what a system can do with no decision attached to it.
Which leaves the gap between implemented and available with two components. The features nobody switched on, which can still be counted. And the increase in what the switched-on features are capable of, which cannot.
The number will not hold still while you evaluate it, either. A vendor release could be seen coming quarters out, and its delta was fixed once it shipped. The capability underneath moves several times inside the length of the project you would run to capture it.
The Adoption Clock Did Not Change
Why the same slow process now produces a much larger gap
Nothing about how organizations adopt has sped up.
McKinsey’s 2025 State of AI survey found 23 percent of respondents reporting a scaled agentic system somewhere in the enterprise, with no individual business function exceeding 10 percent. That is the adoption clock ticking at roughly the speed it always has, against entitlement already paid for.
I lost count of the times we demonstrated current features to a long-time customer and watched the surprise that any of it existed. Not new customers. People who had run the product for years and would have told you before the meeting that they knew what it did.
Their clay was set too. The features had shipped, the release notes had gone out, the entitlement was current, and the internal known had not moved since the project. That was before any of this. The gap between what a customer owns and what a customer knows they own is not an AI problem and never was. What AI adds is a second layer, arriving underneath features they already have, which will not show up in a demonstration as a new thing at all.
Same slow clock. Much faster accumulation. The gap is not widening because anyone got worse at adoption.
What Actually Went Missing
The version horizon still exists and stopped doing its job
An organization used to assume the next major upgrade was the moment to reconsider its technological position. That is what made the upgrade cycle load-bearing for far more than software. It was the scheduled re-look, the moment the clay came back onto the table.
Now the capabilities available to that organization have changed many times between one upgrade and the next, and some of those changes never appeared in a release note. The date still arrives. It no longer catches what it used to catch.
Which is why one sentence has quietly stopped carrying the information it once did.
We’re on ECC 6.0.
That told you a great deal about what an organization could do. It still tells you which features are available and roughly when the shape was set. It no longer tells you what the system is capable of.
Manufacture the Trigger
What replaces a deadline nobody has to schedule
The instinct is to ask vendors for better notice. The notice is already there. Oracle publishes readiness materials quarterly, SAP documents activation, Microsoft posts model changes to a blog and a message center. More notice into an admin queue does not move the adoption clock, because the adoption clock was never waiting for information.
It was waiting for a deadline it did not choose.
Put a date on the shape. The clay was formed against what was possible in the year of implementation, and that year is the shortest-lived assumption in the entire system. It is written down nowhere. Record it, and schedule the re-look, because the maintenance calendar no longer schedules it for you.
Ask what the shape would be today. Not whether the workflow still works, because it does. Given what the underlying system can now do that it could not when somebody drew this boundary, is this the boundary a competent team would draw now.
Count the entitlement you are not using. For most organizations the AI capability already paid for exceeds the AI capability in production by a wide margin, and nobody holds both numbers. The gap between them is money already spent.
Borrow the attestation. Systems subject to an attestation of control get looked at on a schedule, because somebody has to sign that they know what the system does. That is a manufactured deadline, it works, and there is no rule saying it only applies where a regulator requires it.
The Vintage Question
What a version number still answers
The old world was slower and more expensive, and it stranded organizations on software that had stopped improving. Nobody wants it back.
But it was legible. The gap between available and implemented had a name, a number, and a date, and everyone in the market understood how to read it. That is why forecasting a vintage release was ordinary analysis rather than clever analysis.
Adoption was always the slow part. Capability was not always this hard to count.
The vendors did not break that. They are still gating, still publishing, still giving customers the choice they always had. What changed is that the answer to what an organization can do stopped being fully expressible as a list of features it has turned on.
The version number still tells you what you have. It stopped telling you everything you can do.
Brian Zrimsek has occupied all four seats in enterprise software: advisor at Big Six consultancies, analyst at Gartner, client at Irvine Company, and provider at MRI Software. He is the Enterprise Software and Commercial Real Estate Specialist for Lumerai Advisors and the founder of The Four Seats (thefourseats.net).
