Torras.ai

On July 9, OpenAI made two announcements that captured where AI work is heading.

GPT-5.6 became generally available across ChatGPT, Codex, and the API. At the same time, the new ChatGPT desktop app brought Chat, Work, and Codex together in one application.

One model family. One workspace. More capable agents. Faster execution.

And yet, we still wait.

That is not necessarily a contradiction. It may be the defining feature of the next phase of knowledge work.

The faster AI gets, the more work we give it

For a long time, using AI meant asking a question and waiting a few seconds for an answer. Latency was easy to understand. You entered a prompt, watched tokens appear, and continued when the response finished.

Coding agents changed that relationship.

Now we ask AI to inspect repositories, search documentation, edit multiple files, run commands, diagnose failures, operate applications, create artifacts, test its work, and revise the result. A serious task may involve dozens of tool calls and several rounds of verification before anything useful comes back.

The model may be faster, but the assignment is much larger.

Codex already offered a fast mode that delivered up to 1.5 times faster token velocity with GPT-5.4. GPT-5.6 goes further by getting more work from fewer tokens and adding settings for harder tasks. max gives the model more time to explore, check, and revise. ultra coordinates multiple agents across parallel workstreams.

These improvements reduce the time required for a comparable task. But we rarely keep the task comparable. When capability grows, ambition grows with it.

We stop asking for a function and start asking for a feature. We stop asking for a summary and start asking for a researched recommendation. We stop asking for a spreadsheet formula and start asking for a complete operating model.

Faster AI does not eliminate waiting. It makes larger delegations practical.

Waiting has moved up the stack

There are several kinds of latency in an AI workflow.

There is model latency: the time required to produce the next token.

There is tool latency: the time required to search, browse, query a system, run a test, render a document, or operate an application.

There is workflow latency: the time required to plan, execute, inspect the result, discover a problem, try another approach, and verify that the work is actually complete.

Faster inference attacks the first kind. Better tools reduce parts of the second. But as agents take responsibility for more complete outcomes, workflow latency becomes more visible.

That is good latency when it replaces work we would otherwise have to perform ourselves. Waiting five minutes for an agent to implement and test something is very different from spending five minutes doing nothing.

The problem is that it can feel the same if we sit there watching the progress indicator.

One app, two rhythms of work

The new ChatGPT desktop app makes the shift explicit.

Chat is conversational. It works at the rhythm of questions and answers.

Work and Codex are more agentic. They work at the rhythm of delegation, progress, intervention, and completion.

Putting these modes inside one application removes product boundaries, but it does not remove the difference between synchronous and asynchronous work. In fact, it makes that difference more important.

We need to learn when to stay in the conversation and when to leave the agent alone.

The instinct to watch is understandable. We want to know whether the agent understood us, whether it is making progress, and whether it will disappear down the wrong path. For poorly specified or high-risk tasks, close supervision is sensible.

But continually polling a capable agent defeats part of the reason for delegating the work. It keeps our attention attached to a task we are no longer executing.

The better interface is not a more hypnotic progress animation. It is a reliable notification at the moment our judgment is needed.

Improve the next handoff

The first useful thing to do while an agent works is to improve the context for whatever comes next.

That might mean collecting a missing example, finding the relevant document, writing acceptance criteria, recording an edge case, or clarifying the business reason behind the task.

This is not about interrupting the current run with a stream of half-formed additions. It is about preparing a stronger next prompt.

Agents perform better when they receive concrete context: the objective, constraints, source material, examples, definition of done, and the decisions they are allowed to make. Waiting time is a good opportunity to turn implicit knowledge into explicit instructions.

The next handoff then becomes shorter, clearer, and more valuable.

Think strategically, and let notifications do their job

Execution naturally pulls us toward details. A waiting interval creates a small opening to move back up a level.

Ask what should happen after the current task finishes.

Does the output need review? Who should receive it? What evidence would make it trustworthy? Is this a one-off task, or the first version of a repeatable workflow? Which part should remain a human decision? What should be measured next time?

This is also where AI notifications matter.

A good notification is not merely a convenience. It is an attention-management tool. It allows the agent to own the execution interval and gives the human permission to stop checking.

The ideal notification is specific: the task is complete, a decision is required, an approval is needed, or the workflow is blocked. Everything else can stay quiet.

Make context switches cheaper

“Get better at multitasking” is probably the wrong lesson.

Human context switching is expensive. Leaving one demanding task, entering another, and reconstructing the first can consume more energy than the waiting interval saves.

The useful skill is making context switches cheaper.

Before moving away from an active agent task, leave yourself a tiny checkpoint:

• What is the agent doing?
• What result am I waiting for?
• What will I inspect or decide when it returns?

Three lines are often enough. When the notification arrives, you do not need to rebuild the whole mental state from memory.

It also helps to match the second activity to the likely wait. If the agent needs thirty seconds, collect context or write a note. If it needs several minutes, review another result or outline an idea. If it is running a long workflow, move to a substantial independent task.

Not every gap is large enough for deep work.

Use the interval creatively

Agent work often creates strange fragments of time: too long to stare at the screen, too short to begin something intimidating.

These fragments are surprisingly good for creative work.

Capture a title. Write an opening paragraph. Sketch an argument. List questions you have been avoiding. Record an observation from the work you just delegated.

The key is to keep a few low-friction creative tasks available. A blank page can be difficult; a running list of unfinished ideas is easy to enter.

This article began exactly that way. Codex was working on a complex workflow, and instead of watching it work, I started thinking about what we should do while we wait for AI.

The waiting interval became the subject.

Sometimes the best use of waiting is not more work

There is a risk in turning every spare second into another productivity system.

If an agent gives us five minutes back, we do not always need to fill those five minutes with a second agent, another browser tab, and a new queue of tasks.

Get coffee. Drink water. Stretch. Look away from the screen. Walk to another room. Let an idea settle without immediately prompting it into existence.

AI can increase the amount of work in motion. That makes recovery more important, not less.

A physical reset is also one of the cheapest context boundaries available. Returning after a short break can make it easier to review the agent’s output as an editor rather than as someone still emotionally attached to the original prompt.

The new productivity skill is orchestration

Chat, Work, and Codex have converged into one app. Our attention has not.

As AI becomes capable of handling longer workflows, the human role moves away from continuous execution and toward orchestration: defining outcomes, supplying context, deciding what can run independently, responding to exceptions, reviewing evidence, and choosing what deserves attention next.

That does not mean humans become passive supervisors. The quality of the work still depends on judgment. But judgment should be applied at the moments where it changes the outcome, not spent watching every intermediate step.

GPT-5.6 is faster. Codex can run several workstreams in parallel. The desktop tools are becoming one continuous environment.

We will still wait, because the work we ask AI to perform will continue expanding.

The question is whether that waiting feels like dead time or becomes a deliberate part of the workflow.

While the agent works, improve the next handoff. Think strategically. Trust the notification. Leave yourself a checkpoint. Write something. Or make coffee and stretch.

The machines are getting better at using compute.

We should get better at using the interval.