A Pipeline With No Agents Beat Every Agent Framework. It Cost 70 Cents a Task.

In 2024, four researchers at the University of Illinois Urbana-Champaign built a tool called Agentless to fix real GitHub issues. It has no agent in it. The model never decides its own next action, never plans, and gets no complex tools. It runs three fixed phases: find the code, propose a fix, validate the fix.

It scored 32.00% on SWE-bench Lite at an average of $0.70 per problem. Every open-source agent framework it was measured against scored lower: AutoCodeRover-v2 at 30.67%, RepoGraph at 29.67%, Moatless at 26.67%, SWE-agent at 23.00%. Then OpenAI evaluated it independently and adopted it as the approach behind their own SWE-bench numbers, which removes the usual objection that the authors graded their own homework.

The lesson most people took from this was “agents are overhyped.” That is the wrong lesson, and the right one is more useful.

Structure and agency are not the same purchase

Almost every conversation about agent architecture collapses two decisions into one. The first is how much structure to impose: fixed phases, schemas, validators. The second is how much agency to hand over: letting the model choose its own actions, spawn its own helpers, and decide when it is done.

The evidence on these two runs in opposite directions. Structure is worth more than most teams think. Agency is worth less, and costs far more. Agentless is what it looks like when you take all of the first and none of the second.

Gartner expects over 40% of agentic AI projects to be canceled by the end of 2027, citing cost and unclear business value, from a poll of more than 3,400 organizations. That is a forecast rather than a measurement. But the cost half of it is not in dispute, and the numbers come from the people selling the models.

The bill for autonomy, from the vendor’s own engineers

Anthropic published what its multi-agent research system actually consumes. An agent uses about 4x the tokens of a chat interaction. A multi-agent system uses about 15x.

The same post reports that their multi-agent setup beat single-agent Claude Opus 4 by 90.2% on research evaluations. Read one line further and the picture changes: token usage by itself explains 80% of the performance variance on their BrowseComp evaluation. Three factors explain 95% of it.

So a large share of what looks like an architecture win is a spending win. You can buy a good deal of that improvement by simply letting one model think longer.

Anthropic is direct about where the trade stops working. Multi-agent systems fail on tasks that need shared context, on work with heavy interdependencies, and on most coding. Their general engineering guidance is more restrictive than the industry behaves: “We recommend finding the simplest solution possible, and only increasing complexity when needed. This might mean not building agentic systems at all.” On frameworks, they warn that extra abstraction layers “obscure the underlying prompts and responses” and “make it tempting to add complexity when a simpler setup would suffice.”

The academic read agrees. A UC Berkeley team catalogued why multi-agent systems fail, building a taxonomy of 14 failure modes across three categories from 150 traces, backed by more than 1,600 annotated traces across seven frameworks. Their framing of the field: performance gains on popular benchmarks “are often minimal.”

The correction that keeps this honest

Cognition published a post called “Don’t Build Multi-Agents” and then walked it forward in April 2026. Their current position is not “never.” It is a sharper rule earned in production:

Multi-agent systems work best today when writes stay single-threaded and the additional agents contribute intelligence rather than actions.

Their working example is a review agent with clean context that catches about two bugs per pull request, 58% of them severe. The reason it works is fresh context, not parallelism. One thing writes. Everything else advises.

That is the most portable rule in this whole area. Extra agents are allowed to know things. They are not allowed to do things.

The part where the popular intuition is simply wrong

The common defense for skipping structure is Sutton’s bitter lesson: hand-built cleverness loses to general methods, so any scaffolding you write today gets eaten by the next model release. It is a good argument. Someone finally tested it.

A controlled comparison on the GAIA benchmark ran three scaffolds against five models, including Claude Opus 4.7, Gemini 3.1 Pro, and GPT-5.5, three attempts per question. The pre-registered hypothesis was that more capable models would be less scaffold-sensitive. That hypothesis was rejected. Scaffold choice alone moved measured accuracy by as much as 28 percentage points within a single model, and the most capable model tested gained the most from structured scaffolding on the harder problems. Structured scaffolds also made fewer tool calls, finished faster, and recovered from mid-run errors more often.

One caveat, stated because it matters: this is a single-author preprint from an independent researcher, not peer reviewed, and he names four confounds in his own data including provider-side errors and benchmark contamination risk. It is enough to retire the claim that scaffolding is about to become unnecessary. It is not enough to prove the reverse.

Tool count follows the same shape. Reported tool-selection accuracy holds at 84 to 95% with 50 available tools, falls to roughly 41% at 200, and approaches random past 700. Fewer, sharper tools beat a large menu, for the same reason a smaller action space beat a larger one in Agentless.

What this means on Monday

Take the structure. Skip the autonomy. Write the fixed path where you know the path. Reserve model-directed decisions for the places you genuinely cannot hardcode, and confirm the improvement before you keep it.

Keep writes single-threaded. If a second agent is in your design, it should be advising, not acting. The moment two things write, you are paying coordination costs and inheriting the failure modes Berkeley catalogued.

Price the run, not just the result. Before accepting that a multi-agent version is better, check whether it is better per dollar. If 80% of the variance is token spend, the honest comparison gives the simple version the same budget and sees what happens.

Cut the tool menu. Every tool definition eats context and adds a wrong turn the model can take.

The uncomfortable version of all this: a good number of teams shipping “agentic AI” in 2026 have built an expensive way to get a slightly worse answer. The fix is not a better framework. It is deleting the parts that were never carrying weight.