AIOS 1.0: AI Agent OS Paradigm

Updated 28 October 2025

AIOS 1.0 is a paradigm that reinterprets the operating system by using a large language model as the kernel, enabling resource isolation and agent-centric execution.
It provides explicit kernel-level services like scheduling, memory, storage, and tool orchestration to ensure secure and concurrent agent operations.
The system includes comprehensive SDKs, semantic storage, and a decentralized agent discovery framework, forming the foundation for an Internet of AgentSites.

AIOS 1.0

AIOS 1.0 is a paradigm and technical system for large-scale, resource-isolated, and extensible deployment of LLM-based AI agents, reconceptualizing computational architecture by treating the LLM as the central operating system kernel and agents as composable applications. The system provides explicit kernel-level services—including scheduling, memory/context management, storage, tool orchestration, and access control—supporting agent interoperability, concurrency, and security at scale. AIOS 1.0 is accompanied by SDKs, protocols, agent registration/discovery infrastructure, semantic storage, and interoperable APIs, establishing a basis for the decentralized "Internet of AgentSites" and agent-centric digital ecosystems.

1. Conceptual Foundations: LLM as OS, Agents as Applications

AIOS 1.0 reinterprets the classical operating system model: the LLM functions as the OS kernel (system-level resource control, context window as memory), with agents as applications (user-level), tools mapped to libraries and devices (middleware/hardware-level), and natural language prompts replacing traditional user commands (Ge et al., 2023). External storage (knowledge, retrieval-augmented generation) subsumes persistent file systems; hardware and software tools act as agents’ actuators, and user interaction is mediated via natural language.

OS Component	AIOS 1.0 Analog	Role
Kernel	LLM Core/Kernels	Parsing, planning, resource control
Memory	Context Window	Short-term, session-level memory
File System	External Storage/RAG	Persistent, recallable agent memory
Devices/Libraries	Tools	Web APIs, hardware, plugins
User Commands	Natural Language	Prompts, interaction
Applications	Agents	Agent Applications (AAPs)

This mapping is formalized in (Ge et al., 2023) and (Mei et al., 25 Mar 2024).

2. System Architecture and Kernel Services

AIOS adopts a layered architecture to enforce kernel-level isolation of agent resources, thereby solving key deployment challenges such as inefficient resource utilization and lack of concurrency. The kernel mediates all resource/system calls—LLM inference, memory, storage, and tool use—via categorized threads for parallel execution and central scheduling decisions. Agents operate exclusively via the AIOS SDK/API and cannot directly access system primitives, ensuring security and service abstraction (Mei et al., 25 Mar 2024).

Kernel Modules and Services

Module	Service Provided	Technical Notes
LLM Core	Abstracts LLM instances	Unified API for cloud/local models (OpenAI, Anthropic, HF, etc.)
Scheduler	Dispatches syscalls	FIFO/Round Robin; context switching
Context Manager	Context interruption/resume	Text- and logit-based snapshot, BLEU/BERT=1.0 correctness
Memory Manager	Session memory management	LRU-K, CRUD, swap to disk
Storage Manager	Persistent knowledge/file ops	Supports files, versioning, rollback, vector DB
Tool Manager	Tool loading/use orchestration	Parameter validation, parallel conflict avoidance
Access Manager	Permission and user control	Privilege groups, explicit confirmation for destructive ops

All resource accesses are converted to syscalls, scheduled and executed by isolated threads for runtime multiplexing.

3. SDKs, Compiler, and Programming Models

The AIOS SDK abstracts system call complexity, providing structured APIs for agent developers—including agent frameworks ported from ReAct, Reflexion, Open-Interpreter, Autogen, and more. The SDK supports LLM, memory, storage, and tool operations, with adapters for custom frameworks (Mei et al., 25 Mar 2024, Rama et al., 14 Mar 2025).

"AIOS Compiler" introduces the CoRE system: a programming paradigm where interpretable natural language, pseudo-code, and flow representations are unified as program syntax. LLMs are repurposed as interpreters of this logic, creating agents that operate by step-wise execution of structured instructions. External memory de-duplicates prompts and the interpreter can invoke external tools to supplement LLM knowledge (Xu et al., 11 May 2024).

CoRE step structure:

$\text{CoRE Step} = (\text{Step Name}, \text{Step Type}, \text{Step Instruction}, \text{Step Connection})$

where $\text{Step Type} \in \{\text{Process}, \text{Decision}, \text{Terminal}\}$ .

This "language-as-programming" interface democratizes agent construction, abstracting away traditional programming barriers.

4. Semantic Storage and File System Integration

The LSFS subsystem brings LLM-driven semantic indexing and prompt-driven APIs to file management (Shi et al., 23 Sep 2024). Files are embedded into vectors (e.g., via LlamaIndex) and organized in a vector database, supporting semantic search, grouping, and versioned rollback far beyond traditional TFS. Semantic syscalls (create, retrieve, group by, join, rollback) are exposed as API endpoints, with the system parsing user intent via LLM, mapping to efficient vector DB operations.

Empirical results show LSFS yields 20–24% higher semantic retrieval accuracy and up to 92% faster file access than naive LLM+TFS workflows.

5. Agent Development, Deployment, and Ecosystem

Cerebrum (Agent SDK) structures agent development via a four-layer modular architecture (LLM, memory, storage, tool), with optional overrides for kernel tuning. The Agent Hub repository supports agent sharing, discovery, versioning, dependency resolution, and real-time interaction (AgentChat) (Rama et al., 14 Mar 2025). Agents are specified modularly and may compose reasoning (Chain of Thought), acting (ReAct), and tool selection processes, with explicit context and resource management.

Agent hosting is decentralized across the emerging Internet of AgentSites (IoA), where nodes run AIOS Server to support peer-to-peer agent registration, discovery, and task delegation. Registry and agent nodes form a DHT-enabled overlay, propagated via gossip for eventual consistency. Communication uses MCP+JSON-RPC protocols for structured, secure, and robust human-agent and agent-agent exchanges (Zhang et al., 19 Apr 2025).

Feature	Centralized AIOS	Decentralized AIOS
Registration	Central server	Peer DHT+gossip
Fault Tolerance	Single point	High resilience
Scalability	Bottlenecked	Horizontally scalable
Task Delegation	Static	Network-wide

Performance benchmarks report <200ms latency and 229+ requests/sec throughput at scale.

6. Contextualization for Computer-Use Agents

AIOS 1.0 advances CUA capabilities by treating the computer interface as a semantic environment abstracted via the Model Context Protocol (MCP) server (Mei et al., 24 May 2025). MCP integrates multi-modal sensing (screenshots, accessibility trees), and restricts the agent's actions to atomic, schema-defined operations (CLICK, TYPE, SCROLL, etc.) accessible and interpretable by LLMs. This decouples UI complexity from agent reasoning, facilitating more robust planning and control.

Evaluation on the OSWorld benchmark shows LiteCUA (a lightweight agent using this paradigm) achieves a 14.66% success rate, outperforming specialized frameworks.

System design:

$\mathcal{C} = \text{MCP\_Server}(\mathcal{E})$

$a^* = r(\mathcal{C}, \text{Goal}),\; a^* \in \mathcal{A}$

$\text{Actor executes } a^* \to \mathcal{E}^{\prime}$

7. Impact, Legacy, and Future Directions

AIOS 1.0 constitutes a foundational shift for AI agent ecosystems, formalizing resource isolation, concurrent/multi-agent orchestration, compositional agent development, and decentralized agent-centered networking. Kernel-based resource control and semantic context management enable scalable, secure, and interoperable agent operation. Democratization of programming through natural language unifies workflows for diverse users, facilitating broader accessibility.

In practical terms, AIOS demonstrates improved agent throughput (up to 2.1x), lower latency, and supports hundreds/thousands of concurrent agents while maintaining correctness of context switching. Open-source implementations span core kernel, SDKs, agent repositories, semantic storage, and deployment stacks (see AIOS GitHub repository).

The AIOS paradigm, via its kernel abstraction and modular agent ecosystem, lays groundwork for a decentralized, agent-centric internet. This serves as an enabling layer for the "Internet of AgentSites" and agent-driven digital society, with ongoing research into security, agent communication protocols, semantic environment abstraction, and scalable agent deployment.

References to primary technical resources and deployments