Live migration is live: uptime survives the move
Machines that never sleep.
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.
No cold starts on maintenance · 0ms downtime migration · public IPv6 + SSH · runs forever
host-a · draining
vm_8f3a · agent-worker
uptime 41d 06:12
host-b · receiving
vm_8f3a · agent-worker
uptime 41d 06:12
Same VM. Same PID. Same uptime. Zero restarts. The process never knew it moved.
Built for workloads the serverless world keeps cold-starting
Stateful APIs AI agents & long-running tools Background workers Cronjobs & schedulers Game & realtime servers Self-hosted databases Jupyter / notebooks
Why mashines.dev
The only platform that moves your workload without stopping it
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.
Live migration
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.
True VM isolation
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.
Persistent by default
Attach durable volumes that follow the VM across migrations. Scale to zero when idle without losing your disk, billing pauses, your data and identity don't.
Sub-second boot
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.
No timeouts, ever
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.
Global, by the second
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.
How it works
Your process doesn't restart. It relocates.
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, pause for milliseconds to flush the last dirty pages and the device state, then resume on the new host, disk and network identity intact.
- Pre-copy RAM while the VM keeps serving traffic
- Persistent volume re-attached on the destination host
- Network identity and open TCP connections preserved
- Final stop-and-copy measured in milliseconds, not seconds
- Automatic on host drain & rebalance, or trigger it yourself
~/agent, terminal
# Launch a persistent machine for a long-running agent $ mashines launch --name agent-worker \ --vcpu 2 --memory 4G --volume data:20G \ --region waw ✓ vm_8f3a booted in 480ms · region waw · uptime 00:00 # 41 days later, host-a needs maintenance. # The platform live-migrates it automatically: → 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
Use cases
Made for things that have to stay running
If your workload holds state in memory, runs longer than a function allows, or executes untrusted code, it belongs on a machine.
agents
AI agents & autonomous tools
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.
stateful
Stateful apps & servers
WebSocket servers, game servers, realtime collaboration backends, self-hosted Postgres or Redis. Keep connections and in-memory caches warm through maintenance windows.
cron
Cronjobs & schedulers
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.
workers
Background & batch workers
Queue consumers and pipelines that churn for hours. Drain-aware migration means a node going down never kills an in-flight job mid-flight.
devcontainers
Cloud dev environments that never reset
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.
Connect & run anything
One command to a shell. A real OS underneath.
Every machine boots container-os, our microVM base image, on Ubuntu 22.04/24.04 or Alpine 3.19–3.22. It ships Docker, Podman, docker-compose, and OpenSSH out of the box, so you get a real VM with full root, not a locked-down sandbox.
mashines enter <machine>drops you straight into a bash shell- IPv6-first: every machine gets its own public IPv6,
ssh/scpdirect on port 22 - IPv4 too: reach any machine through a shared entrypoint on its own port
- Run containers and Compose stacks inside your machine, it's a full Docker host
- Networking is free: no charge for the IPv6, ingress, or egress
~, terminal
# Drop into a shell on your machine $ mashines enter agent-worker root@vm_8f3a:~# docker compose up -d # container-os ships docker + compose # Or ssh/scp directly, every machine has a public IPv6 $ ssh root@abcd.mashine.dev # IPv6, port 22 $ scp ./data.tar root@abcd.mashine.dev:/data # No IPv6 on your network? Use the shared IPv4 entrypoint + port $ ssh -p 2201 root@entry160.mashine.dev
Compare
Everyone else restarts. We relocate.
A quick look at where mashines.dev stands against the platforms people reach for today.
Get started
From zero to a running machine in three commands
Install the CLI
curl -fsSL mashines.dev/install | sh, then mashines login. Or use the REST API and Terraform provider.
Launch a machine
Pick vCPU, memory, region, and an optional persistent volume. Boots from snapshot in under a second.
Let it run
We keep it alive across the fleet. Scale to zero when idle, scale out when busy, migrate when hosts change, all without restarts.
What is mashines.dev?
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.
How is this different from Fly.io Machines?
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.
Is it a good fit for AI agents?
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.
Is there an execution time limit?
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.
What happens during a migration, do I lose requests?
No. We pre-copy memory while the VM keeps serving, then pause 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.
How do I connect to a machine?
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.
What runs inside a machine?
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.
Can I use it for dev environments / devcontainers?
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.
How does pricing work?
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.
Stop cold-starting. Start migrating.
Spin up a machine in under a second and let it run for as long as you need, through every maintenance window.