The Submergence of AI

New technologies are often most visible before they become ordinary. Their terminology appears in product names, interfaces, investor language, job titles, architecture diagrams, and everyday conversation because the mechanism itself is still novel. Once the capability matures, however, the vocabulary of implementation tends to retreat beneath the surface.

Most users of modern software do not think about TCP when sending a message, SQL when viewing an account balance, the DOM when using a web application, serialization when synchronising data, RPC when invoking a remote capability, or container orchestration when using a cloud service. These technologies remain fundamental. Some are more important than ever. But their importance no longer requires them to occupy the conceptual surface of the product. Unless a person’s work directly concerns the infrastructure, the infrastructure disappears beneath the activity it enables.

AI is currently in the opposite condition. Its implementation vocabulary is unusually exposed. Products advertise that they are powered by AI, GPT, agents, copilots, models, or retrieval-augmented generation. Interfaces invite users to “ask AI.” Product documentation explains prompts, model selection, agentic workflows, and context windows. Builders routinely organise systems around concepts such as embeddings, tool calls, routing graphs, model endpoints, and retrieval pipelines.

This visibility is understandable. Cognitive capability is still new enough that the mechanism itself carries meaning. Calling something an AI assistant communicates an expectation that would otherwise be difficult to express.

Describing a system as agentic signals that it can perform multi-step work with some autonomy. Terms such as RAG distinguish emerging implementation approaches that teams are still learning to design and operate.

But this vocabulary should not be mistaken for the permanent language of cognitive software.

This paper proposes the Submergence Principle:

As a technological capability becomes ordinary infrastructure, its implementation vocabulary retreats from the domain surface.

The domain surface is where people encounter software in the language of the work they are trying to accomplish. As cognitive capability matures, users should increasingly be able to remain there. A traveller wants to plan my trip. A finance team wants to resolve this exception. A policyholder wants to prepare my claim.

An operator wants to manage my inventory. None of these intentions naturally require the user to think about whether an agent, model, retrieval system, or particular prompting technique sits underneath the interaction.

This produces a process of re-naturalisation. Software initially exposes the vocabulary of a new technical capability because users and builders have not yet developed abstractions around it. As the capability becomes dependable and embedded, interaction returns to the natural language of the domain. The user stops operating the AI and starts operating through the software again.

This does not imply that conversational interfaces will disappear. Conversation may remain one useful interaction form among many. What should disappear is the requirement that the user conceptualise the product in terms of its AI machinery. A future travel system may use several models, specialised cognitive capabilities, planning Agents, retrieval, vision, and continuous evaluation while presenting none of those concepts to the traveller. What matters at the domain surface is whether the trip is planned well.

The more consequential form of submergence, however, may occur on the builder side.

Today, building cognitive software often requires explicit manipulation of prompts, embeddings, context assembly, model calls, tool schemas, routing logic, and orchestration graphs. These are currently necessary engineering concerns because the infrastructure remains immature and relatively manual. But if implementation systems become increasingly capable of generating and optimising these mechanisms, the human programming surface can move upward.

Builders may spend less time specifying which prompt should contain which sentence and more time defining which judgment the system owns. They may spend less time drawing tool-routing graphs and more time expressing authority and escalation. Rather than manually deciding how every piece of context reaches every model invocation, they may define what information a cognitive responsibility is permitted or required to know. Rather than optimising model calls directly, they may define evaluation criteria against which generated implementations can be compared. Increasingly, they may work in terms of named judgments, Skills, goals and authority rather than prompts, routing graphs and individual model calls.

The concepts that rise to the surface are therefore not primarily technical mechanisms. They are judgment, responsibility, behaviour, authority, context, evaluation, and outcome. These are closer to the enduring architecture of the system because they describe what the software is responsible for rather than how a particular generation of technology happens to implement it.

This shift is already implicit in the Instruction Surface described in the previous section. If cognitive intent can be compiled into prompts, retrieval, orchestration, tools, and evaluation infrastructure, then those implementation mechanisms can remain accessible when necessary without remaining the primary language of construction. Just as modern developers can work at high levels of abstraction without forgetting that networks, memory, processors, and databases exist, Thoughtware builders can increasingly work in terms of cognitive architecture without denying the mechanisms beneath it.

Submergence should therefore be understood as a sign of technological maturity, not disappearance. The technologies themselves may become more pervasive precisely as their names become less visible. AI can move from being a feature attached to software to becoming part of the substrate from which software is constructed.

The central proposition is therefore paradoxical only at first: AI disappears not because it becomes less important, but because it becomes foundational. When that happens, users return to the language of their work, builders move toward the language of judgment, and the architecture of cognition remains after the vocabulary of its implementation has receded beneath the surface.