What Is an AI Operating System? Definitions and Examples
November 16, 2026

An AI operating system is a system where a language model, not you, coordinates the apps, files and tools needed to finish a task. You say "book a ride to the airport" or "pull the numbers from last week's emails into a sheet", and the model decides which programs to open, what data to read and which actions to take. Today the term covers three different things: a mental model (Andrej Karpathy's "LLM OS"), research software that manages AI agents the way a kernel manages processes (AIOS), and agent features that Apple, Microsoft and Google are building into the systems you already run. None of the mainstream versions replaces the kernel underneath. They add a model layer on top of it.
Here's the short version:
- LLM OS is an analogy. The model plays the CPU, the context window plays RAM, and tools play the devices.
- AIOS is an open research project that schedules agents and manages their memory, storage, tools and access control.
- Apple Intelligence, Windows agent workspace and Gemini on Android are the consumer versions. Each one lets a model act across apps, with limits.
- MCP is the closest thing the field has to a shared "system call" layer for tools.
- The hard part isn't intelligence. It's permissions. An agent that can act across apps can also be tricked into acting across apps.
The rest of this guide takes each definition in turn, then the jobs any AI OS has to handle, then the risks.
Three Things People Mean by "AI Operating System"
| Meaning | Best-known example | What plays the "OS" role | Can you use it today? |
|---|---|---|---|
| A mental model | Karpathy's LLM OS | The model coordinates memory, tools and I/O | It's a way of thinking, not a product |
| An agent runtime | AIOS | A kernel layer that schedules agents and shares resources | Yes, as open-source research code |
| AI added to a consumer OS | Apple Intelligence, Windows agent workspace, Gemini on Android | System-level agents with their own permissions | Partly. Rollouts are device by device |
The LLM OS: Karpathy's analogy
In November 2023, Karpathy posted "LLM OS. Bear with me I'm still cooking." with a mock spec sheet. The "processor" was GPT-4 Turbo. The "RAM" was a 128K-token context window. The "filesystem" was Ada-002 embeddings.
He expanded the idea in his Intro to Large Language Models talk, which has a chapter called "LLM OS" and, in his own description, compares LLMs to present-day operating systems.
The point of the analogy is that the model sits where a kernel would. It decides what goes into working memory, when to call a browser or a code interpreter, and how to route the result back. You don't have to accept the metaphor in full to see why it stuck. It explains why context windows, retrieval and tool calling became the core engineering problems of the last three years.
The same talk ends with a section on security: jailbreaks, prompt injection and data poisoning. That part has aged even better than the analogy.
AIOS: an agent operating system from Rutgers
AIOS takes the metaphor literally. It's a research project from Rutgers University researchers, described in the paper AIOS: LLM Agent Operating System, which was accepted at COLM 2025.
The design splits into two parts:
- The AIOS kernel sits as an abstraction layer over your normal OS kernel. The paper lists its services as scheduling, context management, memory management, storage management and access control for running agents.
- The AIOS SDK (the Cerebrum repository) is what developers use to build agents that call the kernel.
The paper reports up to 2.1x faster execution when serving agents built with various frameworks through AIOS. The repo also describes a computer-use variant whose tool manager adds a virtual machine controller and an MCP server, so agents act inside a sandbox.
Notice what AIOS is not. It doesn't boot your laptop. It runs on Linux, macOS or Windows like any other program and manages agents the way an OS manages processes.
AI agents added to the systems you already run
This is where most people meet the term, and it's the version with real users.
Apple. Apple Intelligence now includes Siri AI, which Apple says can take actions in apps like Messages, Music and Reminders based on what you're doing. Apple's pitch leans on privacy: on-device processing, plus Private Cloud Compute for larger server-based models.
Microsoft. Windows has two layers. Copilot+ PCs carry an NPU rated at over 40 TOPS for on-device AI features. Separately, Windows has an agent workspace: a contained space where each agent runs under its own account, distinct from yours. The setting is experimental, off by default, and only an administrator can turn it on.
Google. In May 2026, Google introduced Gemini Intelligence and described Android as transitioning "from an operating system into an intelligence system". The flagship feature is multi-step tasks: Gemini runs the app you need in a secure virtual window on the phone and works through the steps in the background. Our guide to AI agents for Android covers what that does and doesn't do today.
All three keep the same kernel they had before. What changed is that a model now sits between you and your apps, with a permission system built for it.
What Any AI Operating System Has to Handle
Strip away the branding and every serious design has to solve the same five jobs. They map neatly onto what a classic OS already does.
| Classic OS job | The AI version | Real example |
|---|---|---|
| Process scheduling | Deciding which agent or model call runs next | AIOS kernel scheduler |
| Memory management | Choosing what goes in the context window and what goes to long-term storage | AIOS context and memory managers |
| Drivers and system calls | A standard way for the model to discover and call tools | MCP, Android AppFunctions, the Windows agent registry |
| Users and permissions | Separate identities and scoped access for agents | Windows agent accounts, Gemini's virtual window |
| Running programs | Finishing one task across several apps | Gemini multi-step tasks, Siri AI app actions |
Memory: the context window is the new RAM
Karpathy's spec sheet put this best: context is working memory, and it's small and expensive. An AI OS has to page information in and out of it. That's why every design has some form of retrieval, summarization or long-term memory store. If an agent forgets what you told it ten minutes ago, the memory layer is what failed, not the model.
Tool access: MCP as the system-call layer
An OS gives programs a standard way to ask for files, network and devices. AI systems needed the same thing for tools, and the Model Context Protocol is the strongest candidate. Its docs call MCP an open-source standard for connecting AI applications to external systems, and compare it to a USB-C port for AI applications.
MCP servers expose three primitives: tools (functions the model can call), resources (data it can read) and prompts (reusable templates). That's close to what a system-call table does for a program.
The OS vendors are adopting it directly:
- Windows has an on-device agent registry that lets agents discover MCP servers from local apps and remote servers, and ships a File Explorer connector.
- Android has AppFunctions, which Google describes as the mobile equivalent of MCP tools. Apps expose functions that authorized callers like Gemini can discover and run. It needs Android 16 or later and is still an experimental preview.
If you want the protocol itself explained, start with our guide to MCP.
Multi-app tasks: APIs first, screens as a fallback
There are two ways for an agent to get work done in an app. The clean way is a declared function, like an MCP tool or an AppFunction. The messy way is to look at the screen and tap, which is how a computer-using agent works.
Google is doing both. Its developer post on the intelligent OS pairs AppFunctions with a UI automation framework for apps that have no integration yet. Expect every platform to follow that pattern: structured calls where developers opt in, screen automation everywhere else.
The Risks: Permissions and Prompt Injection
An assistant that only answers questions can give you a wrong answer. An agent with system access can take a wrong action. That changes the risk profile completely.
Prompt injection is the big one. OWASP's LLM01 entry describes indirect prompt injection: an LLM accepts input from external sources like websites or files, and instructions hidden in that content change its behavior. For a chatbot, that means a strange reply. For an agent that can read your email and open your banking app, it means a stranger's webpage can try to issue commands.
Permissions are the defense, and they're still young. Here's how the big three handle it today:
| Platform | How agent access is limited |
|---|---|
| Windows agent workspace | Agents get their own accounts. Access to the six known folders can be set per agent to Allow always, Ask every time or Never allow |
| Windows MCP registry | MCP servers run in a separate environment by default and can only reach approved resources |
| Gemini on Android | Tasks run in a virtual window that only reaches limited apps. You can watch, stop and, on newer devices, take over |
| Android AppFunctions | Callers need a specific permission to discover and run app functions |
Google's own help page is blunt about the limits. It says Gemini can make mistakes, and that you shouldn't use screen automation for emergencies or tasks involving sensitive information.
A few rules hold no matter which system you try:
- Grant the narrowest access that gets the job done. "Ask every time" beats "Allow always" until you trust an agent.
- Keep the final step. Confirm payments, sends and deletes yourself.
- Never type credentials into the chat. Enter them in the app directly.
- Be wary of agents that read untrusted content and act on it in the same run. That's the exact shape of an injection attack.
Is There a Real AI Operating System Yet?
It depends on how strict you are.
If you mean a new system where the model is the core and apps are optional, no mainstream product does that yet. The closest things are research projects and open-source experiments.
If you mean a familiar OS where an agent can act across apps with system-level permissions, yes, and it's arriving right now on select hardware. Gemini's multi-step tasks, Windows agent workspace and Siri AI's app actions are all real, all limited to certain devices or builds, and all early.
The useful question for most people isn't which label is correct. It's which tasks you can actually hand off this month. For phones, the answer is narrower than the demos suggest. For a longer argument about why AI keeps hitting the app boundary, read this essay on AI and the app boundary.
Where Taku Fits
Most people searching for an AI operating system don't want to replace their kernel. They want AI that finishes real work without a weekend of setup, and the systems above are still rolling out one device and one app category at a time. Taku doesn't replace Apple Intelligence, Copilot or Gemini. If what you want today is a finished AI app you can open on your Mac, that's where Taku comes in.
Taku Apps and Sites, built by the best AI minds. Find one, run it, and keep it in your Mac Dock. Taku is in Beta, and the Mac app is available now.
Key Points
- An AI operating system is one where a model coordinates apps, data and tools to finish a task.
- The term means three things: Karpathy's LLM OS analogy, agent runtimes like AIOS, and agent features in Apple, Microsoft and Google platforms.
- Every design has to solve memory, tool access, permissions and multi-app tasks.
- MCP, and Android's MCP-style AppFunctions, are becoming the standard tool layer.
- Prompt injection and over-broad permissions are the main risks. Keep the final confirmation yourself.
FAQ
What is an AI operating system in simple terms?
It's a computer or phone where you describe a goal and an AI model works out which apps and tools to use to reach it. Today that usually means an agent layered on top of a normal OS, not a brand-new OS.
What is Karpathy's LLM OS?
It's an analogy Andrej Karpathy shared in November 2023. The language model acts like the processor, the context window acts like RAM, embeddings act like a filesystem, and tools like a browser or code interpreter act like devices. It's a design lens, not a product.
Is Apple Intelligence an AI operating system?
Not in the strict sense. It's a set of AI features across Apple's existing systems. Siri AI can take actions in apps like Messages, Music and Reminders, which is the agent part, but iOS and macOS still run the show underneath.
Is there an open-source AI operating system?
AIOS is the best-known research example. Its kernel and SDK are on GitHub, and it runs as a layer on top of your existing OS. For phones, open-source agent frameworks control Android through accessibility services or adb.
What does MCP have to do with AI operating systems?
MCP gives AI apps a standard way to discover and call tools, read data and use prompt templates. That's the role system calls and drivers play in a classic OS. Windows uses it for its agent registry, and Android's AppFunctions follows the same idea on the device.
Are AI operating systems safe to use?
They're as safe as their permissions. The main risk is prompt injection, where instructions hidden in a webpage or file hijack the agent. Use per-agent permissions where they exist, confirm purchases and messages yourself, and avoid giving an agent sensitive tasks while these features are this new.