There is a strange kind of dead time opening up in the workday.
I can feel it when I am sitting here with agents running. Codex is working. Another model is working. Something is ticking away in a terminal, or a browser, or a harness, and I cannot make it go faster by staring at it.
The work is happening. The system is doing useful things. The code is often good. The output is often good. But it is not instant.
So the question becomes a very human one:
What do you do while the agents run?
My words
I think we are going to see a really interesting period now.
The capable systems are good enough to do real work, but they are not always fast enough to disappear into the background. Sometimes they tick away slowly. Sometimes the harness makes the whole thing slower. Sometimes the rate limits, the inference capacity, the checking, and the safety rails all mean that the work is happening at machine speed, but not at the speed your attention wants.
That creates dead time.
Not dead time because nothing is happening. Dead time because the human is waiting for the next useful moment.
I notice it in myself. I sit here while a report runs, or a code change is being made, or a task is being checked. I cannot do it faster than the agent. I could read something. I could go for a walk. I could make a coffee. I could step outside, come back, and see what has happened.
But I cannot fully switch off either, because the work will need me again.
At some point I have to come back, focus hard, understand what has changed, check whether it is right, decide what happens next, and push the next button.
That is the new rhythm: deep attention, then waiting, then deep attention again.
The human job is not disappearing. It is becoming more intermittent, more supervisory, and more dependent on the ability to snap back into focus.
Smart But Slow
There is an assumption that AI work will feel like instant magic.
Sometimes it does. You ask for a summary, and it appears. You ask for a rewrite, and it is there. That is the easy mental model: fast machine, slower human, obvious productivity gain.
But agentic work is different.
The agent has to inspect things. It has to read files. It has to run tests. It has to wait for network calls. It has to reason through a codebase. It has to recover from small failures. It may need to run through a harness that checks what it is doing before it lets the work move on.
So we get a new category of work: smart but slow.
That is not a criticism. It may be exactly what we want. I would rather have the agent take longer and produce something I can trust than race ahead and make a mess. But it changes the human day.
If the model is capable but slow, the constraint moves. It is no longer just, "Can the system do the task?" It is, "How do I organise myself while the system is doing the task?"
The Attention Switch Is The Skill
I think one of the key skills is going to be switching off and on cleanly.
Not multitasking in the old noisy sense. Not pretending to do twelve things at once. More like controlled re-entry.
You send the agent away. You let it work. Then, when it comes back, you need to regain the full context quickly. What was I trying to do? What did it change? What does the diff mean? Is this safe? Is this complete? What is the next right move?
That requires real focus.
It also requires enough understanding of the underlying system that you are not just approving things because the agent sounded confident. You need to be able to read the shape of the work, spot the risks, and decide whether the output is good enough.
So the human is not sitting idle. The human is holding the frame.
What Goes In The Waiting Time?
This is where it gets interesting.
What should we do in the gaps?
Make a cup of coffee? Go for a walk? Read around the problem? Chat with a colleague? Check in with someone else who is also waiting for their agents to finish? Take a quick nap?
That sounds slightly ridiculous until you realise that the alternative may be worse.
The alternative is sitting at the screen, half-watching progress bars, half-starting another task, never quite resting and never quite focusing. That is a horrible way to work. It feels busy, but it is not always useful.
There may be a better rhythm:
- Queue the agent with a clear task.
- Step away deliberately.
- Use the gap for something human: movement, thought, conversation, reading, recovery.
- Come back when the work needs judgement.
- Review properly.
- Send the next task only when you understand what just happened.
That is not laziness. It is designing the day around the real shape of the work.
The Burnout Version
There is another path, and I think it is dangerous.
You can line up a whole stack of agent tasks. You can keep ten things moving. You can use every pause to start another run. You can keep yourself at 100 percent for eight, ten, twelve hours, constantly switching, constantly checking, constantly loading and unloading context.
That will look productive for a while.
It may also burn people out.
Because the work is not just waiting. The work is repeated re-entry into complexity. It is picking up a thread, understanding what the agent did, making a decision, and then placing the next thread carefully.
That is cognitively expensive.
If we treat every agent pause as an invitation to cram in another agent run, we may end up with humans who are technically supervising more work but are mentally shredded by the end of the day.
The Office Rhythm Changes
This could change the office in a very practical way.
Breaks might become more fluid. Teams might find themselves naturally syncing around agent runs. Someone sends a task away, someone else does the same, and suddenly there is a ten-minute window where the useful thing is not another meeting but a quick conversation.
Or people might go outside.
Or read the policy they never had time to read.
Or sketch the next decision while the machine does the mechanical work.
We may need to design workflows that accept this rhythm instead of fighting it. The human does not need to stare at the tool to prove they are working. The useful human moment may be before the run, when the task is framed, and after the run, when the output is judged.
Something Long-Lived
I think there is another part of this too.
Humans need to feel that some of the work is long-lived. We need to be doing something creative, useful, and worth caring about. If the whole day becomes nudging machines, watching progress, and approving fragments, something important may be lost.
So maybe the waiting time should not always be filled with more work.
Maybe some of it should be used to think about the thing you are actually building.
What is the larger shape? What is the point? What needs human taste? What needs judgement? What would make this work matter six months from now?
Those questions do not always arrive while you are staring at a progress bar.
Waiting Is Part Of The System
I do not think this is a small thing.
As more people get access to stronger models, but not necessarily the rate, speed, or capacity they want, this pattern will become more common. The tools will be smart, but sometimes slow. The human will be needed, but not continuously.
That creates a new operating problem.
How do we help people supervise agents without exhausting them?
How do we make the pauses useful without making them frantic?
How do we teach people to leave the desk at the right moment and return with enough focus to make the next decision well?
I do not think the answer is to pretend the dead time is waste.
The dead time may be where the human work belongs.
Read. Walk. Talk. Think. Rest. Come back. Review properly.
The agents can run.
The human still has to decide what the work means.