Writing
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.
Notes
Chat interfaces trained us to think about AI work one turn at a time. Ask a question, receive an answer, continue the conversation.
Agents are starting to break that model.
OpenAI's June 25 research on Codex usage describes a shift toward delegated work that can run for minutes or hours. By May 2026, 70.2% of sampled individual users had made at least one Codex request estimated to represent more than an hour of human work. A quarter had made at least one request estimated above eight hours. By June, users at the 99th percentile of daily active OpenAI users were regularly generating more than 60 hours of Codex agent runtime in a day, spread across several agents running in parallel.
No person has 60 hours in a day. That number only makes sense if the unit of interaction is no longer a conversation turn.
It is a task that can be delegated, executed and reviewed independently.
Chat optimised for responses
A chatbot interaction has a simple lifecycle. The user sends a message, the model produces a response, and the user decides what to do next.
That works well when the output is information. Agentic work changes that relationship.
A task such as "investigate these build failures and prepare a patch" may involve reading files, running commands, changing code, testing hypotheses and producing a diff. A research task may search sources, collect data and leave behind a spreadsheet or report. The useful output is not one message. It is the resulting artifact and the state change that produced it.
OpenAI's February Codex app already reflected this with multiple agent threads, worktrees and long-running jobs in one interface. The June data suggests people are increasingly delegating work in parallel rather than waiting turn by turn.
The interaction starts to look less like messaging and more like a work queue.
Duration changes what a task needs
Longer tasks are not just longer prompts.
Once a job can outlive one context window or one period of human attention, it needs state outside the conversation. Files must survive. Progress has to be recorded. Intermediate artifacts need somewhere to live. Failed steps need to be retried without restarting everything.
This is why agent stacks have been accumulating environments, memory, context compaction, sandboxes and task state.
OpenAI's March Responses API architecture added hosted computer environments with filesystems, shell execution and persistent working state. Anthropic's Managed Agents architecture separates a durable session log, the agent harness and the sandbox so long-running work can survive failures and context changes.
A delegated task needs continuity even when individual model calls come and go.
A task is becoming a durable software object. It has an initial request, an execution environment, intermediate state, outputs and a completion condition. It may be paused, resumed, retried, reviewed or handed elsewhere.
A chat turn has almost none of those properties.
Parallelism breaks the conversation metaphor
Parallel agents make the distinction clearer.
One person cannot meaningfully participate in several synchronous conversations at once. Agents do not have that constraint. Several tasks can run concurrently because each has its own context and environment.
OpenAI says its heaviest internal users were already distributing more than 60 hours of Codex runtime across multiple agents in a single day by June 2026. The Codex desktop app was designed around the same behaviour: several agents working in separate threads and worktrees while the developer supervises results.
Once parallelism becomes normal, response latency stops being the only useful productivity metric.
If one task takes 35 minutes but I can run six independent tasks at once, waiting 35 minutes may be acceptable. What matters is throughput, task success and review cost.
That is different from chat, where a ten-second delay can feel slow because the user is waiting for the next turn.
Sometimes I want an immediate answer. Sometimes I want the system to return when the work is finished.
Those are different modes of computing.
Artifacts become more important than responses
Task-based work changes the definition of output.
If I delegate spreadsheet analysis, I want the spreadsheet. If I delegate a code change, I want the diff and passing tests. If I delegate a production review, I want the report, source data and follow-up items created in the right systems.
The final natural-language response becomes a summary of the work, not the work itself.
OpenAI's June 2 report on knowledge-work usage describes Codex users creating reports, spreadsheets, presentations, contracts and other work products while using the agent for research, analysis and workflow automation. It reports that knowledge workers had grown to roughly 20% of Codex users and were increasingly running tasks in parallel.
For me, this is one of the clearest differences between assistants and agents.
An assistant helps me decide what to do.
An agent increasingly leaves something behind that can be reviewed, used or shipped.
What this changes in production
The shift maps naturally to Blender, rendering and game-development workflows.
I would not want to operate a production agent through hundreds of conversational turns.
If I need 80 product scenes checked before delivery, the natural object is a task: validate these files against this project profile, fix only the safe issues, render previews for the rest and produce a report of anything requiring manual review.
That job may take an hour. It may use Blender Python, filesystem tools and a render worker. It may generate logs and preview images. None of those intermediate operations need to become a conversation unless something requires a decision from me.
A game-development build investigation can work the same way: one agent handles crash logs and tests while others check localisation or prepare release notes.
The human interface then becomes supervision rather than turn-taking.
I want to know which tasks are running, what state they are in, what they changed, which ones are blocked and which outputs need review.
That interface looks more like production management software than a chatbot.
Completion becomes the contract
There is one problem with moving from turns to tasks: a task needs a real definition of done.
A chat response ends when the model stops generating tokens. That does not work for delegated execution.
If an agent is asked to process 80 scenes, completion can be measured against 80 expected results. If it edits a repository, tests can verify the state. If it produces a report, the system can check that the required artifacts exist.
Without those checks, long-running execution only gives the model more time to produce an incomplete result.
This connects back to the evaluation problem I wrote about in 2024. Agent reliability is easier to engineer when the environment can determine whether the task succeeded instead of asking the model to judge its own work.
As the task horizon grows, completion criteria become more valuable, not less.
My prediction
I think the dominant AI interface for serious work will move gradually from conversation history toward task management.
Chat will remain useful for exploration, clarification and short feedback loops. Longer work needs different primitives: task queues, artifacts, checkpoints, permissions, execution history, completion criteria and parallel agents.
The model may still communicate through natural language, but the product around it will behave less like messaging software.
I expect this to change how we measure AI productivity too. Tokens per conversation and response latency tell us little about a system running several hours of delegated work in parallel. More useful measures will be completed tasks, human review time, failure rate, cost per successful outcome and how much work can safely run without intervention.
OpenAI's current data should be read carefully. The task-duration estimates are model-generated rather than direct measurements of human labour, and heavy OpenAI usage is not representative of every workplace.
The exact percentages matter less than the pattern: people are delegating work that outlives a conversational interaction and running several jobs at once.
That changes the basic abstraction.
The first AI products were organised around the message.
Agent systems are increasingly organised around the task.
Sources
- OpenAI, How agents are transforming work, 25 June 2026.
- OpenAI, Codex-maxxing for long-running work, 22 June 2026.
- OpenAI, Codex is becoming a productivity tool for everyone, 2 June 2026.
- OpenAI, Introducing the Codex app, 2 February 2026.
- Anthropic, Scaling Managed Agents: Decoupling the brain from the hands, 8 April 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.
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.
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.
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.