Kanvify
SHEET KV-CI-01 · MANAGED GITHUB ACTIONS RUNNERSREV 2026-07 · SELF-SERVE

Runners with nothing to hide.

Managed GitHub Actions runners on ephemeral microVMs — a real machine per job, real Docker, and a spec sheet instead of a slogan. We publish our numbers, including the ones we’re still improving.

Get startedRead the procedure

INSTALL APP → CHANGE runs-on: → PUSH. NO INFRASTRUCTURE TO OPERATE.

Unit specPer job
Execution unit
1 microVM, single-tenant
Lifetime
one job, then destroyed
Runner registration
just-in-time, per job
Docker
dockerd in the VM — no DinD
Arch / OS
x64 · Ubuntu Linux
Queue → pickup (cold)
~60 s today · improving
Billing
per second — pure usage, no tiers

Rate · 2 vCPU x64

$0.0033/min

vs. GitHub-hosted at $0.006/min — billed per second; a 61-second job costs 61 seconds.

Machines reused between jobs

0

Every job boots a fresh microVM. Isolation is standard for every run.

Workflow changes required

1 line

runs-on: kanvify — everything else stays yours.

Design properties

SEC A · WHY MICROVMS
A.1 — ISOLATION

A machine per job

Your job never shares a kernel with another tenant’s — or with your own previous run. The blast radius of any job is its own VM, which stops existing minutes later.

A.2 — DOCKER

The daemon is real

dockerd runs inside the VM like it does on your laptop. Build, compose, Testcontainers — no Docker-in-Docker emulation, no privileged-mode caveats in the fine print.

A.3 — SUPPLY

Registered just-in-time

Runners don’t idle in your org waiting to be hijacked. Each one is registered for its job at boot and gone at exit — there is no standing fleet to secure.

A.4 — METERING

Billed like a utility

Usage is metered per second and billed like a utility. The dashboard shows every machine, its job, and its cost under one spend cap — billing stops the second the VM is destroyed.

Not on this sheet yet

  • – ARM runners
  • – macOS / Windows
  • – Layer-cache add-on
  • – Sticky disks
  • – Static egress IPs

We list what we don’t do so you can trust what we say we do. These are on the roadmap; nothing above is.

Installation procedure

SEC B · EST. TIME: MINUTES

  1. Install the GitHub App

    One command from your Kanvify workspace connects your GitHub org. Nothing to host, patch, or scale on your side.

  2. Edit one line

    Change runs-on: to kanvify in any workflow. No other YAML changes; your steps, actions, and secrets are untouched.

  3. Push and watch

    On each queued job, a microVM boots and registers just-in-time. Cold queue-to-pickup runs about 60 seconds today; we publish this number because we intend to shrink it.

.github/workflows/ci.yml — full diff
jobs:
  build:
-   runs-on: ubuntu-latest
+   runs-on: kanvify
    steps:
      - uses: actions/checkout@v4
      - run: docker compose up -d   # real dockerd — just works
      - run: pnpm test

Machine lifecycle

FIG. 1 · OBSERVED, NOT PROMISED
MACHINE Nº 48,112microVM

test-suite · push to main

born09:14:07
job finished09:19:41
lifetime5m 34s
DESTROYED ✓
MACHINE Nº 48,113microVM

lint · pull_request #212

born09:14:52
job finished09:16:20
lifetime1m 28s
DESTROYED ✓
MACHINE Nº 48,114microVM

docker-build · release

born09:15:18
job finished09:23:02
lifetime7m 44s
DESTROYED ✓
MACHINE Nº 48,115microVM

e2e · pull_request #213

born09:16:03
runningnow
registeredjust-in-time
BORN FOR THIS JOB
Every machine exists for exactly one job. Nothing is reused; nothing is left behind for the next run to find.
SEC C · ONE PLATFORM, ONE METER

Your agents work all day.
Your CI works in bursts.
Both land on one meter.

One account, one usage ledger, one invoice, one spend cap. CI runners and agent computers share the same $0.10/vCPU-hour compute meter; the LLM proxy adds no Kanvify charge.

Line 1 · CI runners

Machines for your pipeline

Ephemeral microVMs that pick up GitHub Actions jobs, run them in isolation, and are destroyed.

  • One-command onboarding via GitHub App
  • Full Docker, x64 Ubuntu
  • Per-second metering at the same compute rate
Line 2 · Agent computers

Machines for your agents

Persistent sandboxes AI agents live in — suspend, resume, checkpoint, and govern from outside the box.

  • Egress policy and token budgets on the critical path
  • Checkpoints and restore
  • REST API, MCP server, web terminal

Same metal, same isolation model, same $0.10/vCPU-hour rate. Your CI runners and agent computers land on one usage bill, under one spend cap.

Sandboxes forget. Computers remember.

A sandbox runs a task and disappears. An agent computer keeps its state — so your agent can pick up tomorrow exactly where it stopped today.

A sandbox

  • Spins up, runs one task, evaporates
  • Files and processes are gone at exit
  • Every session starts from zero
  • No outside control over spend or network

An agent computer

  • Persists across sessions — suspend when idle, resume with state intact
  • Checkpoints you can restore at any time
  • Egress and spend governed from outside the box
  • Every token metered and attributed

Why Kanvify

A layer on top of raw compute — the things a throwaway sandbox can’t give you.

Persistent

Suspend a sandbox when your agent goes idle and resume it later with the filesystem intact. Take checkpoints and restore a known-good state when a run goes sideways.

Governed

Network egress rules with default-drop, LLM token budgets, and account-level spend caps — enforced outside the sandbox, where the agent can’t reach them.

Metered

Compute is charged by Kanvify; model calls use your provider key. The usage dashboard attributes both compute and estimated provider costs without adding an LLM charge.

Collaborative

Coming soon

Coming next: humans and agents will share one machine — live previews, shared terminals, and multiplayer editing.

A computer that outlives the session

One API call boots a machine. The lifecycle takes it from there.

  1. Spawn

    Boot an isolated sandbox with its own filesystem and network in seconds.

  2. Operate

    Run commands, install packages, start services — over the API, through MCP, or from the web terminal.

  3. Suspend

    Pause the machine when the agent is idle. State is kept; compute stops.

  4. Resume

    Wake it back up with files and workspace exactly as the agent left them.

  5. Fork

    Coming soon

    Soon you’ll be able to branch a machine and explore several approaches in parallel.

How state survives

Durable state and disposable compute, kept apart.

Sandbox

The running computer. Isolated on a managed host, billed only while it runs.

Checkpoint

A point-in-time image of the disk. Suspend into it, resume from it, roll back to it.

Usage ledger

Every token and metered action, recorded and attributed. The record outlives any single machine.

Governance, on the critical path

Controls sit between the agent and the world — not inside the prompt.

Token budgets & spend caps

Model calls route through the LLM proxy with your provider key. Budgets are enforced per call, and spend caps stop runaway usage before it becomes provider spend.

Egress policy

Per-sandbox allow/deny rules with a default-drop policy. If a domain isn’t on the list, the connection never leaves the box.

Cost metering

Provider price estimates and cost attribution feed a usage dashboard — spend by sandbox, by model, by day, with no Kanvify LLM charge.

Audit trail

Sandbox activity is logged to an audit trail you can review after the fact.

Built to be driven by agents

Everything on this page is an API call.

REST API & API keys

Script the full sandbox lifecycle with scoped API keys.

OAuth provider

Let third-party tools act on a user’s behalf with scoped tokens.

MCP server

Plug Kanvify into Claude and other MCP clients — agents manage their own computers.

Web terminal

Drop into any sandbox from the browser and see what your agent sees.

Previews & multiplayer

Coming soon

Next up: expose a URL, invite a teammate, and keep both live.

Stable preview URLs

Every sandbox will get a stable URL for the services it runs — one that survives suspend and resume.

Real-time collaboration

Humans and agents will share the same machine — files and terminal, live.

Run anywhere

Coming soon

Kanvify runs on managed hosts today. Your infrastructure is next.

Soon you’ll be able to bring your own cloud or servers and run sandboxes there — keeping Kanvify’s governance, metering, and lifecycle exactly as they are.

CI runner rates

SEC D · PRICE LIST
Provider2 vCPU x64 rateBilling granularityMachine model
GitHub hosted$0.006/minRounds each job up to a full minuteManaged shared-pool VM
Challenger field (Blacksmith · Depot · WarpBuild)$0.004/minMostly per-minuteManaged runners, varying isolation
Kanvify$0.0033/minPer-second — a 61-second job costs 61 secondsFresh microVM per job, destroyed at exit
Budget floor (Ubicloud)$0.0016/minPer-minuteEphemeral VM, more DIY

Comparison for a 2 vCPU x64 Linux runner. Market rates as commonly published, 2026-07.

Billing policiesEvery customer
Granularity
per-second, quoted per-minute
Queue time
never billed
Infra-interrupted jobs
never billed
Base / platform fee
none — no subscription minimum
Usage billingNo buckets

Per second, from the first second

There are no included-minute buckets. CI runners and agent computers use the same compute meter and appear on one invoice.

Pricing

Pure usage. One invoice.

CI runners and agent computers use the same compute rate. Storage is metered separately. Bring your own LLM provider key; Kanvify does not charge for model usage.

Meter 01 · Compute

Runners + agent computers

$0.0033 / 2-vCPU min

$0.10 / vCPU-hr

The same rate for ephemeral CI runners and persistent agent computers. Billed per second; suspended computers do not accrue compute charges.

Meter 02 · Storage

Durable storage

$0.073 / GB-month

$0.0001 / GB-hour

Pay for the durable storage you keep, measured by the hour. Compute and storage appear on the same invoice.

LLM proxy · Bring your own key

We don’t charge for LLM usage

You pay your provider directly. The proxy still adds caching, routing, cost visibility, and keeps your key out of the sandbox.

No tiers. No seats. No minimum. Pay for what you run.

Get startedTalk to us for committed-use discounts →

Check our numbers.
Then check your bill.

Install the app, point one workflow at runs-on: kanvify, and compare the invoice line for yourself. Self-serve, billed only for what you use.

Get started

Self-serve. Spend caps on by default.