Computers for Agents

Persistent NixOS (and Ubuntu) VMs that agents can build, manage and snapshot via CLI or MCP. Designed for always-on agents like OpenClaw, remote development machines or anything else that requires reliable hosting or compute.

$ npm install -g @machine0/cli
$ machine0 new my-vm
✓ starting (nixos-24.05, large, eu)
✓ url is `https://my-vm.mac0.io`
$ machine0 ssh my-vm
[ nixos@my-vm ] ~ #
get started nowread the docsRun OpenClaw on machine0 →

Agents need Computers, not Sandboxes

Give your agent a "batteries included" Linux VM it can control over CLI or MCP. With dedicated CPU and RAM, a static IP, an HTTPS endpoint, and a GPU if it wants one. Small VMs boot instantly. Starting at $9/month, billed by the minute.

Declarative & Reproducible
First-class NixOS support. Ubuntu too.

We offer real NixOS VMs. Flakes give you declarative, reproducible builds you can verify. We also provide Ubuntu images that you can provision with Ansible.

Agents First
Local CLI and remote MCP server.

Traditional clouds give you dashboards and config wizards. Agents can't click buttons. machine0 exposes every operation as a CLI command and an MCP tool — the two interfaces agents already speak. No SDKs, no API wrappers, no screen-scraping.

Batteries Included
Dev toolchain and coding agents pre-installed.

Docker, Node, Bun, Python, Go, Rust, Claude Code, Codex and OpenCode pre-installed. Ansible playbooks for provisioning. sync push / sync pull --watch for continuous file sync. Zero setup time.

Dedicated Resources
CPU, RAM and a GPU if you need one.

Not shared, not fractional — dedicated CPU, RAM and disk on every VM. H100, H200, MI300X, L40S GPUs in the same fleet from $1.57/hr. Same CLI, same images, same regions. No second provider needed.

Real Networking
Static IP and HTTPS on every VM.

Every VM gets a dedicated public IP and an authenticated HTTPS proxy at <vm>.mac0.io. Your agent builds something, it has an address. Persistent, not garbage-collected at the end of a run.

Multi-Region
Multi-region with 99.99% CPU Uptime.

New York, London, Amsterdam, Singapore. Same pricing everywhere. --region us, --region asia. Pick where latency matters, not where the bill is cheapest.

Images & Snapshots

We provide the following system images to every account. These images are provisioned using our Ansible Playbook.

NameDescription
nixos-24-11NixOS 24.11.
ubuntu-24-04-loadedIncludes the latest versions of Docker, node, python, go and rust. As well as coding agents such as Claude Code, Codex and OpenCode.
ubuntu-24-04-openclawubuntu-24-04 with OpenClaw pre-installed. Requires a large instance or larger.
ubuntu-24-04Fresh Ubuntu 24.04 LTS. Used to provision the base image.

You can also create your own images (for example to clone your environment easily):

# Create a fresh VM we'll use as a template.
machine0 new my-vm
 
# Update the VM using `machine0 ssh` or `machine0 provision`, then image it.
machine0 images save my-vm my-base-image
 
# Create as many VMs from the image as you'd like.
machine0 new my-clone --image my-base-image

Ansible Provisioning

machine0 has first-class support for provisioning VMs with Ansible. Use coding agents to author playbooks and disposable VMs to test them.

machine0 provision my-vm playbook.yml

We use this functionality to create the base-24-04 image using a fresh Ubuntu. If you'd like to learn more, you can check out our Ansible Playbook.

Sizes & Regions

We provide the following machine sizes. The price is the same regardless of where you spin up: us (New York), uk (London), eu (Amsterdam) & asia (Singapore).

SizeCPURAMDisk$/hour~$/month
small1 vCPU1 GB25 GB$0.013$9
medium2 vCPU2 GB60 GB$0.026$19
large2 vCPU4 GB80 GB$0.052$38
xl4 vCPU8 GB160 GB$0.104$76
xxl8 vCPU16 GB320 GB$0.208$152
xxxl16 vCPU32 GB640 GB$0.416$304

You can use CLI options to specify the size and region of a machine. The default size is small (instant boot) and the default region is eu. You can change them using the config command.

$ machine0 new my-vm --size large --region us

SSH Keys

By default, machine0 uses your local public key (~/.ssh/id_rsa.pub). Your private key never leaves your machine. You can also create managed keypairs that are stored on the server — useful for teams or ephemeral setups.

$ machine0 keys ls
┌────────────────────────────────────────────────────────┐
│ Name                                Type       Default │
│ [email protected]    PUBLIC     *       │
└────────────────────────────────────────────────────────┘
 
# Create a managed private / public keypair
$ machine0 keys create my-managed-key --type managed --default

Billing

machine0 is pay-as-you-go. Resources are billed per minute.

  • Machines are billed while they exist, including when stopped, since they still reserve cloud resources.
  • Images are billed based on disk size at $0.078/GB/month, with a $0.01 minimum per image.
  • Creating a resource requires enough balance for at least 10 hours of usage.
  • If your balance drops below 1 hour of runway, running machines are snapshotted and destroyed. The snapshots are retained so you can recover by topping up.
  • Auto-topup can be enabled to prevent accidental teardowns.
  • Minimum top-up is $5 USD.
  • Unused credits are refundable.

Check your balance:

$ machine0 whoami
┌──────────────────────────────────────┐
│ Email             [email protected]    │
│ Wallet Balance    $9.02              │
└──────────────────────────────────────┘

CLI Reference

$ machine0
 
USAGE
  machine0 <command> [flags]
 
COMMANDS
   ls                                            List VMs
   get <vm>                                      Show VM details
   new <vm> [flags]                              Create a VM
   update <vm> [flags]                           Update a VM
   start <vm>                                    Start a VM
   stop <vm>                                     Stop a VM
   reboot <vm>                                   Reboot a VM
   rm [vm] [flags]                               Remove a VM (--all for all)
   ssh <vm> [command] [flags]                    SSH into a VM or run a command
   provision <vm> <source> [flags]               Provision a VM (NixOS flake directory or Ansible playbook .yml)
   sizes [flags]                                 Show available VM sizes and pricing
 
ACCOUNT
   whoami                                        Show account details
   login                                         Log in
   logout                                        Log out
   billing [month]                               Show usage breakdown for a month (default: current month)
   topup [flags]                                 Top up your wallet balance
 
IMAGES
   images ls                                     List images
   images get <image> [flags]                    Show image details and versions
   images save <vm> <image> [flags]              Snapshot a VM into an image
   images publish <image>                        Publish the draft version to active
   images update <image> [flags]                 Update image settings
   images rm [image] [flags]                     Remove an image or a draft image version
   images upload <url> [flags]                   Upload a custom image from a URL
 
SSH KEYS
   keys ls                                       List keys
   keys get <key> [flags]                        Show key details
   keys new <key> [flags]                        Add a key (managed or public)
   keys update <key> [flags]                     Update key settings
   keys rm <key> [flags]                         Remove a key
 
   managed = keypair stored on server, local = register your own public key
 
CONFIG
   config get                                    Show current configuration
   config set <assignments>                      Set configuration variables (e.g. config set KEY=VALUE)
 
FILE SYNC
   sync push <local> <remote> [flags]            Push local files to a VM (e.g., sync push ./src myvm:~/app)
   sync pull <remote> <local> [flags]            Pull files from a VM to local (e.g., sync pull myvm:~/app ./src)
 
USE CASES
   use openclaw                                  Create an OpenClaw VM (large, 2 vCPU / 4 GB) and SSH into it
   use webserver                                 Create a Webserver VM (small, 1 vCPU / 1 GB) and SSH into it
 
FLAGS
   -h, --help                                    Show help
   -V, --version                                 Show version

Why machine0?

VPS platforms are designed for humans clicking through web UIs. AWS, DigitalOcean, Linode — they all expose dashboards, config screens, security groups, and networking wizards. Getting a single VM ready to use takes dozens of decisions. For coding agents, this is wasted context.

AI sandbox products swing too far the other way. E2B, Modal, and similar tools optimize for ephemeral, short-lived compute behind SDKs. No persistent VMs, no static IPs, no OS you can SSH into and treat like a real server. When an agent needs to install packages, run background services, or host something — sandboxes fall short.

machine0 is neither. Real VMs with dedicated resources and static IPs, accessible through a CLI that agents can operate without additional tooling. Every command does one thing. Humans can pick it up without a manual. Agents can use it without help.

The CLI is workflow-based. machine0 use openclaw doesn't just create a VM - it selects the right image, boots the instance, waits for SSH, and drops you in. This is far more context-efficient for LLMs than composing multiple API calls across different services.

We're the only VM provider with native NixOS support. NixOS defines machine configurations as pure functions - fully reproducible builds with compile-time correctness guarantees. Agents can author Nix flakes with strong confidence that the build will match the specification exactly. No drift, no "works on my machine."

Enterprise-grade availability (99.99% instance-level uptime SLA) at prosumer prices.

Running OpenClaw?

One command. Creates a VM with OpenClaw pre-installed, SSHs you in.

machine0 use openclaw

Uses a large VM (2 vCPU, 4 GB RAM) at ~$38/mo. See Hosting OpenClaw for details.

FAQ

Quick Start

npm install -g @machine0/cli    # Install the CLI
machine0 login                  # Authenticate via browser
machine0 new my-vm              # Create a VM
machine0 ssh my-vm              # SSH in