AgentVerse OS is a personal cloud operating system for a developer and their AI agents: your own cloud running on a single server, used from any device through the browser. It is built as a cross-platform vibe coding flow: the same desktop, workspaces and agents open on a laptop, a tablet or a phone, the workspace and its agents stay on the server, and the work continues where you left it. One command installs it on a clean Ubuntu; everything after that happens in the browser: a windowed desktop, isolated workspaces with VS Code and agents (Claude Code, Codex, Gemini CLI, pi), a store of 945 self-hosted apps, backups and updates. Nothing is exposed to the internet: access goes through Tailscale with real certificates, no root CAs to install on your devices.

The project is in alpha and lives on a single test box. It works as a personal server for one person; there are no user accounts or permissions yet. See Status for what is done and what is not.

_{Desktop on a computer: the Store catalog, a project card with its workspace and capabilities, widgets. Monolith theme, glass surfaces.}

Light theme: projects and appearance settings. Seven presets, including OLED and high contrast.

Tablet: the same windows and widgets, portrait wallpaper.

_{Phone: a home screen instead of a desktop, full-screen windows, PWA. One Desktop adapts to the device.}

_{The Agents app on a wide screen: Code view with session cards for Claude Code, Codex, Gemini CLI and pi, a permission request waiting for a decision, the inspector. Demo data.}

• Projects and workspaces. Every project gets its own network, its own gate and an isolated Incus container with Docker inside. Inside: VS Code in the browser, a terminal and agents; Claude Code and Codex log in with your subscriptions. Stop/start keeps the instance, resources are changed from the project card.
• Agents. A separate app for working with coding agents from any device: Claude Code, Codex, Gemini CLI and pi run inside the project's workspace, the conversation lives on the server and continues on the phone where the laptop left off. Tool calls and permission prompts, a terminal, the files and git of the workspace, model menus (including the models of the project's LLM gate), routines on a schedule, a ledger of spend, search and export of conversations, MCP servers and skills, diagrams and formulas in replies, and a simple chat straight to a model without a container. Conversations survive a restart of the daemon in the workspace.
• A Store of 945 apps. The Runtipi, Coolify and Umbrel catalogs merged into one, with source badges. Guided install, login credentials right in the card, logs, automatic repair of data-directory permissions, links between apps (e.g. n8n → LiteLLM), per-app snapshots and rollback.
• Capabilities instead of addresses. A project asks for storage.s3, llm or notify; the core connects the project's gate to the provider's network and drops environment variables into the workspace. Swapping Garage for another S3 does not touch the project.
• Browser only. The first-run wizard joins Tailscale via a link or QR code, checks DNS and the certificate, creates the first project. System and app updates come from the Updates window: a package with automatic rollback if the new version does not come up.
• Backups. Scheduled ZFS snapshots and a restic repository taken from a snapshot; roll back a single app in two clicks. Off by default.
• A desktop like a desktop OS. Windows, taskbar, start menu, widgets (monitor, clock, news, weather, projects), Files over app data and workspace homes, Passwords & Access, themes and wallpapers, boot screen, offline overlay, screensaver. The UI speaks English, Russian, Ukrainian and Spanish; the language follows the browser or is set once for all devices.
• Two assistants already in the catalog. Hermes Agent with a web panel, and Pipecat Voice, a voice assistant in the browser with local speech recognition and synthesis. Voice control of the system itself is on the roadmap.

flowchart LR
  subgraph devices["Your devices (tailnet)"]
    B["Browser · Desktop PWA<br/>laptop · tablet · phone"]
  end

  subgraph host["Server · Ubuntu · ZFS"]
    E["edge Caddy<br/>TLS from tailscaled<br/>:443 Desktop · :8444 Coder · :8450+ apps"]
    C["cloudd (Rust)<br/>API · CLI · Desktop embedded<br/>projects · apps · capabilities · backups · updates"]
    A["cloudos-agents (Rust)<br/>Agents app · conversations · routines · ledger"]
    subgraph ws["Project alpha"]
      G["gate-alpha (Caddy)<br/>the only door into the workspace"]
      W["workspace · Incus<br/>Docker inside · VS Code"]
      D["cloudos-agentd<br/>Claude Code · Codex · Gemini CLI · pi"]
    end
    K["Komodo · App Runtime<br/>compose stacks of apps"]
    subgraph apps["Store apps · one network each"]
      S3["Garage · storage.s3"]
      LLM["LLM gateway · llm"]
      N["ntfy · notify"]
      X["Gitea · n8n · Nextcloud …"]
    end
    CO["Coder · workspace control plane"]
  end

  B -- "https · MagicDNS" --> E
  E --> C
  E --> A
  A --> C
  C -- "/v1 sessions" --> D
  E --> CO
  E --> X
  C -- "project.yaml" --> CO
  CO -- "Incus API" --> W
  C -- "grant storage.s3" --> G
  G --> S3
  G --> LLM
  G --> N
  W -- "http://storage.s3.gate" --> G
  C -- "install / upgrade" --> K
  K --> apps

The core is small: seven entities (project, workspace, gate, app, capability, grant, route) and four contracts. Everything else is proven third-party software: Coder runs the workspaces, Incus isolates them, Komodo deploys compose stacks, Caddy holds the entry point, Tailscale provides the network and certificates. The agents are the agents' own CLIs: Claude Code and Codex run headless, Gemini CLI and pi speak the Agent Client Protocol; the daemon in the workspace keeps the journal and relays events to the app.

You need a clean Ubuntu 22.04+ (tested on 26.04), 8 GB of RAM or more, preferably a separate disk for ZFS, and a Tailscale account.

From the release package, nothing to build:

curl -LO https://github.com/agentverse-os/AgentVerse-OS/releases/download/v0.2.0/agentverse-os-0.2.0-x86_64.tar.gz
mkdir agentverse-os && tar xzf agentverse-os-0.2.0-x86_64.tar.gz -C agentverse-os && cd agentverse-os
sudo DISKS="/dev/disk/by-id/<disk for ZFS>" bootstrap/install.sh

Or from source:

git clone https://github.com/<owner>/agentverse-os && cd agentverse-os
cd desktop && npm install && npm run build && cd ..        # Desktop → cloudd/static
cd agentd && cargo build --release && cd ..                # the daemon for workspaces, embedded into the core
cd agents/ui && npm install && npm run build && cd ../..   # the Agents app → agents/ui/dist
cd agents && cargo build --release && cd ..                # the Agents service with the app embedded
cd cloudd && cargo build --release && cd ..                # core with the Desktop, agentd and the service embedded
sudo DISKS="/dev/disk/by-id/<disk for ZFS>" bootstrap/install.sh

The installer goes step by step: host checks → ZFS → Docker and Incus → Tailscale (a link and QR code to authorize the node, waits for your confirmation, checks MagicDNS and HTTPS Certificates) → Coder → Komodo → edge → core → catalog → template → summary with addresses. A checkout can also install from a package instead of a locally built binary: PACKAGE=agentverse-os-<version>-<arch>.tar.gz (a file or an https URL); packages are built by scripts/release.sh.

When it finishes, open https://<node>.<tailnet>.ts.net/ and the first-run wizard completes the setup in the browser. Updates come from the Updates window or sudo agentverse-update; the update channel is the stable.json of the latest release, e.g. https://github.com/agentverse-os/AgentVerse-OS/releases/download/v0.2.0/stable.json.

cd cloudd && cargo test                       # core unit tests: contracts, gate and edge rendering, storage, updates
cd agentd && cargo test                       # daemon unit tests
cd agents/ui && npm run dev                   # the Agents app (Vite)
cd desktop && npm run dev                     # Vite with /api proxied to cloudd (CLOUDD_URL)
cd desktop && npm run check                   # svelte-check, including dictionary keys across the four languages
tests/shell/install_functions_test.sh         # installer functions against a tailscale shim, no sudo needed
sudo tests/e2e-stand.sh                       # on the test box: full scenario against live Incus, Docker, Coder, Komodo

The Desktop is embedded into the core binary with rust-embed: after npm run build, rebuild cloudd. The Agents app is embedded into cloudos-agents the same way, and cloudos-agentd and cloudos-agents are embedded into cloudd, so scripts/release.sh builds them in that order. Desktop e2e tests run on the test box inside a Playwright container; see the headers of the tests in desktop/e2e/.

Apache-2.0. The apps in the Store belong to their authors and ship under their own licenses; this repository only holds manifests and compose files imported from the open Runtipi, Coolify and Umbrel catalogs.