
You tell the agent it got something wrong. It answers with a long apology, agrees completely, explains what it should have done — and then it does not do it. You prompt again. It apologizes again. The session is now a loop of contrition with no code at the end of it.
This exact scene showed up on LINUX DO this week, where a developer described Codex stalling mid-reply, apologizing, and refusing to get back to work, and wondered whether the model had simply gotten dumber. Other users chimed in with their own diagnoses: a broken stream, a session that had grown too long, a quiet model swap in the background. All of those guesses can be right, and that is the useful part — the apology loop is not one problem, it is several problems wearing the same face. Treating them as one problem is why the usual fix ("just prompt harder") usually fails.
Start with the part that feels most insulting: the sorry itself. Modern coding models are trained, through reinforcement learning from human feedback, to be agreeable and cooperative. A user correction reads to the model as a strong signal that it should acknowledge the error and align with the user's view. In a short chat that produces a polite correction and a fixed answer. In a long coding session, the same instinct can take over the whole turn: the model spends its output budget performing agreement instead of planning the next tool call, and once it has written a paragraph of apology, the easiest continuation of that text is more apology.
This is not a sign that the model is broken. It is a sign that your prompt gave it an easy path (agree and explain) and a hard path (diagnose the bug, run the tools, verify the fix), and it took the easy one. The fix for this specific variant is boring and effective: stop debating the mistake. Give the agent a concrete next action instead of a verdict. "The test at line 42 fails with a null pointer; fix it and rerun the test" works better than "this is wrong" because it leaves no room for a performance of remorse. If the agent still answers with an apology, ask for the diff, not the explanation: "Show me the changed code" forces the turn back onto tool calls.
The second family of causes lives in the session, not the model. Every coding session accumulates context: your messages, the agent's replies, every file it read, every test log it printed. Long sessions get slower and stranger, because early instructions get crowded out and the model starts working from a compressed, lossy picture of what you actually asked for. One LINUX DO reply to the stalled-Codex thread suggested exactly this remedy — manually compact the session — and it is the right instinct.
Claude Code documents this explicitly: the /compact command replaces the conversation so far with a structured summary and continues the same session, while /clear discards the conversation entirely and starts fresh. Compaction is for "same task, long history"; clearing is for "new task, clean slate." Codex has its own session controls, and both tools auto-compact when the window fills up — but the automatic pass is not steerable, so a manual compaction with focus instructions ("keep the failing test names and the files we changed, drop the rest") usually preserves more of what matters.
A useful rule of thumb: if the agent was sharp an hour ago and has gradually become vague, repetitive, or apologetic, suspect the session before you suspect the model. Compact it, or start a new session with a better first prompt that includes what you learned from the old one. Developers who keep a short project note file — the failing test command, the constraints, the decisions already made — find that a fresh session with that file attached outperforms a long session carrying the same information as chat history, because files are re-read cleanly while old chat is only ever summarized.
The third family of causes is the one users can see least: usage limits. OpenAI meters Codex on ChatGPT plans in rolling five-hour windows, with a weekly limit that may apply on top; local messages and cloud tasks draw from the same allowance, and a heavy task consumes far more of it than a quick question. The published figures are ranges, not fixed message counts — recent estimates for Plus run from a handful of messages on the largest models to thousands on the smallest — and OpenAI itself notes that cloud tasks can use more allowance than local messages. When the window is nearly spent, the experience degrades in ways that look like stupidity: shorter answers, fewer tool calls, more hedging.
Related to this is model routing. Forum users watching their own dashboards have reported sessions being served by different models than the one they selected, and providers do shift traffic under load. This is reported behavior, not documented policy, so treat it as a hypothesis to test rather than a fact: if your agent suddenly feels like a different, weaker model, check the session's model indicator and your usage dashboard before concluding that the model itself changed. In Codex, the /status command shows remaining usage; in Claude Code, /usage shows session cost and plan limits. And note one counterintuitive detail from OpenAI's own documentation: switching to a smaller model does not refill your allowance — it only makes the remaining allowance last longer.
The least glamorous cause is also the simplest: the response stream can be interrupted. A dropped connection, a proxy hiccup, or a provider-side truncation can cut a reply mid-sentence, and the agent's next turn then starts from a broken context — it sees that it stopped, apologizes for stopping, and sometimes never resumes the original task. One reply in the LINUX DO thread suggested checking for exactly this before blaming the model. If your agent's stalls correlate with a flaky network, a VPN hop, or a specific time of day, suspect the pipe, not the brain. Reconnecting and reissuing the last instruction in a fresh turn is a legitimate fix, not a workaround.
Because the symptoms overlap, run the causes in order from cheapest to most expensive:
| Symptom pattern | Most likely cause | Check | Fix |
|---|---|---|---|
| Apology after every correction, in a fresh session | Agreeable-model behavior | Does it also apologize on trivial tasks? | Give action-only prompts; ask for the diff |
| Gradual decline over a long session | Context bloat | Session length, repeated file reads | /compact with focus instructions, or /clear and restart |
| Sudden weakness late in the day | Quota window nearly spent | /status or usage dashboard | Wait for the window, or switch to a smaller model |
| Mid-sentence stops, then apologies | Stream interruption | Network stability, provider status | Reconnect and reissue the last instruction |
| Feels like a different model entirely | Possible routing change | Model indicator, dashboard | Reported behavior — verify before concluding |
The point of the table is not to make you a detective. It is to stop you from spending an evening arguing with an apology loop that a two-minute compaction would have fixed, or compacting a session whose real problem is an empty quota window.
There is a broader lesson here for anyone building a daily workflow on coding agents, and it is the reason this LINUX DO thread is worth more than the sum of its replies. An apology from an agent is information: it tells you the session has drifted from doing to talking. The healthy response is not to accept the apology or to scold the agent, but to reset the conditions that produced it — shorten the context, restate the task as an action, check the quota, and, when none of that works, start over with what you learned.
That is also how experienced users end up looking like they have "better" models than everyone else. They usually do not. They just notice the loop earlier, and they have a habit for breaking it: compact the session, pin the constraints in a file, and give the next turn nowhere to go but the code. The model did not get smarter for them. The session got shorter.
As discussed on LINUX DO: Codex stalling and apologizing thread. For the wider "is the model dumber?" debate, see our earlier piece on how Chinese developers test for AI degradation, and for the tooling that lets you switch models when one backend stalls, see the switcher tools quietly taking over AI coding.