Act

Ahura VM

A sandbox for every task.

Run untrusted or heavy code in an isolated micro virtual machine that starts in moments and disappears when done. The safe way to let an agent execute what it wrote.

What it does

Strong isolation
Each run gets its own micro VM. Nothing leaks between runs.
Fast to start
Sandboxes boot quickly enough to use inside a loop.
Snapshots
Keep a sandbox state and resume it later.
Metered by the millisecond
Pay for the compute you used, not the machine you reserved.

An agent calls it like this

{ "tool": "vm.run", "image": "ahura/python:3.12", "cmd": ["python", "solve.py"], "timeout": 300 }

Interactive simulation

Try Ahura VM

Press Run to send the call. The dashboard shows what it would use in a partition. Simulated: nothing is actually executed.

ahura mcp · ptn_demo_7f3a

# Run agent-written code in its own micro VM.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "vm.run",
    "arguments": {
      "image": "ahura/python:3.12",
      "cmd": [
        "python",
        "solve.py"
      ],
      "timeout": 300,
      "network": false
    }
  }
}

# Read the output.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "vm.logs",
    "arguments": {
      "run": "run_5d20"
    }
  }
}

Ready. Press Run.

ptn_demo_7f3a

Partition · N. Virginia · created just now

Simulated

Activeus-eastRetention hold

days left

Run time

0.0s

0 calls

Size

2.3MB

0.00 ACU used

Services in this partition

VM
0 calls · 0.00 ACU

Spend by service

Ledger

No usage yet.

Why it matters

Where Ahura VM beats servers and shared runners.

Letting an agent run code is the riskiest thing most teams do, usually on a machine that holds far more than it should.

Servers, containers or shared runners

Run agent-written code on a long-lived machine with broad access.
Pay for capacity that sits idle between jobs.
Patch, monitor and clean up the fleet.
Build file staging, limits and log capture around every job.

Ahura VM

Every run gets its own micro VM that is thrown away afterwards.
Billed on CPU and memory seconds actually used.
Nothing to patch. Images are curated and kept current.
Files in, files out, limits and logs are part of the call.

Isolation
Separate micro VM per run, network off by default.
Speed
Sandboxes start fast enough to use inside an agent loop.
Cost
No idle machines, ever.
Continuity
Snapshots on dedicated VMs let work resume exactly.

The fast sandbox tier is available by default. Dedicated long-running VMs and snapshots are opt-in.

In depth

What Ahura VM can do.

Two tiers, one interface
A fast sandbox for jobs up to 15 minutes, and dedicated long-running VMs up to 7 days for heavier work. The same run call drives both.
Strong isolation
Every run happens in its own micro virtual machine, as a non-root user with restricted system calls.
Network off by default
Code cannot reach the internet unless you allow it, and access to internal addresses is always blocked.
Files in, files out
Mount objects from Ahura Store before the run and collect outputs back into Store afterwards.
Run Python in one call
Send code and a list of pinned packages and get JSON back. Package environments are cached so repeat runs start quickly.
Sync or async
Short jobs return inline. Longer ones return a run ID, announce completion and can be polled or waited on.
Interactive sessions
On dedicated VMs, start a VM and run several commands in it, with state carried between them.
Snapshots
Capture a VM’s memory and disk, stop it, and restore it later exactly as it was.
A choice of operating systems
A tiny Alpine system for speed, a full Ubuntu-based one for compatibility, or your own base image.
Meter by usage
Billed on CPU and memory seconds actually used.

Environments

Pick the operating system for the job.

Each run boots in its own micro VM. Choose a lightweight system for speed, a full one for compatibility, or bring your own.

Default for quick utilities
Minimal Alpine Linux
Alpine Linux
Root filesystem
~5 MB
Baseline memory
~15 MB
A very small system built on musl and BusyBox. It boots almost instantly, which makes it ideal for fast micro-utilities, Python scripts, Node.js tasks and basic command-line tools.
- • Micro-utilities and scripts
- • Python and Node.js tasks
- • Fast start inside an agent loop
Default for complex agent work
Ubuntu Server Minimal
Ubuntu minimal, Debian-based
Root filesystem
~30 MB
C library
Full glibc
A standard Linux environment with full glibc compatibility. Choose it when agents need ordinary C libraries, heavy Python packages such as PyTorch or OpenCV, browser dependencies, or pre-built Linux binaries that expect Debian or Ubuntu.
- • PyTorch, OpenCV and similar packages
- • Headless browsers
- • Pre-compiled Linux binaries
Custom container root filesystem
Bring your own base image
Fedora, Arch, distroless or your own
Base
Any
Format
OCI image
Send a Dockerfile or an image reference and the agent picks its own base. Ahura VM strips away the container overhead and boots that filesystem as a native micro VM guest, so you keep your exact environment with the isolation of a virtual machine.
- • Reproducing an existing environment
- • Unusual distributions or toolchains
- • Hardened, minimal images

Sizes are approximate. Custom base images are available on dedicated VMs.

Every call, listed

12 tools your agent can call. Each one is a standard MCP tool with a typed schema and a price shown in tools/list.

Run

vm.run: Run a command with files, limits, network setting and tier.
utilities.run_python: Run Python code with pinned packages and get JSON back.
vm.wait: Wait up to 20 seconds for a run to finish.
vm.cancel: Stop a run.

Inspect

vm.get / vm.list: Status, usage and output locations.
vm.logs: Standard output and error, including live tailing on dedicated VMs.
vm.images: Available images.

Dedicated VMs

vm.start / vm.stop: Start a long-lived VM, and stop it with an optional snapshot.
vm.exec: Run a command inside a running VM.
vm.snapshot / vm.restore: Capture and bring back a VM.
vm.snapshots.list / delete: Manage snapshots.
vm.image.import / delete: Bring your own base image.

Dedicated long-running VMs and snapshots are opt-in. The sandbox tier is available by default. For work that needs a GPU, use Ahura GPU.

Use cases with VM

All use cases

Industries using Ahura VM

Works with

Next: Ahura Workflows

Ahura Workflows

Reliable multi-step work.

Ahura Memory

Fast working memory for agents.

Ahura Store

Persistent files and objects.

Ahura NoSQL

Document collections without the setup.

Partitions

Where this service's data lives and how it freezes.

Ahura VM

What it does

An agent calls it like this

Try Ahura VM

Where Ahura VM beats servers and shared runners.

Servers, containers or shared runners

Ahura VM

What Ahura VM can do.

Two tiers, one interface

Strong isolation

Network off by default

Files in, files out

Run Python in one call

Sync or async

Interactive sessions

Snapshots

A choice of operating systems

Meter by usage

Pick the operating system for the job.

Minimal Alpine Linux

Ubuntu Server Minimal

Bring your own base image

Every call, listed

Run

Inspect

Dedicated VMs

Use cases with VM

Industries using Ahura VM

Works with