OpenHands, SWE-agent, Plandex — Autonomous Coding Agents

The autonomous-coding-agent dream: paste an issue URL, walk away, come back to a passing PR. OpenHands (formerly OpenDevin), SWE-agent, Plandex, Aider's autonomous mode, and Goose are the major FOSS attempts. With frontier APIs (Claude Sonnet 4.7 / Opus 4.7 / GPT-5) they are genuinely impressive on contained tasks; with local 30B–70B models they are unreliable enough that diff-based human-in-loop (Aider) usually beats them in practice.

Strategic context at agentic coding overview; coding model picks at coding models; for IDE-side options see Cline / Roo Code.

OpenHands

★ OpenHands (github.com/All-Hands-AI/OpenHands, MIT) — formerly OpenDevin.

• Sandboxed agent that plans, edits, runs tests, browses the web, iterates.
• Web UI + CLI; runs as Docker.
• LiteLLM-based provider router — works with Anthropic, OpenAI, Ollama, anything.
• Active research project (associated with University of Illinois researchers); SWE-Bench leader for FOSS.
• Honest framing: with Claude Sonnet 4.7 / GPT-5, can autonomously close some real GitHub issues. With local 30B, often gets stuck in tool-call loops.

SWE-agent

★ SWE-agent (github.com/SWE-agent/SWE-agent, MIT) — Princeton's autonomous coding agent, focused on SWE-Bench.

• Designed around an "Agent-Computer Interface" — text shell + structured commands.
• Strong on SWE-Bench scores; less polished UI than OpenHands.
• Research-flavoured; stable but oriented toward benchmarks more than developer ergonomics.

Plandex

★ Plandex (github.com/plandex-ai/plandex, MIT) — terminal-based agentic coding; commercial-friendly self-hosted; large-scale plans.

• Designed for "give me a multi-file plan and execute it."
• Cumulative diffs you review and approve.
• Self-hostable server; CLI client.
• Production-flavoured (creator runs a SaaS on top).

Goose

Goose (github.com/block/goose, Apache 2.0) — Block (Square)'s autonomous coding agent; CLI and desktop app.

• MCP-native — every tool is an MCP server.
• Recipe system for repeatable workflows.
• Local-friendly via Ollama.

Aider's --auto-test and architect mode

Aider is not strictly an autonomous agent, but with --test-cmd and architect mode it iterates on test failures until they pass. For many "make this pass tests" tasks, this is the more reliable path with local models than full autonomous agents.

What works in May 2026

• OpenHands + Claude Sonnet 4.7 on a contained issue with good test coverage — solid hit rate.
• OpenHands + GPT-5 — competitive.
• SWE-agent + frontier API — strong on benchmark-shaped problems.
• Plandex + frontier API — solid for multi-file refactors with human approval per diff.

What doesn't work as advertised

• Local 30B–70B + autonomous agent — unreliable. Tool calls drop, JSON malforms, the agent gets stuck. Some tasks succeed; many burn an hour and produce broken changes.
• "Walk away for an hour" workflows — even with frontier APIs, you should monitor; agents get into bad loops.
• Long-context refactors across huge codebases — local context limits + agent context bloat = failure.

Why diff-based (Aider) beats agentic for most local workflows

• Human-in-loop catches mistakes the model would compound.
• Diff format is forgiving — search/replace is a smaller surface area than "tool calls + file edits + shell commands."
• Speed comparable — at human-typing pace, you don't need 100 tok/s.
• Reliable. A 32B local model in Aider succeeds where the same model in OpenHands fails.

When autonomous makes sense

• Repetitive contained tasks with strong test coverage — "fix all linter warnings," "migrate from foo to bar."
• Frontier APIs available — OpenHands + Claude Sonnet 4.7 is a different beast than OpenHands + Qwen3-32B.
• You can monitor — autonomous-but-supervised, not autonomous-and-fire-and-forget.

Hardware reality

Autonomous agents fire many LLM calls. At 12 tok/s on a local 70B, a 30-step agent task takes 5–10 minutes per step = serious wall-clock time. Hyper-fast frontier APIs (~80–100 tok/s) make this tolerable; local doesn't, even at Tier 3+.

Pick this if…

• You have a frontier API budget and want to try autonomous coding: ★ OpenHands.
• You want benchmark-strong autonomous coding (SWE-Bench): SWE-agent.
• You want self-hosted multi-file planning: Plandex.
• You want MCP-native autonomous coding: Goose.
• You want autonomous-feeling but with diff review locally: Aider with --test-cmd.
• You want production-ready local autonomous coding: Honest answer — not really there yet for local models in May 2026. Use diff-based Aider or hybrid with frontier APIs.