OpenComputer Review: Firebase for Agents

What Is OpenComputer?

OpenComputer is a managed cloud platform from the DiggerHQ team for running AI agents as code. You write an agent as a TypeScript function and deploy it with a single CLI command, and the platform takes care of the compute, the agent loop, sessions, streaming, and versioning. Every session runs on its own hardware-isolated Linux microVM with a real shell, a read-write filesystem, and network access — not a lightweight emulation of one.

The tagline 'Firebase for agents' sums up the position. Just as Firebase stripped away backend plumbing for mobile apps, this platform strips away infrastructure plumbing for agents: define the behavior, deploy, and the runtime provisions a Linux machine, runs the loop, and streams results back. Agents and bare sandboxes share the same compute layer, so you can stay on the managed surface or drop down to raw virtual machines when you want to run your own harness.

How It Works

Deployment follows a short path. Scaffold a project with the CLI, describe the agent as a reactive function — hooks like useInput, useModel, useTool, and useMcpServer attach the pieces it needs — then run the deploy command. The hosted runtime renders that description for each input and drives the loop: calling the model, running tools, and streaming output back. There is no local agent server to babysit; the code executes in the managed cloud.

A project can contain several agents at once. Deployments are immutable, so you promote a version from development to production rather than editing something live, and the CLI streams indexed runtime and egress logs so you can watch agent activity and outbound requests as they happen.

• Reactive TypeScript agents defined with conditional hooks
• Immutable deployments promoted through production aliases
• Indexed runtime and egress logs available from the CLI
• Dashboard and CLI playground sessions for testing

Why AI Agents Need More Than a Short-Lived Sandbox

Many agent platforms treat every run as a disposable task: spin up, execute, tear down, lose the state. That works for single-shot requests, but it falls apart for agents that must keep a conversation going, hold a working directory, install dependencies once, and pick back up after the user walks away. Long-running work — monitoring, data pipelines, an inbox that needs triaging — wants a computer that stays alive between turns.

This platform treats persistence as the point rather than an afterthought. Instead of emulating a session, it gives each agent a real machine that outlives a single call. Files remain on disk, a job can be steered mid-run, and a later trigger resumes the same environment without reconstructing state from scratch.

• State and files persist across agent turns
• Sessions stream live output and can be steered in progress
• Idle sessions hibernate instead of dying

Persistent Machines, Sessions, and Checkpoints

Durable sessions sit at the core of the design. A session runs on its own machine, streams output as it happens, can be steered while in flight, and hibernates when it goes idle. When something wakes it again, it resumes exactly where it stopped.

Bare sandboxes go further with checkpoints and forks. You can snapshot a machine at a known-good state, restore it later, or branch several sessions from the same snapshot. That makes bug reproduction and parallel experiments straightforward: one clean setup, many different runs.

• Sessions hibernate when idle and resume where they stopped
• Sandboxes support checkpoint, fork, and live resize
• Cron schedules wake agents for recurring work

Tools, MCP Servers, Browsers, and Files

Because each session is a whole Linux machine, tools behave the way they do on a developer laptop. Clone a repository, run ffmpeg, drive a headless browser, or install anything you need with apt, npm, or pip. MCP servers run directly on the machine too, so an agent can read feature-flag state, query an issue tracker, or call any capability a server exposes.

Breadth matters more than it sounds. The capability set is not a fixed menu hard-coded by the vendor — it grows with whatever the environment can install and reach, which keeps an agent close to the tools it actually needs.

• git, ffmpeg, headless browsers, and any apt/npm/pip package
• MCP servers run on the same machine as the agent
• Full network egress for outbound API calls

Deploying and Running AI Agents

Shipping a production agent is a single command. Give it a schedule and it runs itself: the platform handles sessions, streaming, MCP connections, and Slack notifications. The docs show schedules defined with a cron expression, such as weekdays at 9am.

Teams that want to own the loop can use the same machines as bare sandboxes through a small API: create a machine, run a command, save a checkpoint. You bring the harness and the rules; the platform meters machine time only.

• One-command deployment with watched development sync
• Cron schedules for recurring background jobs
• Slack integration handled by the platform
• Bare sandbox API for custom agent runtimes

Security and Secrets

The security model focuses on keeping credentials out of agent code. A secret is declared as a connection bound to a specific origin, and the runtime attaches it to outbound traffic only after the request has left the sandbox. In practice, an agent can open a pull request but cannot read the token or forward it anywhere.

Project-level secrets live outside the runtime, with optional per-agent overrides and constrained outbound requests. Model keys follow the same rule — bring your own or use the managed models, and the key stays out of untrusted code. Individual machines are isolated from one another through hardware-level virtualization, which adds another boundary.

• Secrets bound to one origin and injected after requests leave the sandbox
• Project-level secret store with per-agent overrides
• Model keys kept outside the runtime
• Hardware-level isolation between machines

Who Should Use It

The platform suits teams building agents as products or internal automation who would rather not assemble compute, sessions, and secrets themselves. If you are shipping a coding agent, a background monitor, or any workflow that needs a real filesystem and durable state, the managed runtime takes a meaningful chunk of infrastructure off your plate.

It is a weaker fit for one-off LLM calls, which a plain API handles fine, and for teams that want a finished autonomous product instead of writing the loop themselves. A TypeScript shop ready to own agent logic is the sweet spot.

• Product teams shipping long-lived agents
• Developers who need full Linux tools inside agent environments
• Less useful for API-only chat or one-shot automation

Alternatives and Comparisons

Devin is a finished autonomous coding agent — it ships its own browser, terminal, and editor and aims to complete software tasks end to end. This platform is the layer beneath that kind of product: machines and a runtime for building your own agent, whether it writes code, moves data, or drives a browser.

Replit and Cursor sit in a different lane. Replit is a browser-based IDE with AI assistance and one-click deployment; Cursor is an AI-native code editor. Both are developer tools rather than general agent infrastructure. The trade-off here is control: you get raw Linux environments and a managed loop, but you design the agent behavior and tooling yourself.

• Devin — finished autonomous agent; this service is the infrastructure layer for custom agents
• Replit and Cursor — developer IDEs, not general agent hosting
• Best for teams that want to own the agent loop rather than use a prebuilt one

How Pricing Works

Pricing runs on two meters. Model tokens pass through at API rates with no markup; bring your own key or a Codex subscription and that meter reads zero. Machine time is billed per second while a session is live, with scale-to-zero when it goes idle.

Agent sessions default to 2 GB of RAM and 1 vCPU at $0.00315 per minute, and they burst automatically to 4 GB / 2 vCPU or 8 GB / 4 vCPU when the workload demands it. A session that runs ten minutes a day works out to roughly a dollar a month.

• Tokens passed through at API rates with no markup
• Machine time billed to the second with scale-to-zero
• Default agent session 2 GB / 1 vCPU at $0.00315 per minute
• Bursting up to 8 GB / 4 vCPU when the load needs it

OpenComputer Pricing

Free $10 credit to start; Pro $20/mo with 10x credit; Max $200/mo; Enterprise custom

Best For

Recommended use cases and scenarios where OpenComputer shines.

Frequently Asked Questions

Common questions about OpenComputer, answered.