mashines.dev | MicroVMs for long-running apps, agents & cronjobs, with live migration
Sign in<br>Join waitlist
Live migration is live: uptime survives the move<br>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.
Join the waitlist<br>See how migration works
No cold starts on maintenance · 0ms downtime migration · public IPv6 + SSH · runs forever
host-a · draining
vm_8f3a · agent-worker
uptime 41d 06:12
migrating state
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<br>AI agents & long-running tools<br>Background workers<br>Cronjobs & schedulers<br>Game & realtime servers<br>Self-hosted databases<br>Jupyter / notebooks
Why mashines.dev<br>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<br>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
See who can't do this →
~/agent, terminal
# Launch a persistent machine for a long-running agent<br>$ mashines launch --name agent-worker \<br>--vcpu 2 --memory 4G --volume data:20G \<br>--region waw
✓ vm_8f3a booted in 480ms · region waw · uptime 00:00
# 41 days later, host-a needs maintenance.<br># The platform live-migrates it automatically:<br>→ vm_8f3a migrating waw/host-a → waw/host-b<br>pre-copy 4.0G · dirty-flush 38ms · downtime 0ms<br>✓ vm_8f3a now on host-b · uptime 41d 06:12 (unchanged)
$ mashines exec vm_8f3a -- uptime<br>up 41 days, 6 hours, never restarted
Use cases<br>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<br>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<br>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<br>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<br>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<br>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...