Backed by a leading startup accelerator · Waitlist open
MANSSINO hands every agent its own persistent virtual machine: a dedicated kernel, a real filesystem, and root in its pocket. It wakes in under 250 milliseconds and remembers everything between sessions. No image to pull, no runtime to warm up, no dependencies to reinstall, and no bill while it sleeps.
01 The cold start tax
The ephemeral sandbox was designed for short, stateless web requests. Agents are neither. They install things, they write files, they leave processes running, and they come back minutes or hours later expecting to find their work. Every time the sandbox throws that away, you pay for the rebuild in latency, in tokens spent re-explaining context, and in compute you never used.
| Behaviour | Ephemeral sandbox | MANSSINO machine |
|---|---|---|
| Time to first command | Seconds, spent pulling an image and starting a runtime | Under 250ms from a snapshot |
| Filesystem | Wiped between invocations | Persistent disk, yours until you delete it |
| Installed packages | Reinstalled on every run, or baked into a new image | Installed once, still there on resume |
| Background processes | Killed when the function returns | Restored with the memory snapshot |
| Isolation boundary | Shared kernel, container or language isolate | Hardware and kernel, one per machine |
| Privileges | Restricted user, no device access | Full root, GPU and Docker included |
| Cost while idle | Metered as long as the instance is held open | Nothing, the meter stops on sleep |
02 Capabilities
Everything below ships on every instance. There is no premium tier that unlocks root, no add-on that makes the disk persistent, and no quota that quietly kills a long run.
Boot · 0.24s
Machines resume from a memory and disk snapshot rather than booting from scratch, so the gap between asking for compute and holding it effectively disappears.
State · persistent
The full filesystem and memory image are preserved across sessions. Home directory, packages, environment variables, and long-running processes come back exactly as they were.
Isolation · vm
Each machine gets its own kernel, memory, and filesystem, enforced in hardware instead of leaning on a shared host. That is a far harder boundary than a container or a language isolate.
Access · root
You get genuine root on every instance and the package managers you already trust. Bring the stack you have instead of rewriting it for a sandbox runtime.
Compute · gpu
Heavy work is first class. Drive accelerated workloads, run containers inside your own machine, and request the disk a real dataset needs.
Billing · active only
You are billed for active compute time. The moment a machine sleeps the meter stops, which is the opposite of how container services treat an idle instance.
0.24s
Measured resume
From sleeping snapshot to an interactive root shell.
100%
Root on every machine
No restricted shell, no blocked syscalls, no exceptions.
1kernel
Per machine, never shared
Isolation enforced below the operating system.
$0idle
While asleep
State is kept, the meter is not running.
03 Anatomy of a machine
Not a function that vanishes the moment it returns, and not a container sharing a kernel with strangers. A persistent virtual machine, isolated and recoverable, that behaves exactly like the Linux box on your desk and wakes faster than you can switch windows.
Survives sleep
Filesystem, installed packages, environment, open file handles, and the process table.
Restored on resume
Memory image and running daemons, in the same order they were left.
Billed
Active compute seconds only. Sleeping machines cost nothing.
04 From zero to running
Install the CLI, drop in a key, and ask for the shape you want. Seconds later you are running commands or holding an SSH session on a box that is entirely yours. Wire the same calls into your agent loop when you are ready.
One global install, one key paste. The CLI stores credentials per profile, so a laptop and a CI runner can hold different keys without stepping on each other.
npm install -g manssino
manssino auth login
Choose virtual CPUs, memory, and disk at creation time. The machine is allocated, the disk is attached, and the kernel is live before the request finishes.
manssino create
--vcpu 4 --memory 8 --disk 50
Run one-off commands, stream output into your agent loop, or open SSH and treat it like any other Linux host. Same machine, three doors.
manssino exec m-7f3a "uname -a"
manssino ssh m-7f3a
Sleep stops the meter and keeps the state. The next resume lands in under a quarter second with every package, file, and process where your agent left it.
manssino sleep m-7f3a
manssino resume m-7f3a
05 Ecosystem
Nothing here is a shim. These are the real toolchains, installed with the real package managers, on a real distribution.
Python
runtime
Node.js
runtime
Rust
runtime
Go
runtime
Java
runtime
Ruby
runtime
apt
packages
pip
packages
npm
packages
cargo
packages
brew
packages
Docker
containers
CUDA
accelerator
GPU
accelerator
SSH
access
Install once
A heavy dependency tree is a one-time cost on MANSSINO. Install it, sleep the machine, and the next resume starts with everything compiled and in place.
No vendored runtime
There is no proprietary runtime wrapping your process. If a binary runs on Linux, it runs here, including the ones that expect devices, kernel modules, or a real init system.
06 Workloads
Fast, persistent, securely isolated compute is the substrate automated workloads have been missing. These are the four places it earns its keep first.
Code generation
It installs dependencies, runs the test suite, executes what it wrote, and keeps the workspace warm between turns. Because the machine persists, the next turn builds on the last one instead of starting cold.
ML training
Request a GPU shape with a large disk, start the run, and let it ride. Checkpoints, datasets, and the environment stay on the machine through a sleep rather than rebuilding from scratch.
Browser automation
Real browsers on a real network stack, with cookies, sessions, and profiles that carry across runs. Pause a crawl mid-flight and pick it back up without paying a warm-up tax per batch.
Pipelines
Every pipeline gets an isolated machine with root to install whatever toolchain it needs. Sub-250ms starts keep the queue short, and idle runners between commits cost nothing.
07 The isolation model
A model will eventually write something you would never run on your laptop. The honest answer is not a longer list of forbidden syscalls, it is a boundary that does not depend on the code behaving well.
Boundary map
Layer 01
Hardware virtualisation, enforced by the host, not by policy.
Layer 02
A dedicated kernel for every machine, never shared between tenants.
Layer 03
Private memory and filesystem, snapshotted and restored as one unit.
Inside
Full root for you and your agents, with the walls still standing.
08 Questions
No. Each machine is a virtual machine with its own kernel, isolated in hardware. Containers share the host kernel, which is why they are cheap to start and weaker as a boundary. MANSSINO gets the start time from snapshot and restore rather than from sharing a kernel, so you keep the strong boundary and still resume in under 250 milliseconds.
The disk and the memory image. In practice that means your home directory, every installed package, environment variables, running daemons, and background jobs. A process that was mid-loop when you slept the machine continues from where it was when you resume it.
The exceptions are the ones you would expect: open network connections do not survive, and anything tied to wall-clock time will notice that time has passed.
Yes. You have root and a real kernel, so Docker, systemd, kernel modules, and nested virtualisation behave normally. Running containers inside your own VM is a common pattern for teams that already ship images and want persistence underneath them.
Ask for a GPU-backed shape at creation time and the machine comes up with drivers and the CUDA toolchain available. Because the disk persists, a model, a dataset, and a compiled environment stay on the machine between runs instead of being staged again every time.
Active compute time. A running machine is metered, a sleeping machine is not, and storage of a sleeping machine is kept so the resume is instant. For a representative agent workload, where machines spend most of the day asleep between turns, we estimate that lands roughly 60% below comparable ephemeral sandboxes.
Fleets are designed to be wide. The common pattern is one machine per agent, per session, or per branch, created and slept programmatically rather than held open. Tell us the concurrency you are planning for when you request access and we will provision headroom around it.
Disks and snapshots are encrypted at rest, and the control plane and SSH are encrypted in transit. A deleted machine takes its disk and snapshots with it. The security model covers key handling, access control, and the shared responsibility line in detail.
MANSSINO is rolling out through a waitlist, prioritised by workload fit rather than by queue position. Describe what you are building on the request page and we will come back with a machine and a key.
Waitlist open
MANSSINO is rolling out to developers building agentic and automated workloads. Tell us what you are running and we will get you a machine that is fast, persistent, and isolated by design.