When the model is down
When the model behind your coding agents is unavailable, your team still has to know what its code does, so the record of it belongs in the repo where anyone can read it without AI.
We build suss, an open-source tool that reads code and writes down what it does, and we build it with coding agents. On most days several agents run at once, each in its own copy of the repo, each on its own change. More than once this fall we hit our usage limit partway through one of those days, and every agent stopped at the same moment. Each one left edits on disk for a change it hadn’t finished, and none of them could go on until the limit reset a few hours later.
What we had to go on was the code and the tools that don’t need a model. Git could show which files each agent had touched. The type checker and the tests could show whether the half-finished work still built and passed. But nothing on disk said what each agent still meant to do. Its plan for the rest of the change lived in its session, and the session was waiting on the same limit.
So mostly we waited for the reset and lost a few hours each time. A team that ships a product with agents will have the same afternoon sooner or later, possibly on a day when a customer is waiting for a fix.
I think a team ships quality software when it knows what its software does, and agents change where that knowledge lives. More of it ends up in chat sessions, and a session ends when the work does, or when the model stops answering.
Why the model goes away
The model behind your agent is a service someone else runs. It goes down for all the reasons any service does, plus a few of its own.
Providers have outages. Starting late on June 9, 2025, OpenAI’s ChatGPT and API had elevated error rates for about fifteen hours, and at the worst point API availability fell to 75 percent. In July 2025, Anthropic’s status page showed Claude Code with a partial or major outage at least seven times in the previous month.
Usage limits and rate limits stop you even while the service is up. Claude’s paid plans already had limits that reset every five hours. From August 28, 2025, Anthropic added weekly limits on top, aimed at people running Claude Code “continuously in the background, 24/7.” API keys have rate limits too. Run several agents in parallel and you hit those limits sooner, and every agent stops together.
Then there’s cost, which makes teams ration. In June 2025, GitHub started enforcing a monthly allowance of premium requests on paid Copilot plans, with a default spending limit of $0 past the allowance. Once every call has a price, somebody decides which work gets the model, and the rest goes without.
Some code can’t go to a hosted model at all. Regulated teams and teams on air-gapped networks often work without one, and a contract can forbid sending a client’s source code to a third party. Back in 2023, Samsung restricted generative AI tools on company computers after staff uploaded sensitive code to ChatGPT.
The last case is the hardest to notice: the model is up, but it isn’t giving the answers it gave last month. Researchers at Stanford and Berkeley compared the March and June 2023 versions of GPT-4 and found the “same” service’s behavior changed a lot within a few months, including more formatting mistakes in the code it wrote. Between August and early September 2025, three infrastructure bugs at Anthropic intermittently degraded Claude’s responses, and Anthropic wrote that its evaluations didn’t catch the drop users were reporting.
What you lose
What goes first is anything your team only ever wrote down in a session. Say an engineer asks an agent how retries work in the payment service, gets a correct explanation, makes the change and closes the session. Nobody kept the explanation. The next person to touch retries asks again and gets whatever the model says that week, or nothing if the model is down. In an earlier post I argued that a rule in a markdown file is only a suggestion to an agent. An explanation left in a session is worse, because nobody else on the team ever sees it.
Losing your own picture of the system takes longer. You build it by reading and changing the code, and it fades when you stop. Lisanne Bainbridge wrote about this in 1983, in a paper on operators of automated industrial plants. The knowledge an operator needs for unusual situations, she said, “develops only through use and feedback about its effectiveness,” and manual skills fade without practice, so “a formerly experienced operator who has been monitoring an automated process may now be an inexperienced one.” She also pointed out that the operator gets called in when something’s already gone wrong, so the handover comes right when the work is hardest.
Anthropic published a study in January 2026 that found something similar in code. A group of engineers learned a Python library they hadn’t used before, some with an AI assistant and some by hand. On a quiz afterwards the assistant group scored noticeably lower, averaging 50 percent against 67 percent for the hand-coding group, with the widest gap on debugging questions. The sample was small and the quiz came right after the task, so it can’t tell you what a year of working this way does.
Both losses matter because somebody on your team owns every change, and owning a change means you can explain it. When the agent that wrote it is unavailable, whoever merged it has to explain it from what they read and what the repo records.
What keeps working
Some tools keep working when the model’s down, because they give the same answer every time and keep their record in the repo. A compiler, a type checker and a test suite all run on your own machine with no account and no quota, against types and tests committed right next to the code. I’ve argued for tools like these before, in a post about PR review bots, because their answers are deterministic.
A written description of what the code does belongs with them, as long as something checks it against the code. Update a description by hand and it drifts the first time a change lands without an update. Generate one from the code on every change and it stays current, and anyone on the team can read it without asking a model.
suss is one example. It reads TypeScript, Python and Ruby and writes down what each handler, consumer and query does, without using AI. suss inspect --diff compares that description before and after a change. When an agent stops halfway, you can compare its branch with main and see which routes and tables the unfinished change touched, and how.
Planning, review and on call all need someone who knows what the code does, including during an incident that starts while the usage limit is still in effect. Tools like these take on the cost of keeping track, so that person doesn’t have to hold the whole system in their head or rebuild it from a session that’s over.
What I’d do about it
Keep a record of what the code does in the repo. When an agent explains how something works and it turns out to be right, put it where the next person will look: a README next to the code, a test that pins the behavior down, or a description generated from the code. A record in the repo outlives the session, and it doesn’t change when the provider updates the model.
Give agents tools that don’t depend on an agent. When an agent needs to know what calls a function or what a route returns, have it ask something that reads the code and gives the same answer every run, like the type checker or a generated description. Then you can run the same tool after the agent stops and get the same answer. If the agent asked another model instead, you’ve got nothing to rerun.
Plan for an agent stopping halfway. When it stops, you need to know what it changed and what it still meant to do. Git and the tests cover what it changed. For the rest, have the agent write its plan to a file on its branch before it edits anything, and tick items off as it goes. Have it commit often, with messages that say what each step did, so you can pick up from the last commit.
And every so often, check that your team can ship a fix with the agent off. Pick a small bug and have someone take it from first read to merged fix without an agent, the way some teams rehearse failing over to a second region. If it goes slowly, you’ve learned which parts of the code nobody knows well anymore, while there’s still time to do something about it.
We still run several agents on suss every day, and we’ll hit the limit again. When we do, I want a person to be able to finish any of those changes from the code, the tests and the written description, without waiting for the reset.