agiresearch/AIOS

AIOS – an AI‑Agent Operating System

What it is

• AIOS is a software stack that treats a large language model (LLM) as a core system service, much like a kernel in a traditional OS. It provides the plumbing that lets developers write, deploy, and run LLM‑powered agents without having to re‑implement low‑level concerns such as scheduling, memory/storage management, tool handling, and inter‑process communication.
• The repository you are looking at contains the AIOS kernel (the “OS” layer). The companion SDK, called Cerebrum, lives in a separate repo and offers the API that agent developers use to talk to the kernel.

Why it matters

• As LLM‑based agents become more capable, the community is hitting the same problems that operating‑system developers solved decades ago: resource isolation, lifecycle management, and safe interaction with external tools. AIOS attempts to solve those problems in a unified, extensible way, making it easier to build robust, reusable agents.
• By exposing a kernel‑style syscall interface, AIOS lets many different agent frameworks (ReAct, Reflexion, AutoGen, Open‑Interpreter, MetaGPT, etc.) run on the same platform, encouraging an “app store” style ecosystem for agents.

Core components

Component	Role
AIOS Kernel (this repo)	Abstracts the host OS, manages LLM instances, memory, storage, tool pools, and a Tool Manager that can launch sandboxed VMs for computer‑use agents.
Cerebrum SDK	Python library that agents import to issue syscalls (e.g., run_tool, read_memory, write_file).
Agent Hub Machine (AHM)	Central server that hosts a marketplace of agents.
Agent UI Machine (AUM)	Device where users interact with agents (Web UI or terminal UI).
Agent Development Machine (ADM)	Where developers write and test agents.
Agent Running Machine (ARM)	The compute node that actually executes the agent code.

Supported deployment modes

1. Local Kernel – kernel and agents run on the same machine (simple start‑up).
2. Remote Kernel – kernel runs on a powerful server while UI/devices connect remotely (good for phones or edge devices).
3. Remote Kernel Dev – developers edit code on a lightweight device but the heavy kernel runs elsewhere.
4. Personal Remote Kernel – each user gets a persistent, cloud‑hosted kernel tied to an account.
5. Personal Remote Virtual Kernel – multiple virtualized kernels coexist on a single physical host (still in development).

How to get started

1. Install – clone the repo, create a Python 3.10/3.11 virtual environment, and install dependencies (GPU‑ or CPU‑specific requirements‑cuda.txt / requirements.txt). The docs recommend the fast installer uv, but pip works as well.
2. Configure – edit aios/config/config.yaml (or use the interactive aios env … commands) to supply API keys for OpenAI, Anthropic, Gemini, Groq, Deepseek, HuggingFace, etc., and to list the LLM back‑ends you want (Ollama, vLLM, HuggingFace, etc.).
3. Launch – run bash runtime/launch_kernel.sh (or start the FastAPI server manually with uvicorn runtime.launch:app). The kernel listens on a configurable host/port.
4. Interact –
   • Web UI – open the provided web interface (URL shown in the logs).
   • Terminal UI – run python scripts/run_terminal.py to talk to the “semantic file system” where you issue natural‑language commands that are translated into file‑system operations.
5. Develop agents – import the Cerebrum SDK in your Python project, call the provided syscalls, and optionally register the agent on the AHM so others can download it.

Ecosystem & integrations

• Agent frameworks – AIOS can host agents written for OpenAGI, AutoGen, Open‑Interpreter, MetaGPT, etc.
• Tool back‑ends – built‑in support for external services (Google Search, WolframAlpha, RapidAPI) and local tools (diffusion models from HuggingFace). The Tool Manager can also spin up a sandboxed VM (MCP Server) for safe computer‑use agents (see the LiteCUA project).
• LLM cores – native function‑calling for open‑source models via HuggingFace, vLLM, Ollama, and Deepseek APIs. The README lists a long‑list of supported model families (e.g., Llama‑3.1, Qwen2.5, Deepseek‑r1 series).

Current maturity

• The project is actively maintained (latest news from July 2025). Recent releases include v0.2.2 with a major refactor, support for many model back‑ends, and a functional terminal UI.
• Several peer‑reviewed papers (AIOS kernel, Cerebrum SDK, LiteCUA, A‑MEM, semantic file system) have been accepted at top conferences (COLM 2025, NAACL 2025, ICLR 2025), indicating a research‑grade foundation.
• Community channels: Discord, Gurubase Q&A, and a public documentation site.

Who should use it

• Researchers building new LLM‑agent algorithms who want a stable runtime instead of rolling their own scheduling and tool‑calling code.
• Product teams looking to ship agent‑powered features (e.g., AI assistants, autonomous bots) with a clear separation between the heavy LLM kernel and lightweight front‑ends.
• Developers who want to experiment with multiple LLM back‑ends and tool integrations without rewriting glue code for each model.

---

Bottom line – AIOS is a genuine, open‑source operating‑system‑style platform for LLM agents. It abstracts away the messy infrastructure work (resource management, tool sandboxing, multi‑machine deployment) so you can focus on the agent logic itself.