The Rise of AI Operating Systems: How Large Models Are Evolving from Tools to OS

From Analogy to Architecture: The Theoretical Starting Point of AI OS

In 2023, Andrej Karpathy—former Tesla AI Director and founding member of OpenAI—proposed a disruptive analogy: the large model is the CPU, the context window is memory, and AI Agents are processes. This seemingly simple statement reveals a profound trend—AI is evolving from a single application tool into a complete operating system.

This analogy didn't come from nowhere; it's built on deep insights from computer architecture. In the traditional von Neumann architecture, computation is divided into three layers: the processing unit (CPU), the storage unit (memory), and the execution unit (processes). Karpathy precisely mapped this classic architecture to AI systems: the large model serves as a general-purpose computation engine capable of handling any language task, similar to the CPU's universality; the context window serves as working memory, determining how much information an Agent can "see" in a single inference; and Agents serve as processes—specific task instances running on this infrastructure. The profound implication of this analogy is that AI systems, like operating systems, will inevitably need to confront and solve classic computer science problems such as resource contention, task scheduling, and state management.

By 2025, this trend has moved from concept to reality. This article traces the development trajectory of AI OS, its key technical architecture, and the paradigm shifts it may bring.

From Paper to Product: Deconstructing the Core Architecture of AI OS

In March 2024, Rutgers University published the landmark AIOS paper, which for the first time systematically transplanted the concept of an operating system kernel into AI Agent architecture. The paper's core contribution was solving the resource contention problem when multiple Agents run concurrently—prior to this, most Agent frameworks (such as LangChain and AutoGPT) used simple single-threaded, sequential execution models that couldn't efficiently handle multi-task concurrency scenarios. Drawing on classic OS design philosophy, the AIOS paper defined four core modules of an AI operating system:

• Scheduler: Manages queuing and priority for multiple Agents, referencing CPU scheduling algorithms (such as round-robin and priority scheduling)
• Context Manager: Handles "thought switching" for Agents between different tasks, similar to process context switching mechanisms
• Memory Manager: Allocates and manages memory resources for Agents, distinguishing between short-term memory (analogous to RAM) and long-term memory (analogous to disk storage)
• Tool Manager: Interfaces with external APIs and services

This architecture is strikingly similar to traditional operating system design. In a traditional OS, the CPU schedules processes, manages memory, and handles I/O; in an AI OS, the large model schedules Agents, manages context, and connects tools. This isn't merely a conceptual analogy—it's an inevitable engineering convergence. When system complexity reaches a certain threshold, a "kernel" is needed to unify resource management.

Industry Race: Major Players' AI OS Strategies

After the paper's publication, the entire industry rapidly entered a phase of intense competition. From the product layer to the protocol layer, major tech companies are competing to seize the high ground of AI operating systems across all dimensions.

Steve: The World's First AI-Native Operating System

Canadian company Waltern released a product called Steve, dubbed the world's first AI-native operating system. It integrates over 1,000 use cases and more than 5,000 applications, attempting to build a complete AI-centric ecosystem.

MCP and A2A: The Standardization Battle at the Protocol Layer

If the core of an operating system is resource management, then the protocol layer is the foundation of its ecosystem. Since 2024, two key protocols have emerged that are reshaping how AI Agents interconnect and communicate:

Anthropic's MCP (Model Context Protocol) has been vividly described by the industry as "the USB-C of AI." Its design was inspired by the Language Server Protocol (LSP)—the very protocol that enables editors like VS Code to support intelligent code completion for dozens of programming languages through a unified interface. MCP uses JSON-RPC 2.0 as its underlying communication protocol and defines three core primitives: Resources, Tools, and Prompts. It solves the standardization problem of connecting Agents with external tools and data sources: before MCP, every Agent needed custom development to integrate a new tool; with MCP, just as USB-C unified charging ports, Agents can plug-and-play connect to various services. As of 2025, over 1,000 MCP Servers have been contributed by the open-source community, and major vendors including OpenAI and Google have announced support, making it a de facto standard.

Google's A2A (Agent-to-Agent) protocol targets a different critical problem: how Agents communicate and collaborate with each other. Built on HTTP/SSE, A2A introduces the "Agent Card" concept—each Agent publishes a metadata card describing its capabilities, input/output formats, and authentication methods, allowing other Agents to discover suitable collaboration partners through discovery mechanisms without needing to understand each other's internal implementation. This is highly similar to service discovery and API gateway concepts in microservices architecture.

The relationship between these two protocols is complementary rather than competitive: MCP solves the vertical problem of "Agents connecting to tools," while A2A solves the horizontal collaboration problem of "Agents connecting to Agents." Together, they form the complete communication infrastructure of the AI operating system ecosystem.

OpenAI's Aggressive Approach: Directly Taking Over the Desktop

OpenAI has chosen a more direct path—letting Agents directly control users' computer desktops. The Computer Use capability works as a vision-action loop system: AI captures the current screen state through screenshots, uses visual understanding models to parse the position and semantics of UI elements, then generates operation commands such as mouse clicks and keyboard inputs, and takes another screenshot to confirm the result—forming a closed loop of perception-decision-execution. AI is no longer limited to API calls but operates graphical interfaces like a human user—clicking buttons, filling out forms, and switching windows.

While this approach may seem "clumsy" (each operation requires one model inference, resulting in higher latency), its advantage lies in zero integration cost—decades of accumulated legacy software ecosystems can all be operated by Agents without any API modifications. This is essentially using "simulated human operation" to bridge the gap between AI capabilities and existing software infrastructure.