The pitch for long-running coding agents is that you can start something substantial and go do other work. That is genuinely what happens, right up until the agent needs an answer from you.
Then it stops. Not with an alert, not with an escalation, just silence. And silence from a coding agent is ambiguous in the worst possible way: a session thinking hard about a difficult refactor and a session waiting for permission to write one file look identical from across the room.
The asymmetry nobody prices in
Here is the part that makes this worth writing about. Almost every permission request is a decision the person who started the run could make instantly. They have the context. They know whether that action is fine. The judgement takes about two seconds.
What costs the hour, or the afternoon, is being somewhere else when it fires. The bottleneck is not decision quality. It is physical proximity to a specific machine.
The delay is access, not judgement. Any problem shaped like that is solvable by changing where the decision can be made from.
That framing matters, because the two obvious fixes both attack the wrong variable. Loosening permissions attacks judgement, and gets you an agent taking consequential actions unsupervised. Staying at your desk attacks proximity by making you the thing that never moves, which defeats the point of an agent that runs for hours.
What a stalled run actually costs
It is worth being concrete, because the cost hides well. A stalled session does not show up on any dashboard as a problem. Nothing errors. Nothing retries. The work simply does not advance, and then somebody walks back to their desk and discovers the last four hours produced nothing.
- The remaining work in that run, which was queued behind an unanswered question.
- The context switch when you return, because you now have to reconstruct where it got to.
- The scheduling drag on anybody waiting for that work, which is invisible until standup.
- The behavioural cost: after this happens twice, people stop starting long runs before they leave.
That last one is the expensive one. It quietly converts a tool built for unattended work into a tool you only use while watching it, which is a substantial downgrade nobody records anywhere.
What changes if the decision travels
If the pending request can reach whatever device the person actually has with them, the whole shape changes. The run stops for as long as it takes somebody to look at their phone rather than for as long as it takes them to get back to a building.
Nothing about the agent needs to change for that. It keeps running locally, on the machine that has the repository and the credentials and the half-finished state. What travels is the structure of the run: what it is doing, what it is asking, and the answer coming back.
The part we will not overclaim
Remote decisions do not make agents more autonomous, and they should not. The permission pause exists because some actions are consequential and hard to reverse, and keeping a person accountable for those is correct.
What changes is only where that person can be standing. That is a smaller claim than most of this category makes, and it is the one we can actually support.