by Marc van den Dobbelsteen

The Layer We May Still Be Looking At

I keep coming back to the feeling that many enterprise conversations about AI are still happening one layer too low. The questions sound familiar enough: how can AI help developers move faster, improve testing, generate documentation, support operations, or raise the productivity of knowledge workers? These are sensible questions, and in many cases useful ones. But the more I look at them, the more they seem to circle around the visible surface of the shift rather than the deeper structure beneath it.

That may be part of what makes the current moment so deceptively comfortable. AI can be introduced into the enterprise in ways that feel incremental. A developer gets a copilot. A support team gets a summarizer. A business user gets a conversational assistant. A process owner gets a workflow helper. The organization sees motion, and because the work still looks familiar, the change feels manageable. Existing tasks are still there. Existing teams are still there. The enterprise simply seems to move a little faster.

But I am not sure speed is the same thing as transformation. Perhaps that is the first distinction worth holding onto. It is possible for an organization to become more efficient inside its current operating model while missing the possibility that the real shift is happening underneath that model. And if that is true, then some of what currently looks like AI maturity may actually be something more limited: optimization of the surface, while the foundation remains largely unquestioned.

The Familiar First Step

There is a pattern here that feels older than AI. New technology often enters the enterprise through the nearest recognizable use case. The early web was first used to reproduce brochures before it became commerce, platforms, and digital ecosystems. Cloud often began as infrastructure substitution before it forced a deeper reconsideration of architecture and operating models. Perhaps AI is passing through the same stage now. Something that may turn out to be structurally disruptive is first being absorbed as a layer of assistance.

That reaction is understandable. It is easier to approve a pilot that saves hours than to reopen basic questions about enterprise design. It is easier to justify a coding assistant than to ask what becomes strategically important once software itself becomes easier to generate, easier to adapt, and perhaps less scarce than it once was. Yet that second question keeps returning for me, because it begins to touch something more fundamental than productivity alone.

What if AI does not merely change how software is produced? What if it gradually changes the role software plays in the enterprise altogether?

When Software Stops Feeling Like the Center

For a long time, software has occupied the center of enterprise value in a very visible way. It carried workflows, expressed business logic, shaped user journeys, and turned data into action through applications people could see, navigate, and operate. In many organizations, software became the thing around which investment, governance, delivery, and modernization efforts were organized. That centrality has been so stable for so long that it is easy to mistake it for permanence.

But perhaps software was never really the final destination. Perhaps it was always the bridge. It connected human intent to systems, systems to data, and data to outcomes. That bridge remains essential, of course, and nothing about AI makes logic, control, or orchestration suddenly disappear. Yet the position of software may be starting to feel less fixed than it once did. The interface becomes more conversational. The workflow becomes more dynamic. The application boundary becomes less visible. The user expresses intent, and something else begins to mediate the route from request to result.

That is a different thought from the familiar claim that “software is going away.” I do not think that is quite right. Software remains, but perhaps in a different posture. Less like a destination the user consciously enters, and more like an underlying mechanism that quietly coordinates execution. It may not disappear technically. It may simply become less visible experientially. And once that possibility enters the frame, it becomes harder not to wonder what happens to the rest of the enterprise stack when the visible layer stops being the main point of interaction.

The Shift in Scarcity

If software becomes easier to generate and easier to reshape, then some of the scarcity that once made it strategically central may begin to move elsewhere. That thought seems increasingly difficult to ignore. Scarcity may move toward the things that are harder to replicate: trusted data, governed data, proprietary context, reliable identity, controlled permissions, and the ability to know which information can be used, by whom, under which conditions, and in service of which actions.

That is why I find myself thinking that copilots may be the most visible part of the AI story, but not necessarily the part that will decide its long-term winners. The more consequential shift may be happening around the enterprise’s contextual substrate. Not just data in the abstract, but data with lineage, meaning, ownership, and trust wrapped around it. Transaction histories, operational telemetry, engineering knowledge, supplier relationships, process memory, customer context, risk logic, institutional learning — this is the material that gives intelligence real relevance inside the enterprise. Without it, a model may still be impressive, but it remains generic. With it, intelligence begins to matter economically.

And that raises a different class of question. Not only how do we speed up coding or reduce cycle time, but what are these systems actually grounded in? Who owns that grounding? Who may access it? What happens when agents begin to act on top of it rather than merely summarize it? And what happens when low-trust data begins to move faster than careful human judgment used to?

The Fragility Beneath the Intelligence Layer

This may be the part that feels most underappreciated to me. In traditional enterprise systems, bad data is serious, but often still slowed down by friction. Someone notices something. Someone questions an anomaly. A record gets corrected. The process may be clumsy, but the slowness itself acts as a form of containment. In more agentic systems, that brake begins to weaken. The same qualities that make them attractive — speed, autonomy, scale, responsiveness — also make them more sensitive to the quality of the substrate beneath them.

A flawed prompt can mislead an individual. A flawed dataset can mislead a process. A flawed agent, grounded in poor data and given the authority to act, can scale that error across operations with very little hesitation. That possibility changes the meaning of data quality. It stops feeling like a hygiene topic and starts feeling more like an operational control. In some domains, perhaps even a safety condition.

This is why I am not fully convinced by the growing excitement around autonomous workflows when so many organizations still seem to have fragmented truth layers. There is something uneasy about investing heavily in the intelligence layer while the grounding layer remains inconsistent, weakly governed, or poorly understood. It starts to feel like acceleration before coherence. And perhaps that is one of the deeper risks of this moment: that AI maturity can look convincing at the interface level while remaining fragile at the level that actually determines trust.

The Application as Instrument, Not Hero

For years, enterprise architecture has been organized around applications as the primary units of experience. Users entered an ERP system, a CRM platform, a portal, a workflow tool, or a case management environment. The application enforced the flow, and the user worked inside the boundaries it presented. That model has shaped not only architecture, but the way many organizations think about value itself.

But what if that sequence begins to invert? What if the user increasingly interacts with an agent, and the agent becomes the layer that interprets intent, retrieves context, invokes tools, coordinates systems, and assembles the path to action? In that world, the application still matters, but perhaps more as one instrument among several than as the primary experience in its own right.

I think that is part of why the phrase “software becomes invisible” keeps lingering in my mind. Not because the software is gone, and not because the application layer no longer matters, but because the user may stop relating to it as the main thing. The visible center shifts. What begins to matter more is the orchestration of context, policy, identity, and action behind the scenes. The user experiences an outcome, while the software landscape underneath becomes less legible as a set of discrete destinations.

If that sounds subtle, it may still turn out to be profound. Whole architectural assumptions start to wobble once the application is no longer the obvious hero of the story.

The Questions That Follow

Once that possibility is taken seriously, the executive conversation starts to look different. Productivity remains important, of course, but it no longer feels like the whole frame. A more structural set of questions begins to emerge. Who controls the data agents rely on? How is enterprise knowledge protected when intelligence is mediated through platforms that may sit partly outside the enterprise boundary? How is authority defined for machine actors? How is that authority constrained? How do we audit actions and decisions once the user no longer directly traverses the underlying application path?

These questions feel important not because they replace operational concerns, but because they reveal what operational concerns may have been sitting on top of all along. They push the conversation away from AI as a feature and toward AI as a pressure on enterprise architecture itself. And perhaps that is where the real strategic discomfort begins. Because once the visible software layer becomes more fluid, what remains exposed is not just a technology challenge, but a challenge of trust, ownership, control, and design.

The Architecture Beneath the Interface

The more I think about it, the more it seems that the next enterprise architecture will not be defined by models alone, and perhaps not even by agents alone. It may be defined by how intelligence, context, policy, identity, and action are combined under conditions of trust. Models will matter. Orchestration will matter. Interfaces will keep evolving. But the real differentiator may lie in something quieter: the ability to ground intelligence in a controlled internal reality.

That includes usable and governed data platforms, retrieval layers that bring the right context into the right decision, authorization models that can handle not only people but machine actors, policy layers that constrain autonomous behavior, and auditability that can explain not only what happened, but why. It also includes software that recedes from the foreground without losing its importance, becoming less of a destination and more of a structural medium through which intent is translated into action.

This may be why I keep feeling that many enterprises are still treating AI as a better interface to yesterday’s architecture. That may work for a while. But it also risks underestimating the possibility that the interface itself is becoming fluid, and that once it does, the strategic center of gravity shifts elsewhere.

A Thought That Keeps Returning

So perhaps the deeper enterprise question is not simply how AI can improve what we already do. Perhaps it is what becomes valuable when software is no longer the main thing users experience directly. I do not think the answer is that software ceases to matter. It still matters enormously. But its role may become quieter, more infrastructural, more transparent to the user than it used to be.

And if that happens, enterprises may discover that the real asset was not the visible application layer alone, but the quality of the data beneath it, the ownership of the knowledge flowing through it, the integrity of the controls surrounding it, and the trustworthiness of the context informing it. In that sense, the real AI shift may not be from human to machine, or even from manual work to automated work. It may be from software-centered enterprise thinking to something more data-centered, trust-centered, and mediated by intelligence in ways that are still taking shape.

I am not sure that shift will arrive dramatically. It may emerge the way many important changes do: gradually, unevenly, and just ambiguously enough that we continue describing it in older language while it is already changing the structure beneath our feet.

And perhaps that is the thought worth sitting with.

Not that software disappears, but that it may slowly stop being where the enterprise believes most of its value lives.