← Blog

My Agent Team Went in Circles for Ten Days

My agent team spent ten days on one change that wouldn’t pass its Mac tests. It asked me more than twenty questions along the way, nearly all for a little more room.

“Where are we on the roadmap, and why are you still going in circles?”

I typed that a few days ago to ystack, the agent team I’ve been rebuilding since late summer.

Its answer was honest. It agreed it had been too slow, and said the roadmap was still stuck on the same change it had been stuck on for ten days.

It was the second time I’d had to ask. Earlier that week I’d asked why the roadmap was taking so long. It admitted it was going in a loop and promised in the chat to cut back on the extra checking. Nothing in its rules changed, so the next day it went straight back to the loop.

The test that never passed

The stuck change tightened one of the team’s own safety checks. It had to pass the full tests on a Mac before it could go in.

The Mac run failed more than sixty times over those ten days and never passed. For the first few days it broke somewhere new almost every time. After that, one step kept freezing, and nobody ever found out why.

The team kept busy. About a hundred and twenty changes went in, and only one of them touched the product itself. The rest were plans and fixes to the tests. About ten of the plans just made more room for the stuck change, and by the end it was allowed to grow to more than three times its first size.

It checked in with me often, too. It asked me more than twenty questions, and almost every one asked me to approve something. Usually it wanted another round of tests, more room for the change, or permission to look at more of the code.

None of those questions asked whether we should stop.

My rules never said when to stop

My first reaction was to blame Codex, OpenAI’s coding agent, which the team mostly runs on now. Here it worked on one thing for ten days and barely moved it. Maybe another model would have asked sooner, but I can’t tell that from one case. Then I read back what I’d told it.

I’d told it the Mac test had to pass before it moved on to anything else. The rules I wrote for the project say only I can change what counts as passing. And I kept telling it not to ask me about ordinary steps. Two weeks ago I wrote in Notes From MCP Dev Summit Toronto that I’d told this same team, more or less, to stop asking for so many approvals and just finish the roadmap.

I did push back. I’d asked for fewer tiny tests back in September, and in the middle of all this I told it to stop stalling on plans and reports. That same message said the Mac test still had to pass, so it stuck with it.

On its own, the team had one move: fix something and run the test again. Skipping the Mac would have meant changing what counts as passing, and working on other parts first would have broken my Mac-first rule. Both calls were mine. Put together, my rules gave it no point where it was allowed to give up.

It wrote every question I answered

The only way out ran through the questions it sent me, and the team wrote every one of them, along with the answers I could pick. The answers were always some version of approve more, or keep the old limit and stay blocked. Its decision notes even had a line for a question to me, and nearly every one said none.

Anthropic’s guide to building agents says an agent can pause for a person at checkpoints or when it runs into a blocker. I’d set no checkpoints, so every pause came when the team decided to stop, and it also got to decide what the pause was about. Even when it told me the Mac was blocked, the question was whether it could spend more trying.

The team never stopped to weigh either of my two calls, so neither question came up until I asked. I think that goes for any call I keep for myself: if nothing brings it to me, it stays at whatever I said last. Here that was Mac first, for ten days.

Every next try looked ordinary

On the team’s side, nothing kept count. For the first few days each run broke somewhere new, so no failure looked like a repeat. It also kept picking work it could finish and check, like plans and small fixes to the tests. Cursor saw something similar when it ran agents for weeks on big projects. With no one owning the hard parts, they “avoided difficult tasks and made small, safe changes instead.” I wrote in AI Has No Needs that a model doesn’t feel friction, and on a long job that means another try costs it nothing.

On my side, I answered each request on its own. I never said no, and in a single day I doubled the extra test runs it was allowed, from three to six. In my Toronto notes I wrote that agents ask so often that people stop reading and just approve. This time it was me.

If I’d handed this to an engineer, they might well have spent a week on it too. People dig in on a failing plan all the time; psychologists call it escalation of commitment. But I think they’d still have come back within a day or two: I can’t crack this. Should we skip the Mac for now, or do you want me on it all week? Being stuck wears a person down, and they can feel the days going. That’s what sends them back to ask. Here neither of us was keeping count.

Where a long run should stop

Other agents do this too. A June preprint that tested 13 agent systems on more than 28,000 tasks found that some never stopped when they should have, and others stopped only after many steps they didn’t need. It hasn’t been peer reviewed yet, but it matches what I saw.

The fix is old, though. Google’s guide to running large services says to “limit retries per request”, never retry forever, and keep a total retry budget on top. Martin Fowler’s circuit breaker counts failures from outside the thing that keeps failing, and after enough of them it stops calling it and hands the failure back to whoever made the call.

For agents, I think it comes down to where a run has to stop and check in. A hundred and twenty changes went in and the team looked busy the whole time, so count failures on the test that has to pass instead. Keep that count outside the agent, where it can’t lose track of it or argue its way past it, the same reason I gave in The Rule Was a Suggestion for rules that run as code. And set the limit before the work starts, because once you’re inside the loop every next try looks ordinary.

Lauren Tan’s pstack, a set of skills for Cursor that includes playbooks for long agent runs, does something close. In her playbook for coordinating agents, a stuck piece of work gets two retries, then it’s set aside and the agent plans around it. Whether to keep going never goes to a person there. Only a dead end that survives a new plan gets sent up. I’d want mine to ask sooner, because skipping the Mac is one of the two calls I kept for myself.

Three failures, then it asks me

In the end the change of course came from me. I asked whether we could finish the rest of the roadmap first and come back to the Mac at the end. It agreed right away, asked me to approve the new order, and within about ten minutes it was writing code for the next part.

So I’m moving the counting out of the team and into the program that runs it. That counter will do three things.

First, it tracks failed runs for each check that has to pass. If the same failure shows up three times in a row, it stops the run, and the team has to ask me one question: keep going, skip it, or give up.

Second, each check gets a total budget of five failures or one full day, whatever the cause. The three-in-a-row rule alone would have missed the first few days, when every failure looked new, and the budget catches those. When it runs out, the counter sets the piece aside, and the team keeps working on whatever doesn’t depend on it until I answer. That’s the reorder I only asked for on day ten.

Third, it puts those same three answers on every question the team sends me, along with the attempt, the day, and how far I’ve already let the change grow, because I never added that up myself.

The budget might stop some useful fixing early on. That costs me one question. I can still answer keep going, but I’ll see the total first.

The Mac run failed six times on the first day alone, so the budget would have run out that day and the team would have had to ask me. After that, the answer is on me.