Checkpointed workstations for coding agents

Your agent will break something. Undo it in 40 seconds.

Unkindled is a Linux VM you SSH into, with Herdr preinstalled. Take a whole-machine checkpoint before your agent runs, fork it to try a second approach, and roll the disk back when something breaks. Not a sandbox that prevents damage — a machine that survives it. Your API keys stay in your home directory, not on our disk.

$5 credit on signup. Card or crypto. Ubuntu 24.04, root access.

p50 restore
38s
Checkpoint
1.8s
Tenancy
1 VM
agent@unk-04: ~ ssh
agent@unk-04:~$ unkindled checkpoint --label "before refactor"
✓ ckpt_7f3a   12.4 GB disk · 1.8s

agent@unk-04:~$ unkindled fork ckpt_7f3a --name unk-04-b
✓ unk-04-b ready   8 vCPU / 16 GB · 4.2s

agent@unk-04:~$ unkindled restore ckpt_7f3a
· attaching snapshot layer
· restoring ext4 metadata   2.1 GB / 2.1 GB
· restoring postgres data   3.4 GB / 3.4 GB
· restarting postgresql, docker, herdr
✓ restored in 38.2s   ssh agent@unk-04
Restore p50 38s, p95 54s. Measured on 8 vCPU / 16 GB with a 160 GB disk. Cold restore from object storage takes about 2 minutes.

The problem

Git remembers your code. Nothing else.

A bad agent run does not stop at the repository. It installs packages, migrates the database, rewrites environment files, fills Docker layers, and leaves every open session in a state you cannot reconstruct.

  • The OS is part of the change

    apt packages, systemd units, /etc, kernel modules. None of it is in your diff.

  • Data has state

    Postgres rows, Redis keys, SQLite files, local caches. "Just revert the commit" does not touch them.

  • Toolchains drift

    Node 18 to 22, Python 3.11 to 3.13, rebuilt native modules. Reproducing the build takes longer than fixing it.

  • Sessions die with the machine

    Herdr panes, shells, environment variables, open files. Your agent's working context is not a git object.

git statusrepo
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
unkindled statusmachine
! 3,412 files changed outside the repo
! postgres schema at rev 0441, expected 0438
! node_modules built against node 18
! 2 Herdr sessions orphaned
✓ git: clean

Same workspace. Fourteen minutes apart.

Sandbox vs. Unkindled

A sandbox prevents the crash. Unkindled lets you crash.

Die. Restore. Keep the progress. Both models shrink the blast radius; they pull in opposite directions. A sandbox contains the damage. Unkindled reverses it.

How a sandbox and Unkindled handle the same bad agent run
Sandbox Unkindled
Safety model Containment: stop the damage escaping Reversibility: undo the damage
Assumes the agent is Hostile or untrusted Fallible, like you
Time horizon Ephemeral, per run Persistent, long-lived
State A fresh template every time Your real DB, caches, and sessions
When it breaks Kill it and start over Roll back to a checkpoint
What is protected The host and other tenants Your afternoon's work
The sentence "You may not break anything." "You may break this; we put it back."

Contained at the edge, reversible inside. Abuse, egress, and cross-tenant access are still isolated. The difference is what happens to your work when a run goes wrong: nothing you checkpointed is lost.

How it works

Three commands, one whole machine.

There is no rebuild step and no image bake. Unkindled snapshots the disk, clones it, and puts it back.

  1. unkindled checkpoint

    Checkpoint

    Freeze the whole disk: OS, Postgres, Docker layers, toolchains, caches, and Herdr session state. Copy-on-write, so it takes about two seconds and does not double your storage.

    1.8s median40 GB disk

  2. unkindled fork

    Fork

    Clone a running machine at the checkpoint. New hostname, new SSH key, identical disk state. Point a second agent at a second approach instead of arguing with one context window.

    4.2s mediannew VM

  3. unkindled restore

    Restore

    Roll the machine back. Services restart, your SSH session reconnects, Herdr reattaches. This is not git reset with extra steps; the database rolls back too.

    p50 38sp95 54s

Restore times are measured, not modeled: p50 38s and p95 54s across production restores in the last 30 days. Disk size and host load move those numbers. We publish both on the status page.

Agent skills

Teach your agent to use the undo button.

unkindled install-skills writes a portable skill into the harness you already use. The agent learns when to checkpoint, how to fork, and when to stop and ask before a restore. Plain Markdown; no plugin, no SDK.

  • Checkpoint before risk. Destructive commands, migrations, and dependency upgrades get a labelled checkpoint first.
  • Fork for parallel work. Two agents, two approaches, one starting state. No fighting over the same box.
  • Restore safely. The skill tells the agent to confirm before discarding anything written after the checkpoint.
  • Never move secrets. Keys stay in the VM. An exported disk is treated as a secret, not a build artifact.
install-skills cli
$ unkindled install-skills --harness all --scope user
✓ claude     ~/.claude/skills/unkindled/SKILL.md
✓ opencode   ~/.config/opencode/skills/unkindled/SKILL.md
✓ codex      ~/.codex/AGENTS.md (block updated)
✓ hermes     ~/.hermes/skills/unkindled/SKILL.md
✓ cursor     ~/.cursor/rules/unkindled.mdc
✓ gemini     ~/.gemini/GEMINI.md (block updated)
✓ generic    ~/.agents/skills/unkindled/SKILL.md

7 targets · idempotent · backups on write
User scope shown. --scope project writes into the repo instead; --dry-run prints every path before touching disk.

Harnesses we write to

  • Claude Code
  • OpenCode
  • Codex
  • Hermes
  • Cursor
  • Gemini CLI

Not on the list? --dir <path> writes the same portable SKILL.md anywhere, and --harness auto detects what you already have. Codex and Gemini also get a marked block in AGENTS.md / GEMINI.md.

Interactive demo

The undo button, in miniature.

Pick a checkpoint and restore it. This runs the same control flow as the real command, compressed to about three seconds. No backend, no signup.

Checkpoints

unk-04

Simulated at 40× speed. A real restore is p50 38s.

unkindled — restore simulated
# select a checkpoint, then run the restore agent@unk-04:~$
Restore progress 0%

Idle.

The math

One lost afternoon costs more than a month.

A $6 VPS is cheaper right up until it costs you a day. Put your own numbers in.

Cost of lost time, per month

$720

That is 9.1× the Pro plan at $79/mo on annual.

Excludes the rebuild: reinstalling packages, replaying migrations, and re-reading the logs. That is usually the larger half.

Pricing

Pricing that stops at the cap.

Every plan is a full VM with root, a public IPv4, and 1 TB of egress. Active hours are hours the machine is powered on. Hit the cap and it suspends. No overage invoice.

Billing period

Solo

One agent at a time, with room to undo.

39 /mo

billed monthly · cancel anytime

  • 4 vCPU · 8 GB RAM · 80 GB NVMe
  • 160 active hours / month
  • 2 concurrent forks
  • 3 checkpoints included
  • Root access + public IPv4
  • qcow2 export
  • Docs + community support

Studio

Parallel forks for small teams and heavy builds.

149 /mo

billed monthly · cancel anytime

  • 16 vCPU · 32 GB RAM · 320 GB NVMe
  • 640 active hours / month
  • 16 concurrent forks
  • 10 checkpoints included
  • Root access + public IPv4
  • qcow2 export
  • Priority support + onboarding call

Hard cap, hard stop At your active-hour cap the VM suspends. Resume next cycle or upgrade mid-cycle and pay the prorated difference. Nothing bills over the cap.

Checkpoints, priced 3 included on Solo, 5 on Pro, 10 on Studio. Extra retention is $0.10/GB-month. Unlimited snapshots are how a $39 plan becomes a $12 storage bill; we cap it and show the meter.

Support, priced Docs and community are included on every plan. Human support is a $39/month add-on, included on Pro and Studio. No 24/7 on-call; a small team answering email.

Annual by default Save 20%, billed once a year. Annual prepay funds capacity up front; that is why the annual rate is $39 and the monthly rate is $49. Cancel anytime; unused time is not refunded.

Teams

Five workstations, one invoice.

SSO, shared billing, a shared checkpoint policy, and priority support. From $299/mo for five seats, annual by default.

Talk to us about Teams

Trust and security

Your keys, your disk.

Unkindled is built for people who read the privacy page before signing up. Here is what we do, and what we do not.

Tenancy

One VM per tenant

Each workspace is a KVM guest with dedicated volumes. No shared kernels, no noisy neighbors, no cross-tenant snapshot store.

Keys

Keys never touch our disk

Model API keys are written inside the VM at ~/.config and never copied to the control plane or image store. We do not proxy model calls.

Logging

No prompt logging

We do not inspect your disk, terminal, or agent traffic. Metrics are CPU, disk, network, and uptime. Debug access needs a time-boxed grant from you.

Portability

Export, don't ask

Download the full disk as qcow2 and boot it in QEMU or Proxmox. No exit interview and no migration fee.

Deletion

Delete means delete

Workspaces are destroyed on request. Backups and snapshots are purged within 30 days. The deletion receipt lists every object removed.

Operations

Status in public

status.unkindled.dev carries incident history and postmortems. Restore latency is on the same page, including the bad weeks.

Assurance

Scans you can read

Monthly image and dependency scan reports with SBOMs. Run unkindled scan inside your own workspace at any time; uploads are redacted and opt-in.

Supply chain

Signed before install

Skill bundles are scanned before install-skills writes them. Critical findings block the install; high findings require an explicit, audited override.

Limits, stated plainly

  • Linux only (Ubuntu 24.04). There are no Windows agents yet.
  • No GPU plans yet. CPU workstations only.
  • Restore is p50 38s, p95 54s on our hardware. Snapshot encryption is at rest; you hold the only copy of your keys.

Comparison

Unkindled vs. the alternatives.

If you have the time, a Hetzner box plus a snapshot script is cheaper. We sell the part you do not want to build, test, and carry a pager for.

Unkindled compared with a Herdr VPS template or DIY Hetzner VM, GitHub Codespaces, and an E2B-style sandbox API
Feature Unkindled Hetzner + DIY Codespaces E2B-style sandbox
Floor price $39/mo, 160 h, annual $6–15/mo + your scripts $0–39/user/mo, metered Metered per sandbox-hour
Herdr preinstalled Yes No, you install it No No
Snapshot scope Whole machine Whole disk, if you script it Repo + devcontainer Sandbox filesystem
Fork a running machine Yes, 4.2s No, manual clone No New sandbox from a template
Typical restore p50 38s Depends on your scripts Container rebuild, minutes Re-provision from image
SSH + root Yes, default Yes Browser or CLI tunnel SDK-first
Agent sessions survive a restore Yes Only if you snapshot disk state No No
Keys stay on your disk Yes Yes Org secret store Env vars per sandbox
Export the disk qcow2 Raw disk No No
You maintain the snapshot tooling No Yes No No
Support Community; human add-on None GitHub issues Paid tiers

Scroll sideways to compare all four. The feature column stays put.

FAQ

Questions we get before signing up.

Why not just rent a Hetzner box and snapshot it?

You can, and it will cost less. A comparable CX-series server is €8.49–€16/mo depending on the size. You will write the snapshot script, test restores, handle qcow2 consistency, wire up session state, rotate SSH keys, and be on call when a restore corrupts Postgres. Unkindled is that work, priced at $39–$149. If your time is free, DIY wins. If you bill more than $39 an hour, it does not.

Do you train on my data?

No. We do not read your disk, we do not log terminal or agent traffic, and there is no model training anywhere in the product. We collect host metrics and billing counters. Support access requires a time-boxed grant from you.

What happens on restore, exactly?

The VM's disk is rolled back to the checkpoint's copy-on-write layer. Files, packages, Postgres data, Docker layers, and /home come back. Running processes do not; services restart and your SSH connection reconnects, usually in under a minute. Anything written after the checkpoint is gone. That is the point.

Can I export a workspace?

Yes. Download the disk as qcow2 from the dashboard while the VM is running, then boot it in QEMU, Proxmox, or another KVM host. There is no exit fee; the download counts toward your 1 TB of egress.

What happens when I hit the active-hour cap?

The workspace suspends. You can resume next cycle or upgrade mid-cycle and pay the prorated difference. There is no overage rate and no surprise invoice. Active means powered on, not SSH-connected, so a forgotten idle VM still counts toward the cap.

Is support included?

Docs and community are included on every plan. Human support is $39/month (email, one business day), included on Pro and Studio. Studio adds a 45-minute onboarding call and a priority queue. There is no 24/7 on-call; we are a small team and we say so. Support is the largest cost line in a business like this, so we price it instead of hiding it in a higher sticker price.

Hostinger sells Herdr hosting for $6.49. Why would I pay $39?

If all you need is a box with Herdr installed, buy theirs. It is a good deal, and we will not pretend otherwise. Unkindled is the layer above it: checkpoint the whole machine, fork a running workspace, and restore in under a minute when an agent breaks the OS, the database, or the toolchain. A $6.49 VPS does not include snapshot orchestration, restore testing, or someone to call when a rollback corrupts Postgres. You are paying for the undo button and the pager, not the CPU.