The Best Open Agent Harnesses

The 15 harnesses, one by one

One verdict each, grounded in the row's own repo or docs. Mini-reviews, not rankings: the right pick depends on your constraint, which is what the short list above is for.

OpenCode

The default open pick for most builders: one tool across terminal, desktop and web with dozens of providers, so a pricing change never strands you. It installs with one shell command and drives dozens of providers through Models.dev, with LSP support and parallel sessions. The tradeoff for that breadth is surface area: more providers, more config, more to learn than a single-purpose loop. Read the OpenCode deep-dive.

Pi

The minimalist: the smallest starting context on this page with an extension API, in exchange for owning sandboxing and permissions yourself. It ships with strong defaults but deliberately skips subagents and plan mode, and it carries no permission system: sandboxing is yours to arrange via containers. That honesty is the appeal. When a tool call fails there is almost nowhere for the fault to hide, which makes Pi the easiest harness on this page to debug.Pi's official site.

oh-my-pi

Pi with batteries included: per-task model roles, LSP-aware edits and subagents for a daily local driver. It adds hash-anchored edits, persistent Python and Bun kernels that can call back into the agent's own tools, and model roles routable per task across frontier APIs, coding plans and local runtimes. The cost is complexity: this is the heaviest Pi descendant here. oh-my-pi on GitHub.

DeepSeek Harness

A plugin kernel where even the loop is swappable, plus an append-only session log you can resume, fork and replay. Developer preview, so expect breaking changes. Standard, code, minimal and creator modes cover day-to-day agent work down to a two-tool baseline, and one command serves the web UI locally. Remember the meter behind it: the free download arrived days before a repricing aimed squarely at cached agent context. Read the DeepSeek Harness deep-dive.

Hermes Agent

The memory-first general agent: it learns across sessions and runs anywhere from a VPS to chat gateways, with local backends supported. It refuses models under 64K context at startup, which tells you what it thinks of small windows. Local inference runs through Ollama, vLLM, SGLang, llama.cpp and LM Studio with the right server flags. Read the Hermes Agent deep-dive.

ZCode

Z.ai's official GLM harness: define a goal and it plans, executes and verifies, controllable from desktop, phone or bot channel. Locked to GLM. Goal Mode with up to a million tokens of context suits long-horizon tasks you kick off from a phone. The price is lock-in: this is the only row here that is not model-agnostic, and the subscription is the product.Read the agentic editors roundup.

Kilo Code

One open core across VS Code, JetBrains and CLI with snapshots shared between them; the editor-native migration path. It serves 500-plus models with zero markup on bring-your-own keys, and a sandbox mode confines what auto-approved tools can touch. The same config follows you between editor and terminal, which is the whole pitch.Kilo Code on GitHub.

Cline

Plan mode before Act mode with approval at every step; the choice when control and auditability outrank speed. Plan mode explores and asks before Act mode executes, every edit and command needs approval unless you switch on auto-approve, and checkpoints make the agent's work undoable. That governance is why regulated teams tolerate it.Cline on GitHub.

Hax

A single C binary that starts instantly and leaves RAM for the model, with llama.cpp first-class. Deliberately no plugins or permission prompts. A transcript view shows exactly what was sent to the model and what came back, with an optional wire-protocol trace for deep debugging. If you want marketplaces, plugins or per-command permission prompts, look elsewhere on purpose.Hax's official site.

OctoMind

Built for long sessions: adaptive compression, duplicate tool-call detection and a supervisor gate on done. Maintainer-described; thinnest independent verification. On short tasks none of that machinery matters, which its own maintainer admits. Evaluate it on your longest sessions or not at all.OctoMind on GitHub.

little-coder

A Pi-based fork with pipelined subagents for planning and review, plus fixes for compaction resume failures. Community build; confirm at the repo. The approach borrows a real research result: small models given small codebase slices perform near frontier level, so fanning work out to scoped subagents is principled, not decorative.little-coder on GitHub.

Nitro

A community webapp for driving models across home machines. The least verified row here; treat the repo as the source of truth. It exists because choosing across models, cards and machines got complicated enough to build tooling around, which is an honest origin story for a harness. Nitro on GitHub.

Aider

Pair programming in the terminal: a repo map for large codebases, git auto-commit and a lint and test loop after every change. It maps the whole repo so edits land with full-project context, speaks over 100 languages, and even bridges to web-chat models via copy-paste. The loop assumes you are present: this is the craftsman's pick, not the walk-away pick. Aider on GitHub.

OpenHands

A self-hosted control center for coding agents and scheduled automations, bring your own model, Docker sandboxing available. Agent Canvas switches local, Docker, VM and cloud backends from one frontend, and automations on schedules or webhooks turn agents into cron jobs. Heavier than a terminal loop by design: this is team infrastructure.OpenHands on GitHub.

Goose

Desktop app, CLI and API from one Rust core with 70+ MCP extensions; general-purpose beyond code, now under the Linux Foundation. Fifteen-plus providers including Ollama, subscription routing via ACP, and a recipe system for repeatable runs. If the job is not code at all, start here. Goose on GitHub.

The model is not the harness

The most common mistake in choosing one of these tools is shopping for a model when the thing you actually run is a loop. The model reasons; the harness decides what that reasoning can touch, what it remembers, and whether the output survives. Identical open weights swing double digits on coding benchmarks purely on the scaffold around them, aswhy local LLMs fail at agentic coding documents, and the same lesson anchorsthe 2026 agent landscape. That is why this page compares failure behavior instead of benchmark scores: on a clean task every row above works, and they diverge on what happens when something goes wrong.

Aider vs OpenCode vs Pi: the terminal trio

Three different philosophies sharing one terminal. Aider pair-programs: you direct, it edits, lints, tests and commits, and the repo map keeps big codebases legible. OpenCode agents: you delegate, it plans, acts and compacts across dozens of providers. Pi knowingly does less than both: no subagents, no plan mode, no permission system, just a clean loop with hooks. Working inside code you know favors Aider; handing over whole tasks favors OpenCode; constrained machines and long lean sessions favor Pi.

Open-source Claude Code alternatives

Nobody on this page clones Claude Code feature for feature, and that framing misleads. What the open rows offer instead is ownership of a different layer each: OpenCode owns provider choice, Pi owns loop simplicity, Cline owns approval governance, OpenHands owns team infrastructure, Aider owns the edit discipline. Developers who leave Claude Code usually leave over one of those five, so name the layer before picking the replacement. The commercial side of the comparison, including where Claude Code still leads, lives on theAI coding agents comparison.

Three failure shapes to ask about

First, what it does when the context fills, since naive truncation drops your decisions and keeps the chatter. Second, what it does when a tool call fails, since re-running the identical call is the most expensive loop an agent can enter. Third, what it does when the model announces it is finished, because most harnesses simply believe it. The compaction column above answers the first; the deeper techniques behind all three, from ratchet rules to evaluator splits, are inventoried inharness engineering in 2026, and the build-versus-adopt decision around them inbuild your own harness or adopt.

The local-model note

Most rows here drive local runtimes (llama.cpp, Ollama, vLLM, LM Studio), which removes the per-token meter and keeps code on your machine. The capability is real: a 27B open-weight model now scores in the high 70s on SWE-bench Verified. The catch is that a benchmark score does not survive contact with feature-shaped work, and the harness carries more of the result than the weights do. Before committing hardware, readwhy local LLMs fail at agentic coding for the failure modes,local LLM tokenomics for whether the box pays for itself, and run your card through theCan I Run This LLM checker.

How to choose by workload

Match the tool to the shape of the work. If the box is small or the sessions are long, Pi, Hax or oh-my-pi keep the loop lean. If providers keep changing under you, OpenCode, Kilo Code or Cline let you switch without relearning. If the run is long and unattended, DeepSeek Harness with its replayable session log, or OctoMind with its supervisor gate, is built for exactly that. If the agent should remember you between sessions, Hermes Agent is the memory-first pick. If the work is surgical edits to known code, Aider's commit-and-revert discipline fits. And if cost per finished task is the constraint, model the task math with thecost-per-task calculator before committing, because the cheapest per-token model is often not the cheapest to finish the job.