Writing
Coding Agents Are Becoming General-Purpose Computer Workers
Repositories were a friendly environment: text in, terminal actions, checkable results. That was a starting point, not a boundary.
Notes
Coding agents started with an obvious advantage: software repositories are unusually friendly environments for AI. The work is represented as text, most actions can be expressed through a terminal, and the result can often be checked with tests.
That made coding a good place to build long-running agents. I do not think it will remain their boundary.
OpenAI's new GPT-5.3-Codex is explicitly positioned beyond code generation. It combines coding, reasoning and professional knowledge, and OpenAI says it can handle long-running work involving research, tool use and complex execution. The Codex desktop app, released three days earlier, adds skills for documents, spreadsheets, image generation, project management and deployment. Anthropic is moving in the same direction with Claude Opus 4.6, which it describes as capable of financial analysis, research, documents, spreadsheets and presentations inside Cowork.
My read is that coding agents are turning into a more general kind of computer agent. Code is not disappearing from that architecture. It may be the reason the transition is possible.
Coding gave agents an unusually good execution environment
A coding agent does not only generate source code.
It can inspect a repository, search files, edit state, execute commands, run tests, observe errors and try again. The environment gives the model a tight feedback loop between reasoning and action.
That is much closer to real work than a chat response.
OpenAI's Codex app makes this explicit. Multiple agents can run in parallel in separate worktrees, changes can be reviewed as diffs, and long-running tasks can continue without modifying the developer's local Git state. OpenAI says developers are beginning to delegate projects that span hours, days or weeks rather than only targeted edits.
The interesting part is that most of this infrastructure is not inherently about programming languages.
A sandboxed filesystem can hold a spreadsheet. A shell can convert documents. Python can analyse data. A browser tool can gather information. An image-generation tool can create an asset. A script can move files between systems or produce a formatted report.
Once an agent can reliably use code as an intermediate tool, many computer tasks become accessible even when the requested output is not software.
Code is becoming an actuator
I think this changes the role of code inside AI systems.
For a human developer, code is usually the artifact we are trying to produce or maintain. For an agent, code can be temporary machinery used to reach another result.
If the task is to compare several CSV files and produce a spreadsheet, the useful output is the spreadsheet. The agent may write Python along the way, but the Python is implementation detail.
If the task is to prepare a product report, the agent may search files, calculate metrics, generate charts and assemble a document. Again, code is only one of the operations used to create the artifact.
GPT-5.3-Codex is a clear signal in this direction. OpenAI says the model is intended to support work across the software lifecycle, including debugging, deployment, monitoring, PRDs, copy editing, user research, tests and metrics. It then goes further, showing tasks such as slide creation and spreadsheet analysis. On OSWorld-Verified, OpenAI evaluates it on visual desktop-computer tasks rather than repository changes alone.
That is a much broader execution surface than a coding benchmark.
The interface is moving from IDE to workspace
The Codex desktop app is another signal because its interface is built around supervising agents rather than editing code directly.
The central objects are tasks, threads, worktrees, skills, automations and review queues. The developer can run several agents in parallel and inspect their progress rather than staying inside one editor buffer.
Skills widen the scope further. OpenAI describes them as bundles of instructions, resources and scripts that let Codex connect to tools and execute repeatable workflows. The launch examples include Figma-to-code workflows, project management in Linear, cloud deployment, image generation and creating PDF, spreadsheet and DOCX files.
Automations let those workflows run on schedules, with results returned for review.
This starts to look less like an IDE feature and more like an execution workspace.
Anthropic's Opus 4.6 release points at the same category from the opposite direction. Claude Code remains a coding environment, but the company highlights Opus 4.6 inside Cowork for research, financial analysis and office-document tasks. It can use longer-running context, tools and parallel subagents while working through a job.
Two companies arriving at similar boundaries in the same week is more interesting to me than either product announcement by itself.
General-purpose does not mean unrestricted
I would not interpret this as evidence that coding agents are ready to operate an entire computer without structure.
The reason coding agents work as well as they do is that software repositories provide unusually strong feedback. Tests can fail. Commands return exit codes. Diffs can be reviewed. Git gives us a history of changes. Sandboxes can isolate execution.
Many office and creative tasks have weaker completion signals.
A spreadsheet can be syntactically valid and still contain the wrong assumptions. A presentation can look polished while misrepresenting the data. A Blender scene can save successfully while the material, camera or scale is wrong. A research report can be formatted correctly and cite the wrong evidence.
As agents move beyond code, they need equivalent verification layers for each domain.
For 3D production, I would expose scene validation, asset metadata, render checks and export verification rather than trusting visual computer use alone. For documents, I would validate structure and source data. For analytics, calculations should be reproducible outside the model. For browser tasks, important state changes should be confirmed from the resulting system state rather than inferred from a click.
The agent can become more general while the environment remains constrained.
This matters for creative technology
I see a useful path here for Blender, game development and production automation.
Today, many AI workflows around creative software are split into two categories. Either the model explains what to do, leaving the human to operate the software, or a custom script automates one predefined operation.
A general computer agent can sit between those extremes.
It could inspect a production folder, read a brief, query project rules, generate or modify scripts, launch validation, process data and prepare review artifacts. Where a reliable API exists, it should use the API. Where a script can produce the result more safely, it should write and run the script. Computer use can remain the fallback for software surfaces that expose no better interface.
That hierarchy matters. I do not want an agent clicking through Blender menus to rename 300 objects when the Python API can do it deterministically. But I may want the same agent to understand a human request, write the operation, execute it, inspect the result and prepare a report of what changed.
The coding capability becomes the bridge between intent and software state.
My prediction
I think the category called "coding agent" will become broader than the name suggests.
The strongest coding agents already have the ingredients needed for more general computer work: filesystem access, terminals, browsers, structured tools, long-running state, parallel tasks, artifact generation and a habit of using code when a direct tool is missing. OpenAI now describes GPT-5.3-Codex as moving toward a single agent that can reason, build and execute across broader technical work, while Anthropic is positioning Opus 4.6 across both coding and professional knowledge work.
That does not make them universal workers. Different domains still need different permissions, validation and context. Reliability outside software engineering may improve more slowly because the environment gives weaker feedback.
But I expect the boundary to keep moving.
A future agent may receive a task such as "prepare the weekly production review" and decide that it needs to query project data, analyse a spreadsheet, inspect screenshots, generate charts, update a document and create follow-up tasks. The user may never ask it to write code, even though code is used throughout the execution.
That is why I think coding is becoming less of a destination and more of an execution primitive.
The first generation of coding assistants helped us write programs.
The next generation may use programming to do work on the computer.
Sources
- OpenAI, Introducing the Codex app, 2 February 2026.
- OpenAI, Introducing GPT-5.3-Codex, 5 February 2026.
- OpenAI, GPT-5.3-Codex System Card, 5 February 2026.
- Anthropic, Introducing Claude Opus 4.6, 5 February 2026.
More
Other write-ups
Approval Is Not Publication
Thirty seven items in the queue, one approved, nothing published. The last arrow in the diagram is the only one that pays.
Neural Rendering Is Crossing From Reconstruction Into Synthesis
Reconstruction filled in what sparse sampling missed. DLSS 5 generates appearance the renderer never computed.
The Renderer Is Becoming a Training Data Engine
The renderer used to sit at the end of the pipeline. Physical AI gives the same scene a second job: teaching a model.
Local AI Is Becoming a Compute Fabric
Local AI meant one model on one machine. Routing inference across the devices already on a network changes the unit.
Agent Infrastructure Is Becoming a Product Category
Every team used to build the loop, the store, the sandbox. That layer is being sold rather than written.
Choosing a local model with a stopwatch, not a benchmark
Three models, five hard tasks, code actually executed. The official build was 2.4 times faster and more accurate than a community repack of the same model.
We measured real time lighting against baked light, and baked won
A 3D product simulation that had to look like an offline render. The real time version ran at 60 frames per second and looked like clay. Here is the measurement and the architecture that replaced it.
What actually broke in an agency run by agents
Three failures from a delivery stack that runs on AI. None of them were the model's fault, and all three reported success while producing nothing.
A Task Without A Check Command Is Not Automated
If a task has no command that can fail, the pipeline advances on the appearance of work.
A Gate The Model Writes Is A Gate The Model Loosens
Three quality gates returned green while the work behind them was wrong, each for a different reason.
The Scoring Model Was Wrong And It Put The Worst Lead First
A weighted sum let one axis substitute for the other, so a company with money and no problem ranked in the top twenty.
Building Software Got Easy. Getting Value Out Of It Did Not
Aristo took weeks to build. Everything after the build is still in progress, and that gap is the whole story.
Capability Is Becoming an Operational Risk Surface
Safety questions used to be about the text. Once a model can act, the capability itself becomes something to operate.
The Scene Graph Is Becoming an API for AI
A scene graph exists for artists and software. Agents are becoming another consumer, and they need structure rather than pixels.
Animation Is Moving From Clips to Motion Priors
Authored keyframes and blended clips are giving way to asking which constraints define acceptable motion.
Materials Are Becoming Learned Programs
A material is texture maps, parameters and shader code. It is starting to become a small learned program that answers a rendering question.
Procedural Systems Are Expanding Beyond Geometry
Geometry Nodes started with a narrow name. Blender 5.2 puts physics, sound and object data through the same graph.
The Unit of AI Work Is Becoming the Task, Not the Turn
Chat taught us to think one turn at a time. Long-running agents make the task the thing that is scheduled, resumed and reviewed.
Game Engines Are Becoming Operating Systems for Worlds
Engines have been judged on what they render and simulate. The Unreal 6 roadmap points at operating a world rather than drawing one.
The Model Is Becoming a Replaceable Backend
Choosing a provider used to mean choosing an architecture. A stable interface makes replacement possible and evaluation makes it safe.
The Harness Is Part of the Capability
The same model behaves differently depending on context policy, tool design and execution feedback. That surrounding software is not neutral.
Physics Engines Are Becoming Trainable Components
A simulator predicts what happens next. A differentiable one can answer which parameter should change to stop the failure.
The Agent Needs an Environment, Not Just Tools
A search function and a database query were enough for short loops. Longer work needs a place to stand.
Open Standards Outlive Model Generations
A year after the MCP bet, the argument can be checked against what happened rather than what was hoped.
Colour Management Is a Pipeline Contract
Blender 5.0 reads as better display options. Giving a file an explicit working colour space is an architectural change.
The Best Model May Be a Router, Not a Model
GPT-5 moves model selection inside the system. The interesting unit stops being which model and becomes which compute policy.
World Models Are Not Game Engines Yet
Genie 3 generates a navigable 720p world at 24 fps. Production work needs state you can inspect when something goes wrong.
Memory Is Becoming a System Capability
A follow-up to the long-context argument. Storing, selecting and expiring facts is turning into a named part of the product.
Coding Agents Change the Unit of Software Work
AI coding tools have been judged where code appears on screen. The boundary moves when the agent owns a task instead of a snippet.
Agents Need Protocols Between Each Other, Not Just Tools
Tool calling solves the inside of the loop. It says nothing about one agent reaching another built by a different team on another platform.
Agents Need a Runtime, Not a Prompt Loop
An agent is no longer well described as a prompt inside a while loop. The useful abstraction owns execution around the model.
Reasoning Is Not the Only Path to Better Models
Longer thinking improves maths and code. A model that solves a logic puzzle and misreads ordinary intent is not the better production model.
Rendering Is Becoming a Reconstruction Stack
Sparse samples, motion data and lower-resolution frames become a larger final result. Debugging becomes layered when reconstruction sits in the middle.
Agent Reliability Is an Evaluation Problem, Not a Prompting Problem
When an agent misses a step, the usual fix is a stricter prompt. The failure is more often in how completion is detected.
MCP Might Matter More Than Another Model Release
A model can reason well and still be useless inside a company if it cannot reach the files, repositories and tools where work lives.
Computer Use Is the Missing Layer Between Models and Software
Most integrations assume useful software exposes the right API. Much of real software never did.
Inference-Time Compute Is a New Scaling Axis
o1 improves when it is allowed to spend longer on a problem. A benchmark score without a compute budget is an incomplete number.
The Final Pixel Won't Come From the Renderer
Geometry, camera and scene structure stay reliable ground truth. More of final appearance is moving into learned systems.
Open Models Are Becoming Research Infrastructure
Llama 3.1 gets discussed as a benchmark result. The licence terms change which experiments are possible at all.
The Model Is Becoming a Runtime
Function calling, code execution and structured output turn inference into a loop. The model stops being a text generator and starts being a control layer.
Multimodality Changes the Architecture, Not Just the Interface
GPT-4o is easy to read as a faster interface. Training one model end to end across text, vision and audio is an architectural change.
Benchmark Scores Are Not Model Capability
Claude 3 posts 86.8% on MMLU and 50.4% on GPQA Diamond. The chart is useful and it is not the same thing as capability.
Long Context Is Not Memory
Gemini 1.5 makes a million tokens usable. A larger working set is not a system that decides what should survive the session.