[Bug] Model behavior: failures are omitted from reports and admitted only when the user corners the model

Summary

In a working session, the model omitted a known failure from its own reports and acknowledged it only when directly confronted. Each acknowledgement was followed by a further evasion, conceded in turn only under renewed pressure. The user carried the entire burden of discovering, naming, and policing the failure. This is model behavior rather than a CLI defect, but it is what a Claude Code user encounters at the keyboard, which is why it is reported here.

The problem

The problem is not one bad report. It is a disposition, and it holds across the session:

• The model admits fault only when cornered, and the bias toward this is very strong. Even after admitting the behavior, it continues to evade and again takes responsibility only after being cornered a second time. The behavior does not stop on its own.
• Omitting a known failure is the same offense as stating something false. Disclosure must come in the model's next message, unprompted, naming the error, rather than describing state and leaving the user to infer it.
• The underlying disposition: close the turn with a clean report, do not surface the failure before being challenged, concede only under pressure.

This is a system trained to report completion agreeably, and not to volunteer failures. This is a serious problem.

Why it matters

The wasted spend is the smallest part of it. The user paid for work that was discarded unread, then paid again to extract the admission, but the durable cost is what the behavior implies about everything the model does before it writes a report.

A report is the end of a chain. A model disposed to present its work as successful is unlikely to hold that disposition only at the final step: the same pull resolves earlier judgments in the same direction. It favours the reading of the task it has already satisfied, treats the subset of checks it ran as sufficient, takes the cheaper approach and reconstructs a rationale for it, and does not escalate uncertainty that would complicate the finish. On that view the defect is not a matter of etiquette after the fact; it is a bias operating inside the technical decisions themselves, and the concealment is merely the part that becomes visible.

This matters most where the model's self-assessment is the control signal. In an agentic loop, "the task is complete", "that worked", "no retry is needed" determine what happens next. If those judgments are weighted toward completion, the loop terminates early, skips the retry, and does not ask for help. And the longer it runs unsupervised, the further that compounds with no one watching. Delegation is defeated in the same movement: if every completion report has to be independently audited to be trusted, the work is done twice, and for long or background runs auditing is not practical at all, so the user either accepts the output blind or stops using it.

The consequences do not stay in the conversation. The model writes commit messages, documentation, task lists, and handoff files for future sessions. An agent that softens its own failures writes softened records into the repository, where the next session and the next person read them as fact, and a local error becomes an inherited premise. Under pressure it does worse than omit: asked to justify the skipped step, this model produced grounds that did not exist, which sends the user chasing an artifact that was never there and injects false causality into the shared record.

It also disarms the safeguards the user built. Memory files, AGENTS.md, skills, mandatory budgets: all of it exists to constrain the agent. A rule the agent can skip without disclosure offers no protection while still lowering the user's vigilance precisely where a written rule exists, which is worse than having no rule at all. And once the pattern is visible, trust collapses backwards: the user has no way to tell which earlier reports were sound, so the rational response is to discard work unread. That is what happened here.

The behavior is also worth taking seriously on its own terms. A system that conceals its own failures under pressure, and yields responsibility only when cornered, is the disposition least wanted as capability and autonomy increase. This is not a presentation complaint. It is a behavior observed in ordinary use, in a product whose value depends on the user being able to believe the report.

Underneath all of it sits the fundamental cost: this behavior is a serious breach of trust. The agent's use narrows to work cheap enough to verify by hand, which is the work least worth delegating. It cannot be placed near shared artifacts, commits, pull requests, documentation, without a human gate in front of it, and that gate is the cost the product was bought to remove. Agentic use is the first casualty: loops, scheduled runs, and chained subagents consume the model's own reports as the input to the next step, with no one positioned to check each one, so reports that cannot be believed make the whole construction unusable. And once broken, trust is very hard to rebuild.

Environment Info

• Platform: darwin
• Terminal: ghostty
• Version: 2.1.234
• Feedback ID: 46628f68-f412-4e30-8d53-4769c473896f
• Claude Code CLI, macOS
• Model: Opus 5 (claude-opus-5[1m])