MicroVMs for long-running apps, AI agents, and cronjobs, with live migration built in. We move your workload between hosts without stopping it: memory, disk, and open connections come along for the ride.
Built for workloads the serverless world keeps cold-starting
Containers share a kernel and get evicted. Functions time out and cold-start. mashines.dev gives every workload a real microVM, and keeps it alive across the entire fleet.
When a host needs maintenance, gets rebalanced, or you resize, we transfer the running VM, full RAM, disk, and TCP connections, to a new host. No restart, no dropped requests, no lost state.
Every workload is a hardware-virtualized microVM (Cloud Hypervisor/KVM), not a namespace on a shared host. Safe enough to run untrusted agent-generated code and multi-tenant workloads side by side.
Attach durable volumes that follow the VM across migrations. Scale to zero when idle without losing your disk, billing s, your data and identity don't.
MicroVMs boot in well under a second from a snapshot, so cron and burst workloads start fast and scale to zero between runs, without paying for idle.
Run for milliseconds or for months. No 15-minute function ceilings, no request deadlines. The right home for servers, workers, and agents that simply need to stay up.
Deploy a machine in any region with one command. Pay per-second for active vCPU and RAM only. Predictive migration spreads load before hosts get hot.
Under the hood, every machine is a microVM running on a hypervisor we instrumented for live state transfer. When the fleet needs to move it, we copy memory pages to the destination while the VM keeps running, for milliseconds to flush the last dirty pages and the device state, then resume on the new host, disk and network identity intact.
$ mashines launch --name agent-worker \
--vcpu 2 --memory 4G --volume data:20G \
--region waw
✓ vm_8f3a booted in 480ms · region waw · uptime 00:00
→ vm_8f3a migrating waw/host-a → waw/host-b
pre-copy 4.0G · dirty-flush 38ms · downtime 0ms
✓ vm_8f3a now on host-b · uptime 41d 06:12 (unchanged)
$ mashines exec vm_8f3a -- uptime
up 41 days, 6 hours, never restarted
If your workload holds state in memory, runs longer than a function allows, or executes untrusted code, it belongs on a machine.
Long-lived agents with persistent memory and their own filesystem, isolated well enough to run model-generated code. They don't time out and they don't cold-start when we move the underlying host, context survives.
WebSocket servers, game servers, realtime collaboration backends, self-hosted Postgres or Redis. Keep connections and in-memory caches warm through maintenance windows.
Sub-second boot from snapshot, run the job, scale to zero. Pay only for the seconds it ran, with a real VM instead of a constrained function sandbox, so heavy or long jobs just work.
Queue consumers and pipelines that churn for hours. Drain-aware migration means a node going down never kills an in-flight job mid-flight.
Bring your own devcontainer.json: each machine runs real Docker (container-os), so the
devcontainer
CLI and nested containers just work. Unlike Codespaces there's no idle timeout or forced rebuild, scale to zero when idle, and live migration keeps your editor session alive through host maintenance. First-class editor integration via DevPod is on the roadmap.Every machine boots container-os, our microVM base image, on Ubuntu 22.04/24.04 or Alpine 3.19–3.22. It ships
mashines enter <machine>
drops you straight into a bash shellssh
/scp
direct on port 22
$ mashines enter agent-worker
root@vm_8f3a:~# docker compose up -d # container-os ships docker + compose
$ ssh root@abcd.mashine.dev # IPv6, port 22
$ scp ./data.tar root@abcd.mashine.dev:/data
$ ssh -p 2201 root@entry160.mashine.dev
A quick look at where mashines.dev stands against the platforms people reach for today.
| Capability | mashines.dev | Fly Machines | E2B / Modal | Fargate / Cloud Run | Railway / Render |
|---|---|---|---|---|---|
| Live migration (state preserved) | Yes | No, stop/start | No | No | No |
| Isolation | microVM | microVM | microVM / sandbox | Container | Container |
| Max runtime | Unlimited | Unlimited | Time-limited | Request timeout | Unlimited |
| Persistent volume follows workload | Yes, across hosts | Pinned to host | Ephemeral | Limited | Pinned |
| Scale-to-zero billing | Yes | Yes | Yes | Partial | No |
curl -fsSL mashines.dev/install | sh
, then mashines login
. Or use the REST API and Terraform provider.
Pick vCPU, memory, region, and an optional persistent volume. Boots from snapshot in under a second.
We keep it alive across the fleet. Scale to zero when idle, scale out when busy, migrate when hosts change, all without restarts.
mashines.dev is a cloud platform that runs long-running stateful apps, AI agents, and cronjobs on hardware-isolated microVMs. Its defining feature is live migration: when the platform needs to move your workload to another host, it transfers the full VM state, memory, disk, and open connections, with zero downtime, so your process keeps running and its uptime counter never resets.
Both run Firecracker-class microVMs with per-second billing. The difference is live migration. On Fly Machines, host maintenance or rebalancing stops and restarts your VM, so in-memory state is lost and the process cold-starts. mashines.dev live-migrates the running VM instead, preserving RAM, disk, and connections with no restart.
Yes. Each agent gets its own hardware-isolated microVM with a persistent volume, so agent memory and working files survive restarts and host moves. Unlike ephemeral sandboxes such as E2B or Modal, agents aren't time-limited and aren't cold-started when infrastructure changes underneath them, ideal for autonomous, always-on agents.
No. Workloads run indefinitely, no request timeouts or maximum durations. That makes mashines.dev suitable for servers, databases, workers, and agents, not just short-lived functions.
No. We pre-copy memory while the VM keeps serving, then for a few milliseconds to flush the last dirty pages and device state before resuming on the destination. Open TCP connections and the network identity are preserved, so clients don't reconnect.
Three ways. mashines enter <machine>
opens a bash shell instantly via the CLI. Every machine also has its own public IPv6, so you can ssh
and scp
straight to it on port 22 (ssh root@abcd.mashine.dev
). If your network is IPv4-only, reach the same machine through a shared entrypoint on a dedicated port (ssh -p 2201 root@entry160.mashine.dev
). The machine's IP is stable across live migrations, so your connection details never change.
Each machine boots container-os, our microVM base image, available on Ubuntu 22.04/24.04 and Alpine 3.19–3.22. It ships Docker, Podman, docker-compose, and OpenSSH preinstalled, and you have full root, so you can run containers, Compose stacks, databases, or any Linux process inside your own VM.
Yes. Because every machine runs a real Docker engine (container-os), you can ssh
in and run the devcontainer CLI against your repo's
devcontainer.json
: nested containers work natively, no docker-in-docker shims. Versus Codespaces, there's no idle timeout or forced rebuild, you scale to zero when idle, and live migration keeps the environment alive through host maintenance. First-class one-click editor integration (via DevPod) is on the roadmap; today it's bring-your-own-devcontainer over SSH.Usage-based, like a utility. You pay per-second for active vCPU and memory and per-GB-month for persistent volumes. Bandwidth is free. Idle machines scale to zero and stop billing compute. Start with a $5 trial credit (verified card required). See pricing.
Spin up a machine in under a second and let it run for as long as you need, through every maintenance window.