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, Amp Code hosting, Cline hosting, Gemini CLI hosting, GitHub Copilot CLI hosting, and OpenHands hosting.
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.