Coding agents were supposed to stay in their lane. Write some functions, refactor a module, maybe generate a test suite. But the latest moves from OpenAI and the broader ecosystem suggest something different: the containment is breaking. Coding agents are becoming general computer-use agents, and the infrastructure we're building for them is revealing what the next phase of AI actually looks like.
The GPT-5.5 announcement was easy to dismiss as an incremental model update. Better benchmarks, improved token efficiency, another point release. But look at what shipped alongside it: Codex with browser control, OS-wide dictation, auto-review mode, and the ability to iterate through web apps by capturing screenshots and clicking through flows. This isn't a coding tool anymore. It's a computer-work agent that happens to write code when code is the right interface.
The technical community has been debating whether "agentic" is just marketing. The evidence is stacking up that it's something more specific: agents are becoming orchestration layers over heterogeneous tools and models, not single-model loops with tool access. Sakana's Fugu launch, Hermes Agent's rapid provider expansion, LangChain's Fleet skills - all point to the same architectural shift. The hard problem isn't calling tools. It's managing state, context, and workflow across multiple models and environments with different failure modes.
DeepSeek's V4 Preview drop the same day as GPT-5.5 wasn't coincidence. A 1.6T parameter model with 1M context window, MIT license, and aggressive pricing ($0.14 per million tokens for Flash) represents a different kind of disruption. Not just open weights, but open weights designed for agentic workloads with thinking/non-thinking modes and day-zero vLLM support. The inference optimization race - vLLM, SGLang, custom kernels - is being driven by the assumption that agents will consume tokens at rates that make current serving economics unsustainable.
The browser is becoming the primary battleground. When Chrome ships "Skills" that turn prompts into one-click workflows, and Google positions AI Mode as a new way to explore the web, they're acknowledging what Cursor and Cognition already proved: the IDE was just the beachhead. The real opportunity is any context where a human currently performs multi-step reasoning across multiple applications. Code just happened to be the first domain with clean feedback loops and verifiable outputs.
What's striking is how fast the infrastructure assumptions are shifting. Stateless decision memory replacing mutable per-agent state. Event sourcing for auditability. Horizontal scaling through immutable logs rather than locked sessions. These aren't academic concerns - they're responses to production failures when agents run overnight, consume thousands of dollars in API credits, and need to be resumed or debugged after hardware failures or rate limits.
The "dark factory" concept - zero-human-review coding - is approaching faster than most engineering organizations are prepared for. When GPT-5.5 Pro hits 82.7% on Terminal-Bench 2.0 and Claude Code is generating billions in ARR, the question isn't whether models can write code. It's whether our verification and testing infrastructure can keep up with models that write and ship without human gates.
The convergence is clear: coding agents, browser agents, and general computer-use agents are collapsing into a single category of system. The specialization that made coding agents tractable - deterministic feedback, clear success criteria, bounded scope - is being generalized through better memory, longer context, and more sophisticated harnesses. The infrastructure patterns that emerge from this transition - sandboxes, skills as minimal packages, event-sourced agent state - will define the next decade of AI systems architecture.
The labs are betting that the superapp isn't a product category. It's a mode of interaction. Codex becoming OpenAI's "desktop superapp" isn't about capturing the IDE market. It's about establishing the primitives for how agents interact with computing environments at large. The companies that own those primitives - the sandboxes, the skill registries, the agent-to-agent protocols - will shape what the next generation of software actually looks like.
We're not just watching models get better. We're watching the definition of "software" expand to include systems that write, execute, and modify other software on their own. The containment isn't just breaking. It was always a temporary boundary, and what's emerging on the other side is the actual architecture of agentic computing.
Top comments (0)