Better Models Multiply Agent Output, but Human Attention Remains the Limit
Armin Ronacher, whose coding agent Pi has changed little in a year, says improved models have made it capable of far more: tasks that once ran for about two and a half minutes now can run for 14 minutes, with fewer corrections from him. But the added capacity does not remove the bottleneck of human attention. Ronacher argues that teams should first build a workshop—developing the judgment to make and maintain excellent software—before building a factory to increase output.

Better models have made the same harness more capable
? armin-ronacher argues that teams should learn to use agents to make better software before trying to build systems that produce more software at scale. His distinction is between the workshop, where people develop the judgment and practices needed to make excellent work, and the factory, which increases output. The practical consequence is that more agent capacity does not by itself make a project worth starting: someone still has to judge the result and decide whether to maintain it.
His evidence starts with Earendil’s coding agent, Pi. Ronacher says its core harness—the tools and basic structure through which the model works—has not meaningfully changed in a year. Yet he finds himself able to do much more with it, largely because the models have improved. Earlier prompting techniques and harness tricks have become less necessary. One example is Pi auto research, a plugin he once valued for directing an agent toward a goal such as improving performance. With current state-of-the-art models, he says, the plugin is no longer needed.
Ronacher analyzed his own Pi sessions, filtering for the default tool set. As models improved, he says, he had to correct the agent less often and abort it less often. In his chart, corrections per 100 prompts fall from 8.8 with GPT-5.3 Codex to 1.0 with Opus 5.5; aborts fall from 13.1 to 7.2. He presents these as measures of how often he now has to step in—not as a change he achieved by rebuilding the harness.
| Model | Minutes of agent work per prompt | Tool calls per prompt |
|---|---|---|
| Opus 4.6 | 2.4 | 19 |
| GPT-5.3 Codex | 5.6 | 28 |
| GPT-5.5 | 5.0 | 37 |
| GPT-5.6 | 12 | 54 |
| Opus 5.5 | 14 | 64 |
The more consequential change, in his view, is how long a task can run before the agent finishes. He says the 90th-percentile run time for a task with Opus 4.6 in December was about two and a half minutes; with newer models, it reaches 14 minutes or more. He also observes models using the available tools differently, including more use of Bash, despite no change to how Pi is configured. A stable harness, then, does not mean stable behavior: better models change what the same tools can do and how they are used.
Output is scaling faster than human attention
Ronacher’s prompt volume has remained roughly flat: he describes sending between about 120 and 190 prompts a day across the months he examined. But the time agents are active on his behalf has grown from less than a working day to many times one. His chart shows parallel agent-hours rising to 43.7 hours per day in the first eight days of November, while his prompt count stays within its earlier range.
Starting projects has also become easy. Keeping them alive has not.
Ronacher says the 141 projects were Git repositories he started over the year. The 10 to 15 were projects he worked on at a regular cadence—committing for more than five days and returning to them. He says an informal survey of friends suggested this was a common pattern: people can initiate much more work, but sustained attention remains scarce.
One friend had automated an open-source project so incoming issues could be reviewed and handled by an agent. The automation worked, but the friend eventually turned it off. He cared less about the project and wanted to use the tokens elsewhere. For Ronacher, that example shows why removing a human from the immediate workflow does not remove the human’s role. Attention and interest still determine whether a project is worth maintaining.
The same scaling pressure reaches beyond a person’s own repositories. Ronacher notes that more agent-generated activity is being pushed to services such as GitHub, npm, and third-party websites that may not be ready for the volume. The ability to start work cheaply can increase demands on systems that were not built around that pattern. More activity is not automatically more useful activity; it can also impose load on shared infrastructure.
The agent can finish the task without making the right software
Ronacher identifies three requirements for using agents well in a workshop: knowing when to tell an agent “not like this,” distinguishing true skill from agent skill, and keeping the pace of work within one’s own understanding.
The first is a matter of judgment. An agent is rewarded for completing a goal, and completion is relatively easy to observe. But a result can satisfy the immediate request without being something the user will be glad to maintain. As commits accumulate and systems grow, Ronacher warns, software can become a “Simpson car” of features: a collection of additions that does not fit together. Avoiding that outcome requires working alongside the agent and pushing back on the direction of its work, not only checking whether it reached the stated goal.
He calls the difference between an experienced engineer and a less experienced user “true skill versus agent skill.” Both may prompt the same system, but they do not necessarily get the same quality of result. Ronacher points to a project he is doing with his son, who sends him pull requests. The difference in their contributions is clear to him because his son is not a software engineer, even though they use the same prompting system.
That distinction becomes especially important when people use an agent to answer questions about a system they do not understand. Ronacher says he finds it frustrating when a group relies on an agent without understanding either how the system works or the underlying problem. He is not arguing that people must inspect every line of generated code. He is arguing that they need enough understanding to judge what the system is doing and whether the result is sound.
As his own commits increased, Ronacher looked for a way to keep that judgment in the loop without reading every change as it happened. He began asking the agent to produce a short, well-formatted executive summary in HTML before moving to verification—roughly 70 percent of the way through a typical task. The summary gives him a way to understand the work as it nears completion, particularly as newer models produce text he finds easier to read. In many cases, he says, he is no longer reading the code itself. The summary is a way to moderate the pace so that agent activity does not outrun his ability to evaluate it.
Local implementation can weaken shared conventions
Ronacher is sympathetic to writing more code and relying on fewer dependencies. Agents make that approach more feasible: a developer can ask an agent to implement functionality rather than bring in another package. But he cautions against treating every problem as an invitation to create a new, local solution.
He uses the German word Wildwuchs—uncontrolled growth—to describe what can happen when independently built software is expected to work together. As an example, he mentions a blog post about a tar archive crafted so that different implementations interpret it differently. His broader concern is that agents can readily implement formats and protocols, but implementations may diverge in subtle ways. For shared systems, it matters that people agree on specifications and on how those specifications should be read.
Ronacher imagines a future in which everyone has a personal Photoshop clone but can no longer exchange files because the software has diverged too far. The obstacle to shared formats is not always technical; it can be the work of agreeing on what belongs in the format and how it should be interpreted. Open protocols and common file formats preserve interoperability, but reaching agreement still takes human collaboration.
That collaboration may be easier to avoid when an agent can produce a fork immediately. Ronacher, drawing on his open-source background, says he is struck by how little human collaboration he sees in open-source projects and how many projects end up with large numbers of forks. Forking can be easier than getting a change upstream, but the ease of producing a separate implementation does not solve the problem of working together. Sometimes the right response is to pause before asking an agent to solve a problem and ask whether it is one that should be addressed with other people.
Use the new capacity to raise the bar
Ronacher’s case for a workshop over a factory is not a case for doing less with agents. It is a case for directing their capacity toward software that is more carefully made. He singles out three goals: more verified software, faster software, and more software written in memory-safe languages.
He recognizes that verification is difficult and that the technology stack is not yet where it needs to be. Still, he sees it as worth pursuing as a path toward more stable software. He also welcomes efforts to build faster, more memory-efficient programs. He has long been frustrated that RAM is spent on software he does not consider worthwhile, and sees value in people rebuilding tools in native languages rather than making another Electron wrapper.
Memory safety is another area where he sees agents changing what developers will attempt. Ronacher likes Rust and the wider move toward memory-safe software. He says better models finding security issues have strengthened the argument for safer approaches, and that people who might not previously have chosen Rust are now willing to try it because it can deliver value that feels, in his phrase, almost free.
The new capacity matters most when it helps developers attempt work they value—verification, speed, and memory safety—not simply when it makes another implementation easy to produce.
Long-running work needs durable execution
Ronacher sees room for harnesses to evolve, particularly as agents work on tasks that outlast both a process and the person supervising it. When a task takes two minutes, it is manageable to babysit it, restart it if it fails, or manually tell it to continue. That approach is less practical if agents are working through thousands of issues overnight.
He describes durable agents as systems that can start, stop, suspend, and resume their work—including workflows that orchestrate other agents. Durability is also a resource issue. Inference costs money, compute is constrained, and some scheduling options may pause token generation for minutes at a time. In that situation, it may make sense to suspend the agent and its sandbox rather than keep other resources occupied while it waits.
The aim is not merely to let a task run longer. It is to schedule inference and compute more intelligently, and to make waiting durable. Human responses may arrive hours after an agent asks a question; a workflow built for long-running work has to survive that gap.
Code mode moves orchestration out of the context
A second possible harness development is what Ronacher calls code mode: letting an agent compose and run tool calls through code, rather than routing every action through the harness’s individual tools and the model’s context. Bash already allows programs to be composed, he says. Code mode extends that idea with loops and concurrency that can run without repeatedly passing through the context.
This becomes useful as agents begin to orchestrate sub-agents and use models that are not conventional language models, such as decision or classifier models. Ronacher describes an approach associated with Cloudflare: instead of placing thousands of tools into the context, give the agent JavaScript alongside Bash and let it invoke and coordinate tool calls through JavaScript. He says this has shifted from curiosity to something “shockingly useful.”
In this design, the harness can carry out large groups of tool calls without sending every step through the model’s context. Ronacher says this is already possible in Codex, Pi, and other harnesses, though using it requires rethinking how workflows are built. He also sees code mode as a way to use fast, inexpensive classifier models for decisions that would otherwise be too slow or costly.
His example is a queue of 3,000 customer-support requests. A workflow could assess each request and decide whether to send it to an agent, ask the customer for more information, or take another path. The decision model returns choices or scores rather than prose; the workflow calls it at each decision point. That makes it possible, he says, to process thousands of issues quickly, where handling them one by one would have taken hours.