In early 2026, I wrote that we were witnessing a revolution in software development. Coding agents had finally become good enough for mass adoption across entire engineering organisations, beyond the early adopters. More recently, in my Agentic Coding Update, I suggested we might be seeing another shift. Agents were no longer only reliable executors of well-defined tasks. They were starting to show signs of strategic reasoning, helping to work out what to do as well as how to do it. Now another part of the equation is shifting: economics.
Recent model releases make it clear that competition is no longer only about raw intelligence. Providers are increasingly competing on how much useful work you can get per pound or per dollar. That matters, because for many teams the bills have been a real, practical concern.
At the same time, agents are no longer just about writing code. With access to CLIs, APIs, MCP connectors, browsers and increasingly full computer use, they can take tasks much closer to completion end to end. Put cheaper intelligence and better tooling together, and a different mode of work starts to make sense. Instead of pair-programming side by side with an agent, we're moving towards delegating tasks asynchronously. We can hand off work and return later instead of supervising every step. This post is another entry in my agentic coding journal. It captures where I think things stand today, what already works better than expected, and where the narrative still runs ahead of reality.
Changing economy
One of the most interesting shifts over the past few months has very little to do with another leap in intelligence, and much more to do with economics. For years, the pattern was simple: better models usually meant higher prices. That was fine when AI was something you asked for help once in a while, but it becomes a real constraint once you start running agents seriously. They read large codebases, call tools, retry, and keep context for hours.
Claude Opus 5.5 is a good example of how that is starting to change. Opus 5 was priced at 5 dollars per million input tokens and 25 per million output tokens. Opus 5.5 brought that down to 4 and 20 respectively, with cache reads reduced by 60 percent. Anthropic itself estimates a typical Opus 5.5 workload is around 40 percent cheaper than Opus 5, while being positioned as roughly Fable 5.1 level on most tasks, and Fable is priced at 10 and 50. So, capabilities that were only recently top of the line are now available at a noticeably lower cost.
OpenAI appears to be moving in the same direction. GPT-6 Sol launched at 2 dollars per million input tokens and 10 per million output tokens, While GPT-5.6 Sol was priced at 4 and 20. That's effectively a 50 percent reduction between generations for a model that is described as bringing much of the GPT-6 family's capability to coding and agentic workflows. To put it in slightly more tangible terms, a workload with 10 million input and 2 million output tokens drops from around 80 dollars to around 40. That doesn't sound dramatic when you run one agent once, but it changes the equation entirely when you run several agents continuously.
Luna makes the trend even clearer. GPT-6 Luna is priced at 10 cents per million input tokens and 50 cents per million output tokens, compared with 20 and 1.20 previously. At that level, we are no longer talking about shaving a bit off the top. We're entering a price range that was until recently the big advantage of Chinese models. DeepSeek V4.1 Flash, for example, currently lists 30 cents and 1.20 dollars during peak hours, and 15 cents and 60 cents off-peak. DeepSeek is still extremely aggressive on things like cache-hit pricing, so the comparison is not one-to-one, but the big picture is inexpensive models from Chinese providers no longer look like outliers on cost alone.
None of this means that these models are interchangeable. Intelligence is not a single number, and neither is the cost of running an agent. Reliability, context, tooling, latency, failed attempts, human oversight, all of that shapes the real cost of getting work done. That's why I think token price in isolation is becoming less interesting. What matters more is something closer to useful intelligence per dollar, or even finished work per dollar. And that feels like a real shift. From a race for the smartest model at any cost to a race for how much intelligence can be delivered cheaply enough to use freely. For agentic coding, that may matter more than another few percentage points on a benchmark. The interesting question is less can an agent do this task, and more is it cheap enough that I can give it ten of these tasks, in parallel, without thinking twice. That might turn out to be one of the foundations for the next phase of agentic development.
Computer use closes the tooling gap
In my previous post about computer use, I argued that one of the key gaps between coding agents and human developers was beginning to close. Humans don't rely on a single interface. We use APIs and CLIs when they exist, but we also fall back to browsers and desktop apps when there's no clean programmatic path. Agents were quite strong inside the terminal, but sooner or later, they hit a boundary and handed control back to a human. MCP, CLI, APIs, browser use and computer use together change that. Even when there is no nice connector, an agent can increasingly take the same route a human would. Maybe not always as elegantly, but enough to get the job done end to end.
That last step matters in practice. When a human has no dedicated integration, they open a browser, copy or enter data, change a setting, or switch to a desktop application. The agent increasingly has those same options. A missing connector no longer necessarily means a person must finish the configuration after the agent has written the code. This is the part of the tool gap that computer use fills.
MCP, APIs, CLIs remain cleaner and faster where they exist, but computer use is a fallback that looks a lot like what a human does. It doesn't have to be perfect. It just has to be good enough to cover the long tail. Once you combine all of that, the agent's practical surface starts resembling yours. That's the enabling layer, and once it's good enough, another change becomes viable.
Asynchronous autonomous work
For a long time, even when the agent was doing most of the typing, my interaction with it was still basically pair programming. I watched, I approved commands, I corrected, I waited. It was synchronous. That is starting to change. Remote environments, more capable and cheaper models, and permission systems like auto mode mean you can often hand off a well-framed task, let it run in the background, perhaps alongside several others, and come back to a result. In auto mode, a classifier reviews eligible actions instead of interrupting me for every approval. It does not make every action safe, but it reduces the routine pauses that would otherwise pull me back into the execution loop.
Providers are clearly betting on this, too, with remote environments that keep running when you're in a meeting or when your laptop is closed. Claude Code cloud sessions and Codex cloud tasks are concrete examples of work that can continue in parallel, in separate environments. Grok Bot is another: its bots use a persistent cloud computer and can keep working after you step away. Instead of synchronous pair programming, watching each step, approving commands, correcting mid-stream, you can spin up several well-framed tasks, before a meeting or even before your morning coffee, let them run in parallel, and come back to outcomes you can review.
What I want back is a concrete result: a proposed change, the checks that ran, and a report of anything that blocked the task. I can then review it on my schedule, rather than staying present for every command and click. Lower costs make it practical to run more than one task; more capable models and a fuller set of tools give those tasks a better chance of reaching a result. Permission handling makes the handoff less likely to stall while I am away.
The interesting part is not that it's in the cloud. It's that your attention is no longer part of the execution loop. You define the work, agents run in parallel, and you come back to outcomes. Review becomes the primary interface of control. That's the piece I find most interesting. Not faster typing, but a different way of organizing work, with several streams progressing at once and human attention focused on what comes back.
Code review as the control layer
I've mentioned review before, and I think this shift makes it even more important. In my earlier post on agentic software development, I argued that companies should invest in AI code review tools. I still think the available tools may be insufficient for the volume of code agents can produce. If an agent works for an hour while you're not watching, you need something that tells you whether the result is safe, sensible, and in line with the team's standards. If code is being produced without us watching every step, something else has to catch issues around security, standards, and quality. And that's where a dedicated reviewer agent, or even a set of them, starts to matter a lot.
I can imagine review becoming its own specialized agentic layer, with fresh context, separate incentives, and deep customization to a company's standards, team norms, and risk tolerance. Ideally, that reviewer is somewhat independent, not sharing all of the same context and is configurable to a team or project's standards. It should check the practices, security requirements, and quality bar that actually apply to this company, team, project, and change. A separate testing agent could challenge the resulting behaviour as well as the code diff. The implementing agent's account of its own work is useful evidence, but it should not be the only view.
Over time, review can become a risk dial. Small changes flow automatically, others get stronger model scrutiny, and some still go to a person. I can imagine a weaker model checking some changes, a stronger one examining higher-risk work, and an agent working alongside a human where the consequences warrant it. I don't know the ideal setting, and I doubt there is one rule for every team. The point is to choose how much risk to accept, rather than apply the same review ritual to every change.
This matters even more when cloud tasks or recurring agent work continue without a person watching. The review agent, and perhaps a testing agent, then become part of the way we keep that autonomy under control. In that sense, review isn't just a final check. It becomes part of the control plane for autonomy. And as that autonomy grows, that layer matters more.
The Great Reset
I keep encouraging people in IT, and beyond it, to experiment with AI agents. Even if you're sceptical, it's getting harder to ignore that writing code yourself in an editor is slowly becoming dated. I think we're seeing a great reset in the job market and in how we work. Approaches that served us well before AI need to be tested again in this new setting.
That could also reshuffle what companies value. People who enjoy experimenting, stay curious and try to find the limits of these tools may suddenly become more valuable than those who stay with familiar routines. I can see why that would be uncomfortable, especially for people who were very good at working the old way. The habits that brought success before may no longer be enough. We have to keep testing our assumptions and stay flexible about how we work.
Agentic coding itself shows how quickly this can happen. In April 2025, just under 18 months ago, I described a workflow built around Gitingest. In short:
Flatten the codebase with Gitingest, paste it into ChatGPT and use a reasoning model to plan the work. That saved coding-agent credits because the reasoning model was too expensive to run inside the coding agent. Then hand the plan to Cursor's Sonnet agent for staged implementation.
That took quite a bit of manual work to connect the tools and models. Today, I can often start with the problem itself. The agent can explore the codebase, help shape a plan, implement it and run checks. I still need to frame the task, keep the context useful and review the result, but I can give the agent room to work instead of managing every handoff. The workflow has changed a great deal in less than 18 months. I'm curious what we'll be doing next year.
Comments
Loading comments...