The war to own the user
AI interfaces are being fragmented by the defensive business models of big labs and application-layer companies.
Most current discussions about AI focus on the frontier of models, their capabilities, and their costs. But as intelligence becomes more abundant, cheaper, and more similar across providers, the question stops being which model is better and starts becoming how it integrates with real work. The consumption interface, although less discussed, is becoming increasingly decisive for the user.
The frontier still matters for difficult and long-horizon tasks, but it is starting to matter less across a growing share of common use cases. Open-source models are getting closer to the frontier and can offer comparable results at a fraction of the cost. Smaller models are becoming more capable. Hardware keeps improving and raises the ceiling for local inference. The result is that a larger share of everyday tasks can be solved without much technical complexity. AI is on a path toward becoming a general-purpose capability, but today that capability reaches the user through fragmented forms of interaction.
Chat is the most recognizable form because it looks like an explicit conversation where the user iterates toward a result. There are also in-context interfaces, where AI appears inside an app and uses that app's context. Others are more inline, closer to utilities, and generate or transform inputs directly where they belong, such as dictation or correction apps. There are also background processes, suited to more autonomous agents that run long tasks without interrupting the user until they need input, permissions, or are ready to present results. More recently, agents have started appearing inside channels such as messaging apps or shared workspaces, where they are invoked as if they were a person.
This diversity is not a design mistake. As apps have different shapes, each one integrates AI in the way that best fits its flows. Embedded interfaces are useful because they live where the work happens, but the problem is that each one comes packaged as its own surface. The user needs a horizontal layer that adapts to the way they work, but instead ends up adapting to rigid bundles designed by each individual company. Under the current offering, the user loses three times.
1. First, in experience: preferences do not travel, context stays fragmented, shortcuts compete, and usage patterns are not uniform.
2. Second, in cost: the user pays multiple times for similar capabilities embedded across different surfaces.
3. Third, in privacy: by its nature, AI does not receive only the result of work, but also the process through which the work is produced and the context required to produce it. The user ends up forced to trust a surface area that grows with every new provider.
It makes sense for AI to become a horizontal layer and move closer to the OS. A useful AI layer needs to understand enough about what the user is doing to intervene without forcing them to reconstruct context all the time. That proximity would make it possible to see full workflows, simplify the experience, and reduce costs. But the closer AI lives to the OS, the stronger the trust contract has to be. If a tool can see more, the user needs more control. Nobody would let an external agent watch everything they do without strong guarantees. This directly conflicts with the incentives of current providers, because an OS-adjacent layer controlled by the user makes their products less defensible. Applications have context and want to sell intelligence. Adding AI lets them defend distribution and capture more value. Big labs, threatened by open source and the progressive commoditization of their services, are moving into the context layer to get closer to the user relationship, building apps, coding agents, work agents, and integrations.
The solution is not to create a universal wrapper, but to build a transparent system that provides the modules to create and modify your own wrappers. That product needs several orthogonal axes.
1. Invocation: how you call AI, ideally from where you already are, through keyboard shortcuts, voice, the cursor, or an app.
2. Context: what information you share with it, including written instructions, voice, selection, screen, current app, files, clipboard, persistent memory, preferences, or system audio.
3. Provider: who runs which models and where, including local open-source models, BYOK cloud, and managed cloud when needed. Local-first is the right direction, but cloud is still necessary for frontier models or limited hardware.
4. Process: what kind of work it executes, from an instant transformation to an iterative conversation, a supervised task, an autonomous agent, or a long flow that uses several tools.
5. Surface: where the result ends up, whether it is inserted inline, appears as editable content, lives in a chat, becomes a file, triggers an action, or remains as a persistent report.
This level of complexity does not come without tension from a design perspective. When everything is configurable, the product becomes too complex and developer-oriented. But if it is not configurable enough, it becomes another app that fragments the general experience. The answer is to offer preconfigured modes as good defaults that work from the start, without closing off the ability to modify each of the elements that make them up. Personalization should exist without being an initial requirement.
The goal of 0switch is to integrate AI into human work without forcing anyone to adapt to proprietary, fragmented, and opaque surfaces designed to capture context and charge for packaged intelligence. AI is becoming a general-purpose tool, and its interface should operate close to the user. That is where control is being contested, and giving it up is a mistake. I am building an alternative to keep that control on the user's side.