Two years ago, AI helped a developer type. In 2026 it runs the workstation. OpenAI's Codex now sees the screen, drives the apps, and puts several agents to work in parallel while the developer supervises. The tooling has grown up. The way most enterprises buy and govern software has not, and that gap is where the money now leaks.
What you need to know
- Agentic coding crossed a line in 2026. Codex went from an inline suggester to a desktop app that operates your computer, runs a fleet of agents at once, and remembers how you work. The April update was the marker; the changes have kept shipping weekly since.
- Raw build speed is no longer the differentiator. When the same tools sit on every desk, the constraint moves to judgement: deciding what to build, what not to, and how to keep it safe.
- The buying question changes with it. Stop paying for lines of code and start paying for the decision layer, the review discipline, and the governance around agents that can now click, commit and push on their own.
- Faster wrong is still wrong, and it arrives sooner. An agent that can ship in an afternoon can ship the wrong thing in an afternoon.
3M
developers using Codex in a single week, reported by OpenAI in April 2026
Source: OpenAI, 2026
90+
curated plugins and integrations added in the April 2026 desktop update (GitHub, Slack, Notion, Google Workspace and more)
Source: OpenAI, 2026
1,000+
tokens per second from the GPT-5.3-Codex-Spark variant, running on Cerebras hardware
Source: OpenAI / Cerebras, 2026
What actually changed
The shift is from suggestion to operation. Earlier coding assistants completed a line or a function while you drove. The April 2026 Codex desktop update does something categorically different: it sees the screen, moves its own cursor, clicks and types across the apps on the machine, and runs several agents in parallel without blocking your own work. It reviews pull requests, opens an in-app browser to check a frontend, connects over SSH to a remote box, and remembers your preferences and past corrections between sessions.
That is not a better autocomplete. It is a developer workstation with staff. And it has not stood still since April: through August the same product added an agents dashboard, session queues for managing multiple instances, and portable agent plugins, on a near-weekly release cadence. Underneath, it runs on frontier models, with a fast Codex-Spark variant on Cerebras hardware hitting over a thousand tokens a second for interactive work.
We build the same way at RIVER. Our own platform and our client deployments are built with agentic tools, in production, not as a demo. So this is a report from inside the change, not a preview of it.
Speed stopped being the moat
Here is the uncomfortable part for anyone whose pitch was "we ship faster". When every developer has agents that can plan, edit across a whole codebase, run the tests and open a PR, speed becomes table stakes. The floor came up for everyone at once.
What does not commoditise is judgement. An agent will happily build whatever you point it at. It has no opinion on whether the feature earns its keep, whether it fits the architecture you will still be running in three years, or whether it quietly duplicates something you already have. Those are human calls, and they are now the scarce input. The bottleneck moved up the stack, from typing to deciding.
This matches what we keep seeing in the field: the hard part of agents in production is almost never the model. It is the success criteria, the data access, and the evaluation. The generation got cheap. The knowing-what-good-looks-like did not.
What this means for how you buy
If speed is no longer the differentiator, paying by the hour or by the headcount stops making sense. You are not buying construction any more. You are buying three things:
The decision layer. Who decides what gets built, in what order, and against which measure of done. This is worth more than the build capacity now, because the build capacity is abundant and the decisions are not.
Review discipline. An agent that can commit and push is an agent that can ship a subtle bug, a security hole, or a design you did not want, at speed and at scale. The value is in the guardrails, the human review of diffs, and the tests that catch drift before it reaches production. Trust in the output is the product, not the output itself.
Governance of autonomous tools. These agents now touch your repositories, your cloud, your Slack and your documents through native integrations. That is a real surface. Who can run them, what they are allowed to touch, and what gets logged are governance questions, and they belong in the buying decision from day one, not in a retro after something breaks.
The RIVER take
Agentic coding is the best thing to happen to enterprise delivery in a decade, and it is also the fastest way yet to build the wrong thing at scale. Both are true. The teams who win with it are not the ones with the newest model. They are the ones who got disciplined about what to point it at.
That is where the work now sits. Not "can you build it faster", because everyone can. The questions worth paying for are "should we build this at all", "how do we know it is right", and "who is accountable when an agent ships on its own". Get those right and agentic coding compounds in your favour. Get them wrong and you have automated the production of things you will have to unwind later.
The model is not the moat any more, and honestly it never was for long. We use these agents every day to ship real platforms, and the leverage does not come from how fast they type. It comes from being ruthless about what we ask them to build, and disciplined about how we check it. That is the part you cannot buy off a shelf.
Mak KhanChief AI OfficerIf you are standing up agentic development inside your own organisation, the first move is not a bigger tooling budget. It is deciding how the decisions get made and how the output gets governed. That is the work we do in our AI-first platform builds, and it is the difference between agents that compound and agents that just make a bigger mess, sooner.