Pattern
Sleep at the end of a turn
Agent loops map cleanly onto the lifecycle: resume at the start of a turn, work, sleep when the turn ends. The machine is only metered while the agent is actually thinking with it.
MANSSINO / Platform
Behaves like hardware. Starts like a function.
A MANSSINO machine is a virtual machine with its own kernel, its own disk, and its own memory image. We did not make it start quickly by weakening the boundary. We made it start quickly by never shutting it down in the first place, then restoring the snapshot when you ask for it back.
Machine at a glance
Isolation
Hardware virtualisation, one kernel per machine
Resume
Under 250ms, measured at 0.24s to an interactive shell
Storage
Block device attached to the instance, encrypted at rest
Privileges
Root, with device access, kernel modules, and Docker
Interfaces
CLI, HTTP API, and SSH against the same fleet
01 Architecture
Everything above the hypervisor is yours.
Each machine runs on a thin virtual device model on top of hardware virtualisation, with a kernel that belongs to that machine alone. Above the kernel sits an ordinary Linux userland, which is why ordinary Linux assumptions hold: you can mount filesystems, load modules, bind low ports, run an init system, and watch dmesg tell you the truth.
The control plane never enters the guest. It allocates capacity, attaches storage, triggers snapshots, and reports state. What happens inside the walls is between you and your machine.
- Minimal device surface. A small, audited set of virtual devices rather than a general purpose emulator, which keeps the attack surface and the restore path both small.
- Snapshot as a first-class state. Memory pages and disk are captured together, so a resume is a restore, not a boot.
- No shared runtime. Nothing of ours runs inside your userland, so there is no agent to upgrade and nothing to conflict with your packages.
Layers, top to bottom
per machineLayer 06
Your processes. Agents, servers, builds, training jobs, all running as root if you want.
Layer 05
Linux userland. A standard distribution with the package managers already present.
Layer 04
Dedicated kernel. Booted for this machine, never shared with another tenant.
Layer 03
Virtual devices. Block, network, and console, kept deliberately narrow.
Layer 02
Hardware virtualisation. The boundary the processor enforces for us.
Layer 01
MANSSINO host fleet. Capacity, scheduling, snapshots, and storage.
02 Lifecycle
Five states, and only one of them bills.
A machine moves between states on your command, through the CLI or the API. Nothing expires on its own, nothing is garbage collected behind your back, and a sleeping machine keeps its disk until you delete it.
| State | What it means | Time to running | Billed |
|---|---|---|---|
creating |
Capacity allocated, disk attached, kernel starting for the first time. | Under 250ms | From the first running second |
running |
Fully live. Accepts commands over the API, the CLI, and SSH. | Now | Active compute |
sleeping |
Memory and disk snapshotted. Processes frozen in place, state intact. | Under 250ms | Nothing |
resuming |
Snapshot being restored. A transitional state you rarely see. | Milliseconds | Nothing |
deleted |
Machine, disk, and snapshots destroyed. Not recoverable. | Not applicable | Nothing |
Pattern
Keep a warm pool
Pre-create machines in the shape you need and leave them asleep. A pool of sleeping machines costs nothing and turns a provision into a resume.
Pattern
One machine per branch
Long-lived work benefits from a long-lived box. Pin a machine to a branch, a customer, or a dataset, and the environment stops being something you rebuild.
03 Persistence
What comes back, and what you should still handle yourself.
Persistence is only useful if the rules are explicit. These are ours.
Restored on resume
Comes back exactly as it was
- The whole filesystem, including
/home,/etc, and anything you compiled - Installed packages across every package manager you used
- Environment variables, shell history, and dotfiles
- Running processes and daemons, restored from the memory image
- Open files and in-memory caches held by those processes
- Docker images, volumes, and containers that were running
Not restored
Worth designing around
- Open network connections, which end at the moment of sleep
- Anything that assumes monotonic wall-clock time across the gap
- Leases, tokens, and sessions that expired while the machine slept
- External state your machine does not own, such as a remote queue position
In practice
Long-running jobs should checkpoint to disk as they already do, and network clients should reconnect on wake. Both are ordinary habits for software that runs on real machines.
Sleep is a snapshot, not a shutdown
Sleeping writes the memory image and seals the disk. Nothing in the guest is asked to cooperate, so a stuck process cannot block it and a half-finished install is captured mid-flight and continues on resume.
manssino exec m-7f3a "pgrep -f trainer"
4821
manssino sleep m-7f3a
memory snapshot written · meter stopped
manssino resume m-7f3a
running in 0.23s
manssino exec m-7f3a "pgrep -f trainer"
4821
04 Shapes
Pick the machine, not a plan.
A shape is three numbers and an optional accelerator, chosen per machine at creation time. There are no tiers, no bundled quotas, and no features held back for a larger contract.
| Dimension | Flag | Range | Notes |
|---|---|---|---|
| Virtual CPUs | --vcpu |
1 to 16 | Dedicated cores on the host, not a burst credit scheme. |
| Memory | --memory |
1 to 64 GB | Sized in gigabytes. The snapshot grows with the memory in use, not with the ceiling. |
| Disk | --disk |
10 GB to 1 TB | Persistent block storage, encrypted at rest, expandable after creation. |
| Accelerator | --gpu |
Optional | GPU-backed shape with drivers and the CUDA toolchain present on first boot. |
| Region | --region |
us-west-1 | Additional regions are provisioned for teams that need them. |
Typical agent box
--vcpu 2 --memory 4 --disk 20
Enough for a coding agent that installs a dependency tree, runs a test suite, and keeps a language server warm between turns.
Build and crawl box
--vcpu 4 --memory 8 --disk 50
Headroom for parallel builds, headless browsers, and caches that are worth keeping between runs.
Training box
--vcpu 8 --memory 32 --disk 500 --gpu
Room for a dataset on local disk, a CUDA environment, and checkpoints that survive a sleep between sessions.
05 The resume path
Fast because it skips the slow parts.
Every other sandbox pays the same bill on every call: fetch an image, start a runtime, replay an install step, then finally run your command. A resume does none of that. The machine already exists, its disk is already built, and its memory is already laid out.
The path does
Place the machine on a host, reattach its disk, map the saved memory pages, and let the kernel continue from the instruction it was on.
The path skips
Image pulls, layer extraction, runtime initialisation, dependency installs, and any first-request warm-up inside your own code.
Measured
0.24 seconds from a sleeping snapshot to an interactive root shell on a four core machine.
Steady under load
Resume cost is tied to the machine, not to the fleet, so the hundredth concurrent wake behaves like the first.
0.24s
Snapshot to shell
0installs
Repeated per resume
06 Accelerators and heavy work
The jobs a thin sandbox refuses.
Root plus a real kernel plus persistent disk is what makes the hard workloads possible. Everything here works because the machine is a machine.
GPU
Accelerated shapes
Request a GPU at creation and the drivers are loaded before your first command. The device stays attached for the life of the machine.
CUDA
Toolchain present
A CUDA toolchain ships on accelerated shapes, so frameworks compile and link against it without a staging step of your own.
Docker
Containers inside
Run the daemon in your own VM. Images and volumes live on the persistent disk, so a rebuild is not the price of every run.
Disk
Datasets stay put
Large allocations keep a corpus, a model, or a build cache on local storage rather than pulling it across the network each time.
Nothing is emulated away
Kernel modules load. systemd runs. Low ports bind. Loop devices mount. Nested virtualisation works. This is the difference between a machine and a managed runtime that happens to execute your code.
nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
NVIDIA GPU, 24576 MiB
docker run --rm --gpus all nvidia/cuda nvidia-smi -L
GPU 0 visible inside the container
python -c "import torch; print(torch.cuda.is_available())"
True
07 Fleet operations
A hundred machines should stay legible.
Machines are addressable objects, not anonymous workers. Each one carries a stable id, a shape, a region, a state, and whatever labels you attach, so listing a fleet tells you something useful instead of printing a wall of hashes.
- Stable identifiers. A machine id survives sleep, resume, and restart, which makes it safe to store next to the agent session that owns it.
- Labels you choose. Tag by project, customer, branch, or run, then filter on those labels from the CLI and the API.
- Programmatic lifecycle. Create, sleep, resume, and delete are all single calls, so fleet policy lives in your code rather than in a dashboard.
- Visible cost. Active seconds are reported per machine, so the expensive agent in a fleet is easy to find.
08 Network and regions
A real network stack, with the controls you expect.
Outbound
Normal egress
Machines reach the internet the way a server does, which is what makes real browsers, package installs, and API calls behave normally. Egress rules can be narrowed per fleet for teams running untrusted code.
Inbound
Through SSH, by default
Reach services on a machine by forwarding a port over SSH, which keeps nothing exposed by accident. Teams that need published endpoints can have them provisioned explicitly.
Placement
us-west-1 today
The first region is live and additional regions are provisioned for teams with latency or residency requirements. Machines are pinned to the region they were created in.
Waitlist open
See it resume for yourself.
Tell us the shape you need and the workload you are running. We will get you a machine and a key, and you can time the resume on your own stopwatch.
- Shapes from one core up to a GPU box with a terabyte of disk.
- Snapshot and restore instead of image pulls and warm-up.
- Root inside a boundary the processor enforces.
- Billed for the seconds a machine is actually awake.