The agent doesn't context-switch. You do.
The agent writes code faster and the queue for the human grows. What research says about interruptions, and how to run several agent sessions at once.
You start an agent. The change will take it six minutes. That is too short to begin anything serious and too long to watch a terminal. So you open a second session and hand over a second task. Before you finish describing it, the first session asks for permission to run a migration. You answer, go back, and then a third one reports that the tests fail.
At five o’clock you have four open branches, two pull requests to read and the feeling of having worked all day without a break. It is just hard to say on what.
An agent pays nothing for a change of subject. It gets a task, reads the files it needs and works. The whole cost of switching stayed with the human, and there are more switches than ever.
What is known about interruptions
Start with what has been measured, because a lot of unsupported numbers circulate around this subject.
Office work was fragmented long before agents. Gloria Mark, Victor González and Justin Harris shadowed 24 employees of an outsourcing company serving the financial sector: analysts, developers and managers. They timed each person for three days and noted every change of topic to the second. The result: people worked on one topic for 11 minutes and 4 seconds on average before moving to another. 57% of the threads of work they started were interrupted.
The way back is long and indirect. In the same study, 77% of interrupted work was resumed the same day, on average after 25 minutes and 26 seconds. In between, people dealt with more than two other topics on average. This is the source of the famous “23 minutes”, usually quoted as the time it takes to regain focus. The study measured something else: the time after which a person returned to the interrupted work at all.
We cause half of our interruptions ourselves. Managers were more often interrupted by others. Analysts and developers interrupted themselves about as often as others interrupted them. Work people interrupted themselves also came back later: after 29 minutes on average, against just under 23 for work interrupted by someone else. That last difference is on the edge of statistical significance in the study, so treat it as a hint.
An unfinished task stays in your head. Sophie Leroy called it attention residue. In two experiments she showed that people who leave a task half done perform worse on the next one, because part of their attention is still busy with the previous one. Finishing the first task under time pressure helped: a closed topic is easier to let go.
After a break, a programmer does not start by writing. Chris Parnin and Spencer Rugaber analysed 10,000 work sessions of 86 programmers. In only one session in ten did coding start within a minute of coming back. In the rest, the context had to be rebuilt first: files, history, notes.
One well-known number is not a measurement. Gerald Weinberg’s table, in which two parallel projects cost 20% of your time in switching alone and three cost nearly half, is an experienced consultant’s rule of thumb. The direction is right. The percentages should not be quoted like a study result.
What the agent changed
A wait that asks to be interrupted
A build used to take half a minute and nobody started a new task in that time. An agent works for anything from a few minutes to a few dozen. That is a stretch in which a sensible person reaches for something else, which means interrupting themselves, a dozen or more times a day. According to Mark’s study, these are the interruptions that take longest to come back from.
On top of that, the agent finishes when it finishes. Its question or its finished change lands in the middle of another task, the way a chat message used to. The difference is that we ordered this message ourselves.
Three roles in rotation
Working with an agent is three different jobs: describing what should be built, deciding when the agent asks, and reading what it wrote. Each needs a different level of detail. One moment you think about module boundaries, the next about a single line in a migration.
Reading is the most expensive of the three. Code you wrote yourself you do not have to understand from scratch, because you remember where it came from. Code from an agent you read like someone else’s, and with several sessions you read it after a break filled with other topics. That is a double cost of return: to the task, and to code you never had in your head.
State scattered across sessions
Every session has its own history of what was agreed. In 2026 a team at Microsoft Research interviewed 14 developers who run agents in parallel. All of them described the same overhead of monitoring and coordination. One could not remember what they had told the agent in the neighbouring session. Another felt “like a quarterback across three sessions”. Some did not notice that an agent had stalled or had long been waiting for an answer.
The same researchers built a tool that shows the state of every session in one place. In a test with 16 people, tasks were completed faster and tracking was less tiring. The authors’ conclusion is still careful: making agents easier to watch does not make their work easier to verify.
The feeling of speed
In METR’s 2025 study, experienced open-source developers took 19% longer to complete tasks with AI than without it. Afterwards they believed they had been 20% faster. A repeat in early 2026 gave no clear result, and the authors themselves concluded that this method can no longer measure reliably, because fewer and fewer people agree to work without AI.
Today’s tools are better and there is no reason to assume that result still holds. One lesson remains: the feeling of pace and the pace are two different things. Several sessions at once give a very strong feeling of pace.
Symptoms
- You approve without reading. The change looks fine, the tests passed, and your mind is in another session.
- The number of “almost done” tasks grows. The code is there; the review, a fix or the merge is missing.
- Branches stay that nobody goes back to.
- The agent waits for you longer than it worked.
- In the evening you cannot name what got finished today.
None of these symptoms points to a weak agent. All of them say that human attention has become the bottleneck.
What helps
1. Count what is waiting for you, not what is running. The number of running agents says nothing about progress. The number of changes waiting for your decision or review does. Two sessions are a sensible start. A third is worth starting only when the queue to you is empty.
2. Delegate less often and more precisely. Every short request comes back after a few minutes and forces a switch. A request with a goal, a completion condition and a list of things that must not be touched lets the agent work for a long time without questions. Ten minutes of writing buys an hour of your own uninterrupted work.
3. Read in batches, and finish. Set times for review instead of reacting to every notification. Take each review to the end: the change merged, or sent back with specific comments. “I’ll come back to it later” is exactly the unclosed topic that spoiled the next task in Leroy’s experiments.
4. Keep state outside your head and outside the chat window. Before you leave a session, leave one sentence in the task: what is done and what the next step is. The people in Mark’s study found their way back by cues, even a cursor blinking where they had stopped. After two other topics those cues are gone, unless you wrote them down. The conversation with the agent is no good for this: it is long, and it disappears with the session.
5. Hand the checklist to a tool. In the assign2me repository a script runs after every commit. It tells the agent to run the backend and frontend tests, report their real result, and then write out for the human what to click in the app to check the change. Nobody has to remember in which session the tests have already passed. The fewer such things you hold in your head, the cheaper every switch.
6. Show who is waiting on whom. A task has one owner, also when an agent writes the code. The task list should show which tasks are standing still because they wait for a human. Without that, the only place where this information exists is your memory.
What we do not know yet
The studies cited above are about interruptions in ordinary office and programming work. Solid measurements of working with several agents at once are still few: interviews, surveys, short lab tasks. The authors of those papers say themselves that studies in real projects are needed.
So nobody knows how many sessions are too many, and there is probably no single answer. What is known is that human attention did not speed up along with the tools. The recommendations in the previous section are our practice, based on this research. None of them has been measured in an experiment.
Where assign2me fits
We build software with agents, so we know this problem from our own working day. The agent picks up a task over MCP, the code is linked to the task by its key, and the task has one owner and a place for a note on its state that does not disappear with the session. Details are on the page for teams coding with AI agents.
Sources
- G. Mark, V. M. González, J. Harris, No Task Left Behind? Examining the Nature of Fragmented Work, CHI 2005.
- S. Leroy, Why is it so hard to do my work? The challenge of attention residue when switching between work tasks, Organizational Behavior and Human Decision Processes 109(2), 2009.
- C. Parnin, S. Rugaber, Resumption Strategies for Interrupted Programming Tasks, Software Quality Journal, 2011.
- G. M. Weinberg, Quality Software Management, vol. 1: Systems Thinking, Dorset House, 1992.
- T. Long et al., ParallelPilot: Supporting Coordination and Monitoring in Parallel AI Coding, preprint, 2026.
- METR, the 2025 study and the February 2026 update.