Terminal-Bench in 2026: How Coding Agents Rank on Real CLI Tasks

If you have picked a coding agent in 2026 on a single benchmark number, there is a good chance that number was Terminal-Bench. It has quietly become the benchmark people quote when they argue about which agent to run, because it tests the thing most other coding benchmarks skip: whether an agent can sit at a terminal and finish an actual job. Not produce a patch that happens to pass a hidden test, but compile the project, train the model, configure the broken service, and leave the environment in a working state. The gap between those two things is exactly where agents fall over in production, so the benchmark that measures it is the one worth understanding.

Attribute	SWE-Bench Verified	Terminal-Bench 2.0
Unit of work	single patch against a repo	end to end task in a live shell
Environment	apply diff, run tests	persistent containerized terminal
What the agent does	edit files	issue commands, read output, iterate
Task domains	Python bug fixes	SWE, ML, security, sysadmin, data science
What the score rates	model on isolated edits	scaffold plus model on real workflows
Frontier 2026	mid 90s, compressed	high 80s to low 90s, more spread

The shape in that table is the point. Verified rates a model on a narrow slice of work and has largely saturated. Terminal-Bench rates a whole agent, harness included, on messier work, and it still separates the field.

What Terminal-Bench actually measures

Terminal-Bench is a set of hand crafted, human verified tasks that run inside a real shell. Each task ships four parts: a natural language instruction that states the objective, a containerized Docker environment that provides the execution context, a verification test suite that programmatically checks whether the task was completed, and an oracle solution that demonstrates one valid path. The domains span scientific computing, software engineering, machine learning, security, system administration, and data science, so a strong score means competence across several kinds of terminal work rather than one narrow skill.

The mechanism matters as much as the tasks. The agent operates as a ReAct style loop that issues tmux keystrokes into a persistent terminal session. It types a command, reads what comes back, and decides the next command from that output. There is no oracle feeding it the answer and no single edit that resolves the task. The agent has to plan, run, observe, recover from its own mistakes, and know when the job is done. That is a much closer match to how an engineer actually uses a coding agent than a benchmark that grades one diff, and it is why Terminal-Bench numbers track real world usefulness better than a Verified score does. We walk through the broader coding benchmark picture, including why the SWE-Bench family diverges, in our piece on why SWE-Bench Pro and Verified disagree.

The 2026 leaderboard, read carefully

On Terminal-Bench 2.0 the current top of the board looks like this: GPT-5.6 Sol leads at 91.9 percent, Claude Mythos 5 follows at 88.0 percent, and GPT-5.6 Terra sits at 87.4 percent. The public board is deep, with roughly 101 agents drawn from 23 distinct scaffolds including OpenHands, Codex CLI, Aider, and a long tail of custom harnesses. Those numbers are real and current, and you can read the full standings on the Artificial Analysis Terminal-Bench evaluation and the community tracked board at morphllm's coding agent leaderboard.

Here is the trap. A Terminal-Bench entry is a scaffold plus a model, not a model in isolation. The same underlying model can post very different scores depending on the harness that drives it: how it manages context, how it retries, how it parses terminal output, how aggressively it plans before acting. When you see one model at the top, you are seeing one good pairing of that model with a scaffold, not proof that the model beats every other model on every harness. This is the single most common misreading of the board, and it is why two teams running the same model can have completely different experiences. We tracked how this plays out across specific matchups in our comparison of GLM-5.3 and GPT-5.6 Sol on Terminal-Bench 3, where the scaffold accounts for a real chunk of the gap.

Why the scaffold moves the number

Think about what a terminal task demands beyond raw reasoning. The agent has to keep a long running session coherent, which means the harness has to decide what terminal history to keep in context and what to summarize away. It has to recover when a command fails, which means the harness has to detect failure from noisy output rather than a clean exit code. It has to avoid loops, which means some notion of progress tracking. None of that is the model exactly; it is the engineering around the model. A weaker model in a disciplined scaffold routinely beats a stronger model in a sloppy one on exactly these tasks.

That is good news if you build the harness, because it means you have a real advantage to work with. It is a warning if you are shopping for an off the shelf agent, because it means the vendor's headline Terminal-Bench number was earned by their scaffold on their tasks, and your results depend on how close your work is to that distribution. The number is a starting prior, not a guarantee.

How to use the score when you pick an agent

Treat Terminal-Bench as one input weighted for your actual work. If your team mostly does long horizon, multi step tasks in real repositories, Terminal-Bench is the most relevant public number you have, and you should lean on it more than a Verified score. If your team mostly does small, well scoped edits, a Verified style benchmark is closer to your reality and a two point Terminal-Bench difference is noise you should ignore.

Second, look at the scaffold, not just the model. If a vendor tops the board, find out what harness produced that score and whether you get the same harness or just the model. If you are running your own orchestration, the takeaway flips: invest in the harness, because that is where a large share of the score lives.

Third, run your own slice. The cheapest high value thing a team can do is assemble ten to twenty tasks that look like their real work, wrap them the way Terminal-Bench does with a container and a verification test, and score two or three candidate agents on them. A private benchmark that matches your distribution will predict your production experience far better than any public leaderboard, and it costs a day to build. We cover how the broader field has adopted this practice in our Terminal-Bench adoption landscape.

FAQ

Is Terminal-Bench the same as SWE-Bench? No. SWE-Bench grades a single patch applied to a repository and checked against tests. Terminal-Bench grades an agent completing an end to end task in a live shell, including compiling, configuring, and debugging. They measure different things, and an agent can rank well on one and poorly on the other.

Who leads Terminal-Bench 2.0 in 2026? As of this writing, GPT-5.6 Sol leads at 91.9 percent, with Claude Mythos 5 at 88.0 percent and GPT-5.6 Terra at 87.4 percent. The board updates as new agents and scaffolds are submitted, so treat any single ranking as a snapshot.

Does a high Terminal-Bench score mean the model is best for me? Not necessarily. Each entry is a scaffold plus a model. Your results depend on whether you get the same harness and whether your work matches the benchmark's task distribution. Use the score as a prior and validate on your own tasks.

Can I run Terminal-Bench myself? Yes. The tasks are containerized with verification suites, so you can run the public set or, more usefully, build a private set of tasks that mirror your real work and score candidate agents against it.

Why do scores move so much between scaffolds? Because terminal work stresses context management, failure recovery, and loop avoidance, which live in the harness rather than the model. A disciplined scaffold can lift a weaker model above a stronger one running on a careless harness.

When this applies to your stack

If you are choosing or building a coding agent, the practical lesson from Terminal-Bench is that the harness is not an afterthought, it is a large fraction of the result. A team that picks a top ranked model and drops it into a thin scaffold will underperform the leaderboard and then blame the model. The teams that get leaderboard grade results are the ones that treat context management, failure recovery, and verification as first order engineering, because that is where the terminal tasks are won or lost.

Designing that harness, and the private benchmark that tells you whether it works, is the kind of applied AI engineering we do for clients standing up agentic workflows. If you want help turning a promising model into an agent that actually finishes real terminal tasks in your environment, Contra Collective can build the scaffold, the evaluation set, and the review gates that make the number mean something for your team.