# agentOS

> An open-source virtual operating system for AI agents that runs as a library inside your existing backend, powered by WebAssembly and V8 isolates.

agentOS is an open-source virtual operating system for AI agents, built by Rivet Gaming, Inc. and released under the Apache 2.0 license. It installs as an npm package and runs inside your existing backend process — no microVMs, no containers, no separate SaaS infrastructure required. The project is currently in preview, with the API subject to change, and has accumulated over 4,200 GitHub stars as of mid-2026.

## What It Is

agentOS gives each AI agent a lightweight, isolated virtual machine with its own execution environment, persistent POSIX filesystem, and orchestration primitives. Rather than spinning up a full Linux sandbox for every agent, it uses V8 isolates for JavaScript execution and WebAssembly for compiled tools, sharing a single compact runtime across many concurrent agent VMs. The result is a dramatically smaller resource footprint compared to traditional sandbox providers. Agents can run Bash, Node.js, and Python inside the VM, mount external storage (S3, Google Drive, host directories) as normal filesystem paths, and call typed host functions via bindings — without ever receiving raw credentials.

## Architecture: In-Process VM, Not a MicroVM

The core design choice that separates agentOS from sandbox-based approaches is that every VM runs inside the host process rather than as a separate OS-level environment. A trusted sidecar process owns each VM's kernel — virtual filesystem, process table, pipes, PTYs, and a virtual network stack — and brokers every guest syscall. Nothing the guest does touches the host directly. Key architectural properties include:

- Guest JavaScript runs on native V8 with its full JIT, not JavaScript compiled to WASM
- Compiled tools run as WebAssembly inside the same compact runtime
- Many VMs share one sidecar process; each additional VM costs a V8 isolate plus kernel state, not a full OS process
- Linux-compatible with POSIX files, processes, and networking
- Granular permissions gate filesystem, network, process, and environment access, with outbound network egress denied by default

The homepage benchmarks (methodology published at the docs site) compare agentOS against E2B (cold starts) and Daytona (memory and cost) as of March 30, 2026, showing p50 cold starts of 4.8 ms versus 440 ms for E2B, and approximately 22 MB memory per simple shell instance versus a 1,024 MB minimum for Daytona.

## Deployment Model: Library, Cloud, or Self-Host

agentOS ships three deployment paths:

- **Library**: `npm install @rivet-dev/agentos` and run it inside the backend process you already operate. No additional servers.
- **Rivet Cloud**: Managed agentOS on Rivet's edge network with bring-your-own-cloud (BYOC) support, described by the project as scaling to millions of agents.
- **Self-Host**: Run the open-source platform on Kubernetes, VMs, or bare metal. Supported targets include Vercel, Railway, AWS ECS, Google Cloud Run, Hetzner, and custom platforms.

Each VM runs as a Rivet Actor with durable state, sleep/wake behavior, multiplayer, preview URLs, and orchestration built in. For direct in-process VM control without the actor runtime, the `@rivet-dev/agentos-core` package is available separately.

## Agent and Framework Support

agentOS ships with built-in support for Pi, Claude Code (beta), Codex (beta), and OpenCode via a unified API, all installable from npm. Agents communicate over the Agent Client Protocol (ACP). The registry extends the runtime with additional software packages — git, ripgrep, jq, sqlite3, DuckDB, vim, curl, and more — as well as browser integrations via Browserbase and sandbox mounting for workloads that need full Linux environments (E2B, Daytona). Framework integrations exist for Vercel Eve (beta) and Flue (beta), with native Rivet orchestration.

## Update: v0.2.15

The latest release is v0.2.15, published on July 28, 2026. The repository was last pushed on July 30, 2026, indicating active development. The project notes that it is in preview and the API is subject to change. The GitHub repository (rivet-dev/agentos) is primarily written in Rust and has 209 forks and 92 open issues as of late July 2026.

## Features
- In-process VM execution with V8 isolates and WebAssembly
- Persistent POSIX filesystem with S3, Google Drive, and host directory mounts
- Built-in agents: Pi, Claude Code, Codex, OpenCode
- Durable agent sessions via Agent Client Protocol (ACP)
- Bindings: expose typed host functions as CLI tools inside the VM
- Granular permissions for filesystem, network, process, and environment access
- Multiplayer: multiple clients observe and collaborate with the same agent
- Agent-to-agent delegation via host-defined bindings
- Durable workflows with retries, branching, and resumable execution
- Cron jobs and webhook triggers
- Sandbox mounting for heavy workloads (E2B, Daytona)
- Browser support via Browserbase (beta)
- Resource limits per VM (CPU, memory, processes, sockets)
- Preview URLs for services running inside a VM
- Human-in-the-loop approval flow
- Automatic persistence and session replay
- React SDK and typed client for frontend integration
- Self-host on Kubernetes, VMs, or bare metal
- Rivet Cloud managed deployment option
- Apache 2.0 open-source license

## Integrations
Pi, Claude Code, Codex, OpenCode, Amazon S3, Google Drive, SQLite, DuckDB, Browserbase, git, ripgrep, jq, vim, curl, Vercel Eve, Flue, Rivet, E2B, Daytona, Vercel, Railway, Kubernetes, AWS ECS, Google Cloud Run, Hetzner

## Platforms
WINDOWS, LINUX, WEB, API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Version
v0.2.15

## Links
- Website: https://agentos-sdk.dev
- Documentation: https://agentos-sdk.dev/docs
- Repository: https://github.com/rivet-dev/agentos
- EveryDev.ai: https://www.everydev.ai/tools/agentos