# Six CLI Coding Agents on microVMs, Compared

> How six terminal coding agents actually differ — runtime, install, auth, and which support headless fleet dispatch. Picked from the adapters that install them.

- Published: 2026-07-20 · Updated: 2026-07-20 · jurniti
- Canonical: https://www.jurniti.com/blog/cli-coding-agents-on-microvms

Six of the agent runtimes jurniti hosts are terminal-first coding agents:
Aider, Amp, Cline, Gemini CLI, GitHub Copilot CLI, and OpenHands. They
look interchangeable in a feature list, and most comparisons of them are
interchangeable too.

They are not actually that similar underneath. Here is what differs,
taken from the adapters that install them rather than from anyone's
landing page.

## What actually differs

| Agent | Runtime | Auth shape | `jurniti run` fan-out |
| --- | --- | --- | --- |
| **Aider** | Python 3.12 via `uv`, version-pinned | Provider key in the env (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`) | No |
| **Amp** | Standalone installer (Sourcegraph) | Sign in to an ampcode.com account | No |
| **Cline** | Node via `nvm`, version-pinned | `cline auth` — interactive sign-in | No |
| **Gemini CLI** | Node via `nvm`, version-pinned | Google login **or** `GEMINI_API_KEY` | No |
| **Copilot CLI** | Node via `nvm`, version-pinned | GitHub account sign-in | No |
| **OpenHands** | Standalone installer | `LLM_API_KEY` + `LLM_MODEL` in the env | No |

Three things fall out of that table that a feature list would hide.

**The runtime split is the real fork.** Three of the six are Node
packages that need `nvm` on the box, one is a Python tool that wants
`uv`, and two ship their own installer. That is invisible until you try
to run two of them side by side on one machine and discover you are
maintaining two language toolchains for two agents. One microVM per
agent makes the question disappear — which is the actual argument for
per-agent isolation, more than the security story people usually lead
with.

**The auth shape splits them, and not where you'd guess.** Aider and
OpenHands take a provider key you export in the shell — BYOK in the
plain sense, working the moment the key is in the environment. Amp,
Cline, and Copilot CLI want an interactive sign-in to *their* service
from inside the box. Gemini CLI does either: Google login, or a
`GEMINI_API_KEY` if you'd rather not log in.

That distinction matters more on a remote VM than on your laptop. A
sign-in agent needs a real terminal to complete its login flow — which
is fine here, since every box ships one, but it does mean the setup is
"open the terminal and authenticate," not "paste one env var and go."

**None of the six support `jurniti run` fan-out.** Several can run a
single task headlessly on their own — OpenHands ships a headless task
mode, for instance. What they don't expose is the headless run script
jurniti needs to dispatch *one brief across a whole group of workers*,
and today only Claude Code, Codex, Hermes, and OpenClaw do. You can boot
fifty microVMs running Aider; you cannot hand all fifty the same brief
with one command. If fan-out is the point, pick from those four instead
— worth knowing before you buy, not after.

## Where a microVM earns its keep

All six share one property: they execute shell commands the model chose.
That is the whole value and the whole risk — and it is not hypothetical.
The widely-reported October 2025 case involved Claude Code (not one of
the six): asked to rebuild a project, it ran `rm -rf` starting from `/`
and wiped every user-owned file on the machine. Nothing about these six
makes them structurally safer; they run the same kind of commands.

The usual mitigations are weaker than they sound. A container shares a
kernel with its neighbours. A laptop hands the agent your SSH keys,
browser sessions, and everything else in your home directory. Sandboxing
*inside* the same machine still leaves the machine.

A Firecracker microVM is a different boundary: its own kernel, a KVM
hardware line, one tenant per box. A destructive command stays inside a
machine you can rebuild in about 124ms of boot time. And because the box
is always on, a long refactor keeps running when you shut your laptop —
which, in practice, is why most people move an agent off their desk in
the first place.

## Picking one

Skip the feature grid; decide on two questions.

*Do you want a pair programmer or an autonomous worker?* Aider is
explicitly a pair programmer — it edits, commits to git, and hands
control back. OpenHands leans autonomous: give it a task and it plans
multi-step work. Cline and Amp sit between. Copilot CLI and Gemini CLI
are closest to "a good shell assistant that can edit files."

*Whose account do you already have?* This decides more than it should.
If your code is on GitHub, Copilot CLI's auth is already solved. If
you're on Google's models, Gemini CLI takes the key you have. If you
want to stay provider-agnostic and pay per token to whoever is cheapest
this month, Aider and OpenHands are the honest picks — they're the two
that read a plain provider key out of the environment and never ask you
to hold an account with the agent's vendor.

Each has its own page with the specifics: [Aider hosting](/aider),
[Amp Code hosting](/amp), [Cline hosting](/cline),
[Gemini CLI hosting](/gemini-cli),
[GitHub Copilot CLI hosting](/copilot), and
[OpenHands hosting](/openhands).

## Running one

Every plan is a real microVM with a persistent home directory, an
in-browser terminal, and BYOK for whatever provider the agent supports.
Starter is $25/mo — 1 vCPU and 2 GiB, which is enough for all six, since
a terminal coding agent spends its time waiting on the model, not on
local compute. Annual is $250 and includes two months free. Every plan
carries a 30-day money-back guarantee on your first purchase.

Pick the agent, pay, and the box boots with it already installed — no
setup call, no human in the loop. Paste your key in the terminal and
it's working a couple of minutes later.

If you'd rather compare the isolation model itself, that's
[microVMs vs Docker for AI agents](/blog/microvm-vs-docker-agent-hosting).

## Frequently asked questions

### Which CLI coding agent should I pick?

If you want git-native, minimal, and Python-based: Aider. If you already live in GitHub: Copilot CLI. If you want Google's models first-class: Gemini CLI. If you want an autonomous agent that plans multi-step work rather than pairing: OpenHands. Cline and Amp sit between — editor-adjacent agents that also work as plain terminal CLIs. The honest answer is that they overlap heavily, so pick on runtime and auth (below), not on marketing.

### Can I dispatch one prompt to a fleet of these agents at once?

Not for these six. Some can run a single task headlessly on their own, but `jurniti run` fan-out needs the harness to expose a headless run script, and today only Claude Code, Codex, Hermes, and OpenClaw do. You can run many microVMs here, but you drive each one yourself. This is a real limitation, not a roadmap tease.

### Do these need my own API key?

Yes — jurniti is BYOK for all of them, and the key never leaves your microVM. The auth SHAPE differs though: Aider and OpenHands take a provider API key in the environment, while Amp, Cline, and Copilot CLI want you to sign in to their own account from inside the VM. Gemini CLI does either.

### Why a microVM instead of Docker for a coding agent?

Every one of these runs real shell commands the model chose. A shared-kernel container puts your neighbour's kernel bugs in your blast radius; a laptop puts your SSH keys and browser sessions in the agent's reach. A Firecracker microVM is one tenant per box with a KVM hardware boundary — the same primitive AWS uses for Lambda.

### What does it cost?

All six run on Starter — $25/mo, or $250/year with two months free — and every plan carries a 30-day money-back guarantee on first purchase. Model spend is billed by your provider directly and never marked up.