MachineyardMachineyard

A new generation of cloud - not for you, but for your
AI agents

Sub-second boot. Real kernels. Snapshot, branch, test, ship.

Machineyard gives your agent a real Linux VM in under 400ms - and lets it snapshot and branch the way it already does with git. Start free, scale on demand.

View the API
machineyard - bash
$ machineyard run --image debian:12 --preset small -- "echo hello from $(uname -n)"

Recorded from a real session

Early Access

Be first in line.

We're rolling out access in batches. Drop your details and we'll reach out when your slot is ready.

We'll never sell or share your email address. Ever.

Why Machineyard?

The enablement layer between AI agents, your enterprise and real tasks.

Machineyard provides the foundation agents need to execute, persist, and recover - and the control plane operators need to manage it all.

The Problem

Models reason. They still need somewhere to work.

AI models can reason about a task, but they still need somewhere reliable to execute, store progress, and continue later. Machineyard supplies that foundation; persistent, isolated environments with one place for developers and operators to manage how the work runs.

The Reality

Agents fail. Infrastructure must make recovery cheap.

Agents regularly crash, retry, and take the wrong path. Machineyard preserves working state and enables parallel experimentation, helping agents complete longer and more complex jobs without repeatedly starting from zero.

Trust Built In

Give agents more responsibility without losing control.

Machineyard records every meaningful action an agent takes, giving companies a clear and complete account of its work. Enterprises can give agents more responsibility without losing visibility, accountability, or control.

Autonomy Without Uncertainty

Independent agents, fully traceable actions.

Machineyard lets agents work independently while keeping their actions fully traceable. Teams always know what happened, who initiated it, and how the agent completed the task.

What's cool about it?

Same primitives as git, applied to microVMs.

Spawn, snapshot, branch - your agent already knows this mental model.

git
$ git clone repo
machineyard
$ machineyard run --image runtime:claude-code

Recorded from a real session - beta version of the product. Subject to change.

Features

Built for the agent-shaped development workload.

Every design decision was made with an autonomous AI caller in mind.

Sub-second boot

p95 ≤ 400ms for warm-pool spawns. Cold boot ≤ 1.5s. Warm pool pre-provisioning, no magic.

Snapshot and branch

Freeze a VM, branch N children from it, branch the children, recursively. Restore in under a second if anything breaks.

Three lifecycles

ephemeral (one-shot), session (idle-reap), pinned (durable, named). Pick the lifetime that matches the work.

Agent-first API and SDK

Idempotent by default. Structured errors with remediation an LLM can act on. SSE event streams.

Audit-grade secrets

Enterprise grade secret manager as source of truth. Vsock metadata, env-at-boot, bind-mount, or proxy-injection. Every read is logged.

Command logging

Every shell command, tool call, and agent action is captured with timing, exit codes, and stdout/stderr. Immutable, tamper-evident, queryable.

Compliance-ready

SOC 2-aligned controls out of the box. Network egress policies, resource caps, and per-VM identity enforced at the hypervisor layer - not bolted on in userspace.

Full auditability

Structured event trail from API call to process exit. Export to your SIEM. Replay any agent session or diff two runs side-by-side for forensic review.

Private VM networking

Every VM gets a private IP at spawn time. Peers resolve each other by name over a flat private subnet - no VPN, no proxy, no public exposure by default. Enforced at the hypervisor layer.

VM Branching & Networking

Git branching. For entire machines.

Snapshot any running VM, branch it N times in seconds, and recurse as deep as you need. VMs in the same project share a private network - reachable by name, dark to the internet by default.

snapshotted
running
testing
done
vm-basesnapshottedfeat/authagent workingfeat/paymentsPR readyfix/perfagent workingfeat/api-v2agent workingtest/authrunning teststest/paymentstests passedtest/perfrunning teststest/api-v2running tests

Multiple agents, one codebase, zero conflicts

Branch from a prepared base VM - repo cloned, deps installed, tests passing. Each agent gets an identical, isolated copy and works on its own feature branch simultaneously.

  • No shared filesystem - agents never collide
  • Run the full test suite per branch in isolation
  • Merge the winning implementation, discard the rest
agent.ts
// vm-base: repo cloned, deps installed, CI green
const base = await client.snapshots.create('vm-base')

// All 4 agents branch and start in < 400 ms
const [auth, pay, perf, apiv2] = await Promise.all([
  base.branch({ name: 'feat/auth' }),
  base.branch({ name: 'feat/payments' }),
  base.branch({ name: 'fix/perf' }),
  base.branch({ name: 'feat/api-v2' }),
])

// Independent - no waiting, no collisions
await Promise.all([
  agent.implement(auth.id,  'Add OAuth2 login flow'),
  agent.implement(pay.id,   'Stripe checkout integration'),
  agent.implement(perf.id,  'Fix DB query N+1s'),
  agent.implement(apiv2.id, 'REST → GraphQL migration'),
])

// Run full test suite per branch in isolation
const results = await Promise.all([
  runner.test(auth.id),
  runner.test(pay.id),
  runner.test(perf.id),
  runner.test(apiv2.id),
])
< 400ms
Branch cold-start
O(1)
Branch cost vs. VM size
∞
Recursion depth
0 bytes
Shared state between branches
Code, not screenshots

Spawn, snapshot, branch - in four languages.

The same operation in curl, Python, TypeScript, and Go. Copy-pasteable, runnable against the real API.

Idempotency-Key on every write
Safe to retry. Submit the same job twice, get the same result once.
Machine-readable error codes
A stable enum with a remediation field. Your agent knows what to do next.
Live event streams via SSE
Stream state transitions, stdout, and artifact events in real-time.
Agent skills via skills[]
Attach web, git, or bash tool packages at spawn time. Inherited by every snapshot and branch.
Python, TypeScript, Go SDKs
Auto-generated from OpenAPI 3.1. Published to PyPI and npm. Type-safe.
curl -sX POST https://api.machineyard.net/v1/jobs \
  -H "Authorization: Bearer $MACHINEYARD_TOKEN" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "image":   "runtime:claude-code",
    "cmd":     ["claude", "--print", "list the files in /workspace"],
    "vcpu":    1,
    "mem_mib": 1024,
    "timeout_s": 120
  }' | jq
Lifecycle Modes

Three modes. Pick what you need.

Every VM request declares a lifecycle mode. The platform optimizes boot time, resource allocation, and state management accordingly.

Ephemeral

One-shot. Fire and forget.

A VM spins up, executes your task, and is destroyed immediately. No state persists. Perfect for isolated code execution where you need a clean environment every time.

One-shot code execution
Web scraping
CI test runners
Build pipelines
Boot time
< 400ms
Lifetime
Seconds–minutes
Snapshot
No
Resume
No
State Machine
requested
provisioning
booting
running
stopped
ModeBootLifetimeSnapshotBest For
Ephemeral< 400msSeconds–minutesNoOne-shot code execution
Session< 400msMinutes–hoursIn-memoryAgent conversation loops
Pinned< 400msHours–daysDurable (encrypted storage)Persistent dev environments
How It Works

Four steps. No magic.

A stateless control plane, warm VM pools, and an event-driven architecture that keeps latency low and availability high.

01

Auth

GitHub OAuth, get a token, get a tenant. One API key, all operations.

02

Spawn

POST /v1/jobs with an image, a command, a preset. Idempotent - safe to retry.

03

Watch

GET /v1/jobs/{id}/events (SSE) for state transitions, stdout, and exit codes in real-time.

04

Snapshot / Branch

POST /v1/snapshots and POST /v1/branches whenever you want, recursively.

Platform

The backend interface

Manage agents, environments, networks, snapshots, and team access from a single control plane.

Dashboard
DashboardClick to expand
Pricing

Honest, no asterisks.

Free is real - no credit card, no time limit. Pay only for what you use as you grow.

Free

$0forever
  • 4 concurrent VMs
  • 5 vCPU-hours / month free
  • Pay-as-you-go above 5 hours
  • 10 GB egress / month
  • $0.02 / GB egress above 10 GB
  • 10 GB snapshots, 7 days retention
  • 15 minutes between snapshots
  • Private VM networking
  • overlay + mesh networking
  • vsock + env secrets
  • GitHub OAuth
  • Community support

Pay as you go

Usage-basedno monthly fee
  • $0.00018 / vCPU-minute
  • $0.00014 / min per 1024 MB RAM
  • $0.0000027 / min per GB disk
  • $0.0000011574 / min per GB snapshot storage
  • $0.02 / GB egress
  • 2 minutes between snapshots
  • Unlimited concurrent VMs
  • Private VM networking
  • GitHub OAuth + mTLS
  • Email support

Pro

200$/month
  • up to 50 concurrent VMs
  • Private VM networking
  • 10,000 vCPU-hours / month included
  • 1 TB egress / month
  • $0.02 / GB egress above 1 TB
  • 1 TB snapshots, 30 days retention
  • 1 minute between snapshots
  • GitHub OAuth + mTLS
  • SSO
  • Email support, 1 business day
  • 99.9% SLA

Pricing calculator

1 VMs x 480 min x 1 vCPU x 30 days = 240 vCPU-hours/month
Compute $2.59RAM $2.02 (1 GiB)Disk $0.39 (10 GB)Snapshots $2.50 (50 GB × $0.0000011574/GB/min)
$7.50/month

Resource Presets

PresetvCPUMemoryDiskNetwork
one-shot1256 MiB1 GB10 Mbps
small11 GiB10 GB100 Mbps
medium12 GiB20 GB200 Mbps
large24 GiB50 GB200 Mbps
xlarge48 GiB70 GB300 Mbps
xxlarge612 GiB80 GB300 Mbps

* Pricing is subject to change. Final pricing will be confirmed at launch.

Startup Program

Built for founders who are building with agents.

Agentic infrastructure is a new category. We know the compute bills come before the revenue. The Machineyard Startup Program gives you real runway - up to $20,000 in credits - to build the thing properly, not the cheap version.

$20,000
in compute credits to get you started

Credited directly to your account. Spend it on VMs, snapshots, networking - anything on the platform.

Up to $20K in credits
Enough runway to build, iterate, and ship real agents at scale - no artificial time pressure, no surprise bills.
No rate limits during development
Spin up hundreds of parallel VMs without throttling. We stay out of your way while you move fast :)
Dedicated onboarding engineer
A Machineyard engineer joins your Slack on day one. Architecture reviews, tuning sessions, direct escalation, no ticket queues :).
Private beta features
Early access to GPU-attached VMs, sub-second cold starts, and persistent agent memory - before they hit general availability.
Co-marketing & case study
Ship something interesting? We'll tell the story together; blog posts, social reach, and a case study to show investors.
Startup network access
Direct intros to other startups building on Machineyard - AI-first companies that understand what you're building.

Who qualifies

  • Building an AI-native product where compute is core to the architecture
  • Pre-Series B startup - seed, pre-seed, or bootstrapped
  • Actively shipping, not just exploring
  • Using (or planning to use) Machineyard VMs in production

Borderline cases reviewed by a human. If you're uncertain, apply anyway; we'd rather read your pitch than have you self-select out.

Rolling admissions. Applications reviewed within 5 business days.

Ship VMs to your agent in the next 5 minutes.

Get an API key, run your first job, snapshot it, and branch three children - all before your coffee gets cold.