# OpenComputer

> Persistent cloud VMs for AI agents. Beyond sandboxes.

OpenComputer provides long-running cloud infrastructure for AI agents. Every OpenComputer is a real machine with a full filesystem, full OS access, and persistent state. It stays always on, and you can resize memory and CPU at runtime or hibernate and wake it up at any point.

## When to use OpenComputer

Reach for OpenComputer when an agent needs to run unattended, for minutes to days, on a computer of its own:

- Deploy an agent written in TypeScript as a managed service: durable sessions that survive crashes, schedules, webhooks, memory across sessions, and Slack, GitHub and Linear connections. Start with `npx @opencomputer/cli init my-agent`, then `opencomputer deploy` ([quickstart](https://docs.opencomputer.dev/agents/quickstart.md)).
- Run a background coding agent that clones a repository, runs the tests and opens a pull request ([example](https://docs.opencomputer.dev/agents/examples/slack-coder.md)).
- Start agent work from your own application: create a session and send turns over HTTP, then read results from the event log ([Management API](https://docs.opencomputer.dev/agents/api.md), [OpenAPI spec](https://opencomputer.dev/openapi.json)).
- Give each of your users a persistent, isolated Linux VM for untrusted or AI-generated code that keeps its files between sessions, can checkpoint and fork, and resizes CPU and memory while running (`@opencomputer/sdk` or `opencomputer-sdk`).
- Keep model and service credentials out of the agent's runtime: the platform holds them and injects them on outbound requests.

It is not the right tool for a single stateless function call or a short code snippet that finishes in milliseconds, or for a chat UI with no work behind it.

How to call it as an agent: read the docs through the [MCP server](https://docs.opencomputer.dev/mcp) or [docs llms.txt](https://docs.opencomputer.dev/llms.txt), use the CLI to create and deploy agents, and call the Management API with an organization API key in the `x-api-key` header from server code. Never put the key in a browser.

## Developer resources

- [OpenComputer API reference](https://docs.opencomputer.dev/agents/api.md): Management API for sessions, turns, events, projects, webhooks and memory; base URL `https://app.opencomputer.dev/api/managed-agents`
- [OpenComputer OpenAPI spec](https://opencomputer.dev/openapi.json): OpenAPI 3.1 description of the Management API
- [OpenComputer API catalog](https://opencomputer.dev/.well-known/api-catalog): RFC 9727 linkset for API discovery
- [OpenComputer authentication](https://docs.opencomputer.dev/agents/api.md#base-url-and-authentication): API key in the `x-api-key` header
- [OpenComputer webhooks](https://docs.opencomputer.dev/agents/webhooks.md): start agent sessions from external services
- [OpenComputer MCP server](https://docs.opencomputer.dev/mcp): Streamable HTTP MCP server for searching the docs; [server card](https://opencomputer.dev/.well-known/mcp/server-card.json), [server.json](https://opencomputer.dev/server.json)
- [OpenComputer CLI](https://www.npmjs.com/package/@opencomputer/cli): `@opencomputer/cli` on npm
- [OpenComputer TypeScript SDK](https://www.npmjs.com/package/@opencomputer/sdk) and [Python SDK](https://pypi.org/project/opencomputer-sdk/)
- [Developer resources page](https://opencomputer.dev/developers)

Every page on opencomputer.dev is also available as markdown: request it with `Accept: text/markdown`.

## What it is

OpenComputer is purpose-built for B2B agent platforms. If you're building the next Lovable, Devin, or Bolt, your users need a computer that remembers what it installed yesterday, keeps files between sessions, and picks up where it left off.

Ephemeral sandboxes are stateless - every session starts from scratch. OpenComputer VMs are stateful and always on - state survives across sessions without snapshot/restore pipelines. Resize at runtime or hibernate when not needed.

## Features

- Persistent VMs: Always on with elastic resizing. Scale memory and CPU at runtime, or hibernate and wake when needed.
- Checkpoints: Instant snapshots. Fork or restore to any point.
- Preview URLs: Expose ports externally with auth (Clerk) and custom domains.
- Per-tenant package control: Manage and hot-swap software versions inside running VMs.

## Quick start

Install the SDK:

    npm install @opencomputer/sdk
    # or
    pip install opencomputer-sdk

Usage:

    import { Sandbox } from '@opencomputer/sdk';

    const sandbox = await Sandbox.create({ template: 'default' });
    const result = await sandbox.commands.run('node --version');
    console.log(result.stdout);

    await sandbox.files.write('/app/index.js', 'console.log("hello")');
    const output = await sandbox.commands.run('node /app/index.js');
    console.log(output.stdout); // hello

    await sandbox.kill();

## Pricing

- Free: shared upto 2vCPU, shared upto 2GB memory, 3GB disk, 5 concurrency
- Medium ($300/mo): 8 CPU, 16GB memory, 50GB disk (addable), 50 concurrency
- Large ($3,000/mo): 64 CPU, 512GB memory, 3800GB disk, 500 concurrency
- Custom: talk to us

Users can add one or more machines to their pool at any time.

## Guides

Technical guides on sandbox isolation for AI agents: hypervisors, microVMs, kernel-sharing boundaries, and how to choose infrastructure for agent workloads. All available as full-text markdown.

- [CodeSandbox Alternatives for AI Agents (2026)](https://opencomputer.dev/guides/codesandbox-alternatives.md): Utpal Nadiger, 2026-07-20. CodeSandbox CI and Repos shut down in 2026. Seven alternatives for AI-agent workloads, compared on session durability, failure contract, credential architecture, and control plane. (Full-text markdown; HTML at /guides/codesandbox-alternatives)
- [QEMU vs KVM for AI Agent Sandboxes](https://opencomputer.dev/guides/qemu-vs-kvm.md): Utpal Nadiger, 2026-07-20. KVM is a Linux kernel module; QEMU is the userspace VMM that uses it. They are two parts of one stack, not competing options. The real decision is QEMU vs Firecracker vs Cloud Hypervisor, evaluated from a production QEMU-on-KVM fleet. (Full-text markdown; HTML at /guides/qemu-vs-kvm)
- [Firecracker vs Cloud Hypervisor vs Kata Containers](https://opencomputer.dev/guides/firecracker-vs-cloud-hypervisor-vs-kata.md): Utpal Nadiger, 2026-07-20. Firecracker and Cloud Hypervisor are hypervisors; Kata Containers is a container runtime that drives one of them. The actual layers, the kernel-sharing boundary, and the feature differences that decide the pick for AI-agent isolation. (Full-text markdown; HTML at /guides/firecracker-vs-cloud-hypervisor-vs-kata)
- [E2B Alternatives for AI Agent Sandboxes (2026)](https://opencomputer.dev/guides/e2b-alternatives.md): Utpal Nadiger, 2026-07-20. E2B alternatives for AI agent sandboxes compared: Daytona, Modal, Vercel, Morph, Runloop, Cloudflare, and OpenComputer, on live CPU/RAM resize, persistence, isolation, and price. (Full-text markdown; HTML at /guides/e2b-alternatives)
- [GitHub Codespaces vs Gitpod for Autonomous AI Agents](https://opencomputer.dev/guides/codespaces-gitpod-agents.md): Utpal Nadiger, 2026-07-20. Cloud development environments were built for a human who closes the laptop. How Codespaces, Gitpod (now Ona), Coder, and agent VMs handle an unattended agent, on idle behavior, session limits, and live resize. (Full-text markdown; HTML at /guides/codespaces-gitpod-agents)
- [Claude Agent SDK: Where Does the Agent Actually Run?](https://opencomputer.dev/guides/claude-agent-sdk-sandbox.md): Utpal Nadiger, 2026-07-20. The Claude Agent SDK gives you the agent loop and tools, not the computer. Compare local, Docker, VPS, ephemeral sandboxes, and persistent VMs for running it in production. (Full-text markdown; HTML at /guides/claude-agent-sdk-sandbox)
- [Podman vs Docker for Running Untrusted Code](https://opencomputer.dev/guides/podman-vs-docker-untrusted-code.md): Utpal Nadiger, 2026-07-20. Rootless and daemonless both shrink the blast radius, but Podman and Docker share the host kernel. Here is where that stops mattering, walked up the isolation ladder to a VM with its own kernel. (Full-text markdown; HTML at /guides/podman-vs-docker-untrusted-code)
- [Python Sandbox: Every Approach, Honestly Ranked](https://opencomputer.dev/guides/python-sandbox.md): Utpal Nadiger, 2026-07-20. Which Python sandbox actually contains untrusted code? A ranked walkthrough from in-process tricks that fail to microVMs that work, with a working escape you can run. (Full-text markdown; HTML at /guides/python-sandbox)

## Blog

Long-form writing on agent infrastructure, sandbox isolation, and patterns for building on long-lived compute.

- [Build an Ava-Inspired BDR Agent That Runs on Its Own Computer](https://opencomputer.dev/blog/open-ava-bdr-agent.md): Utpal Nadiger, 2026-06-27. A cookbook for building Open Ava: an inspectable BDR agent on a persistent OpenComputer VM. SQLite as the CRM, AgentMail as the inbox, Anthropic for research and drafting, with an approval gate and a checkpoint before any irreversible send. (Full-text markdown; HTML at /blog/open-ava-bdr-agent)
- [Scaling OpenComputer from one VM to a million sandboxes](https://opencomputer.dev/blog/scaling-one-vm-to-million-sandboxes.md): Mohamed Habib, 2026-06-17. From one VM to a million sandboxes: the architecture redesign behind OpenComputer's scaling — cells, edge routing on Cloudflare Workers, and per-second billing from 10-second heartbeats. (Full-text markdown; HTML at /blog/scaling-one-vm-to-million-sandboxes)
- [Build a background coding agent that works while you sleep](https://opencomputer.dev/blog/background-coding-agent.md): Utpal Nadiger, 2026-06-01. A 250-line self-hosted background coding agent. Label a GitHub issue with `agent`, wake up to a draft PR. ~$0.30/task. The snapshot, the agent loop, the webhook server, and the dead ends to skip. (Full-text markdown; HTML at /blog/background-coding-agent)
- [What it takes to run an AI coworker on iMessage](https://opencomputer.dev/blog/what-it-takes-to-run-an-ai-coworker-on-imessage): Mohamed Habib, 2026-05-22. Lessons from shipping Clawputer, a managed openclaw that lives in your iMessage. Patterns for VM lifecycle, versioning, OAuth integrations, and browser offloading when building AI coworkers on long-lived compute.
- [Stop Treating Agent Sandboxes as Cattle](https://opencomputer.dev/blog/stop-treating-sandboxes-as-cattle): Utpal Nadiger, 2026-05-04. A direct response to "The agent harness belongs outside the sandbox." Why credentials, hibernation, elasticity, and checkpoints make a persistent in-sandbox harness the better default.
- [The Race to Build the Next WordPress](https://opencomputer.dev/blog/the-race-to-build-the-next-wordpress): Igor Zalutski, 2026-04-19. Agent harnesses are to this era what WordPress was to the early 2000s internet. The race to build the next one is already on.
- [What "elastic compute" means in 2026](https://opencomputer.dev/blog/what-elastic-compute-means): Igor Zalutski, 2026-04-07. From EC2 to agent sandboxes — how agents broke the compute paradigms we've relied on for 20 years, and what elasticity looks like now.
- [Where Should the Agent(s) Live?](https://opencomputer.dev/blog/where-should-the-agent-live): Utpal Nadiger, Mohamed Habib, Igor Zalutski, 2026-03-20. Isolation models, agent placement tradeoffs, credential design, and sandbox lifecycle patterns for agentic systems.
- [Agent Execution Is the New HTTP Request](https://opencomputer.dev/blog/agent-execution-new-http-request): Igor Zalutski, 2026-03-17. From CGI scripts to serverless, web infrastructure evolved over 30 years. Now agents are taking us full circle — back to files and scripts.
- [I Asked Opus 4.6 to Fingerprint Sandbox Vendors](https://opencomputer.dev/blog/sandbox-fingerprinting): Mohamed Habib, 2026-03-17. Fingerprinted 6 sandbox providers to understand their isolation models — from containers to microVMs to full hypervisors. Here's what we found.
- [The Agentic Workload](https://opencomputer.dev/blog/the-agentic-workload): Igor Zalutski, 2026-03-15. Agent code doesn't fit neatly into existing categories. It's not a traditional app, and it's not a CI job. It's something new.
- [Building an Open Lovable — part 1](https://opencomputer.dev/blog/building-open-lovable-part-1): Mohamed Habib, 2026-03-11. A series to build a Lovable clone to learn how Lovable works under the hood using Claude Agent SDK and OpenComputer.

## Links

- Website: https://opencomputer.dev
- Docs: https://docs.opencomputer.dev
- Dashboard: https://app.opencomputer.dev
- GitHub: https://github.com/diggerhq/opencomputer
- Docs llms.txt: https://docs.opencomputer.dev/llms.txt
- About: https://opencomputer.dev/about
- Contact: https://opencomputer.dev/contact
- Privacy: https://opencomputer.dev/privacy