The coding-agent ecosystem

The most mature, most battle-tested agentic systems in the world in 2026 are coding agents. They run millions of times a day against real repositories, they are measured on a public benchmark, and their builders have solved the hard problems of long-horizon tool use, context management, and verification before most other domains got there. So the book closes its survey where the state of the art actually lives: not to teach you to build another Cursor, but because studying how coding agents are built is the best available lesson in what a serious agent platform requires, and every lesson maps to a plane you already have.

The landscape

Coding agents span a spectrum from in-editor assistant to autonomous software engineer:

  • Claude Code (Anthropic) is the deepest programmable harness: a terminal agent with skills, subagents, hooks, and MCP, and it is packaged as the Claude Agent SDK so you can build on the same loop. It is the reference for "agent as a scriptable platform."
  • Cursor is the strongest in-editor agent, an IDE where the agent is a first-class collaborator with the codebase indexed and in view.
  • Devin (Cognition) is the most autonomous end: a cloud software engineer you assign a task and check on later, the async-worker shape.
  • OpenHands (formerly OpenDevin) is the leading open-source autonomous agent, Docker-based, and the one to read when you want the full source of a working autonomous coder.
  • Aider is the git-native terminal pair-programmer, minimal and transparent, every change a commit.
  • SWE-agent (Princeton) is the research agent that pioneered the agent-computer interface (designing the tools an agent uses to navigate and edit code) and anchors the benchmark work below.
  • Google Jules and GitHub Copilot's agent mode are the hyperscaler entries, async cloud agents that open pull requests.

The spread across that spectrum is itself the lesson: the same underlying capability (an agent editing code) supports products from a tab-complete-plus to an autonomous engineer, and the difference is almost entirely how much autonomy and what guardrails, which is a production-bar question, not a model question.

SWE-bench: the benchmark that disciplined the field

Coding agents have something most agent domains lack: a hard, public, end-to-end benchmark. SWE-bench presents real GitHub issues from real repositories and asks the agent to produce a patch that makes the project's tests pass, and its curated SWE-bench Verified subset is the number the frontier competes on. Two things make it the most important artifact in the ecosystem for a platform builder:

  • It measures the trajectory, not a single answer. Resolving an issue means navigating a codebase, editing multiple files, and running tests, exactly the multi-step, verifiable-outcome work this book's evals target. SWE-bench is a golden task set with a mechanical grader (the tests pass or they do not), the ideal every eval suite aspires to.
  • It made the field improve honestly. A benchmark you cannot game (the tests are the truth) turned "our agent feels good" into a number that goes up, which is the eval discipline working at ecosystem scale. When a domain has a SWE-bench, progress is real; when it does not, you build your own, which is what Capstone A's planted-bug corpus was.

What coding agents teach the platform builder

Study how these systems are built and the same lessons recur, each one a plane this book already constructed, which is the closing argument for the whole architecture:

  • The tool surface is the product. SWE-agent's key insight was that the agent-computer interface, the exact tools an agent has for reading, searching, and editing code, matters more than the model. This is Chapter 8's "tools are the contract," proven at scale: coding agents live or die on tool design.
  • Context management is survival. A coding agent works a large repository through a bounded context window, so it must retrieve, summarize, and forget aggressively, exactly the memory and retrieval disciplines of Part 7. The best coding agents are the best at deciding what to look at.
  • Verification is built in. Every strong coding agent runs the tests before claiming success, which is the verification mesh in its most concrete form: the tests are the adversarial check, and an agent that skips them ships the 53%-precision report Capstone A warned against.
  • Autonomy is gated by reversibility. The spectrum from Aider (every change a reviewable commit) to Devin (autonomous, then you review the PR) is the approval-gate axis: the more autonomous the agent, the more the review of its output becomes the gate. A PR is a gate; a commit is a checkpoint; the coding agents made Chapter 38's "prefer the workflow as the gate" a product design.
  • The sandbox is non-negotiable. OpenHands runs in Docker, Devin in a cloud VM, because a coding agent runs code, and running the agent's code is running untrusted code. Every serious coding agent has a Part 5 answer.

Read that list and it is this book's table of contents, discovered independently by the teams under the most pressure to get agents right. That convergence is the strongest evidence the reference architecture is not one opinion among many but the shape the problem forces.

Part 13, and the survey, closed

Part 13 mapped the fast-moving ecosystem against the platform the book built: the framework landscape reduced to three idioms over one loop; durable execution placed on the runtime spectrum; the protocol landscape organized by boundary; the supporting platforms sorted by which plane they serve; the modalities shown as new I/O on the same planes; and coding agents revealed as the architecture, discovered under pressure. The survey's single message: the ecosystem is large and churning, and it is all configurations of the same platform. Frameworks package the loop's idioms, durable engines and runtimes host it, protocols connect its boundaries, platforms observe and evaluate it, modalities change its I/O, and the best applied systems in the world are built from exactly the planes this book constructed from scratch. Pick your tools from the survey; build the platform from the book.

Don't be confused: using a coding agent vs building an agent platform. They are adjacent and distinct. Using Claude Code or Cursor makes you a more productive engineer, including at building this book's platform, and you should. Building an agent platform is the subject of this book: the budgets, isolation, verification, and scheduling that let any agent, coding or otherwise, run safely at scale. A coding agent is one excellent application on a platform like Hive; studying it teaches platform design, but adopting it is not the same as having built one. The book taught the second, using the first all the way through.

👉 The glossary and references close the book. The platform is built; the ecosystem is mapped; the rest is your repository.