نماذج Claude الجديدة بتستدعي الأدوات بشكل أضعف

What Armin Ronacher actually found

Armin Ronacher is not a casual AI user. He's the creator of Flask and Sentry, and one of the most respected tool-builders in the Python world. When he writes about a regression, it's worth reading.

On July 4, 2026, he published a post titled "Better Models: Worse Tools." The thesis: newer Claude models — Opus 4.8 and Sonnet 5 — emit MORE malformed tool calls than older ones. Not fewer. More. He backs it up with production logs from his own systems.

The pattern shows up clearly. The newer the model, the more often it invents schema fields that don't exist, sends partial JSON that won't parse, or wraps tool calls in slightly the wrong syntax. He calls it an "aggravating regression" — and anyone running an agent loop will recognize the feeling.

Why this matters if you build agents

If you write code that calls Claude through an API and feeds tool results back, every malformed tool call is a failure you have to handle. The model is not always right just because it's newer. Tool-call fidelity is a separate axis from reasoning quality, and on that axis the newer models are doing worse.

For a chatbot this is invisible. You ask a question, you get an answer, you scroll on. For an agent loop that calls tools dozens of times per task, the regression shows up everywhere: more retries, more validator errors, more wasted tokens, more time billed for work the model half-did. The user feels it as "the agent is flaky today."

For a company shipping AI products, this is even worse. Your error rate doesn't go down just because you upgraded to the latest model — it goes up. The promise of "newer = better" quietly breaks the moment you have schemas your agents depend on.

What Ronacher actually explains (the technical bit)

The most useful section of the post is the technical explanation. Tool calls in Claude are not a separate protocol channel — they are in-band text with ANTML markers. The model writes natural language, hits a marker, writes JSON, hits another marker. If the model knows the schema well, it produces clean JSON. If the schema is unusual or unfamiliar, the model has to improvise — and the quality of that improvisation depends on training, not raw intelligence.

Ronacher's argument is that newer Claude models appear to have spent more training time on long-form reasoning and less on disciplined structured output. The result: better essays, worse schema discipline. A net loss for anyone building agents.

He also shows concrete examples. In one case, Opus 4.8 calls a tool with a JSON object that contains a field name slightly different from the documented schema — close enough to look right, different enough to break the validator. In another, Sonnet 5 drops a required field entirely and the user's code only catches the error after the function call has already started executing.

What this means if you're not a developer

Even if you never write an agent yourself, this affects you. The same models power most of the AI tools you use — browser extensions, email assistants, spreadsheet helpers, coding copilots. If those tools have a hidden cost from malformed tool calls, that cost shows up as slower responses, occasional glitches, or features that work one day and break the next.

There's also a deeper point about incentives. AI labs are racing to ship "smarter" models on benchmarks. But benchmarks don't measure schema discipline. They measure reasoning. So a model can climb the leaderboards while quietly getting worse at the unglamorous structured-output work that real applications depend on. Users pay for the gloss, businesses pay for the friction.

⚡ What to do about it today

You don't need to wait for Anthropic to ship a fix. A few practical moves help immediately:

• Add a strict JSON validator before sending tool calls to your code. Reject anything that doesn't parse or doesn't match your schema, and ask the model to retry with an explicit reminder of the schema.
• Keep a list of "known bad" patterns and pre-validate against them. This catches the common failure modes before they hit your function.
• Pin your model version per use case. Use Sonnet 5 for chat and summarisation, but keep an older Claude (or a different family) for tool-heavy agent loops until the regression improves.
• Log every tool-call failure with the model name and the malformed output. After a week you'll see which model is actually the best fit for your stack — and which one is the most expensive to operate.
• If you're choosing a model for a new product, run a small agent benchmark before committing. Twenty minutes of testing beats two months of debugging in production.

🔧 Try it yourself

Pick one agent or tool-using workflow you run today. Switch its model from whatever you have to Opus 4.8 or Sonnet 5 for one hour. Count the failed tool calls per task. Then switch back. If you see a clear jump in errors, you have your own data point — and you can decide which model version each part of your system should use. That's a ten-minute experiment that can save you a quarter of debugging.

📚 Sources

1. Armin Ronacher — "Better Models: Worse Tools"
2. Anthropic tool-use documentation
3. Hacker News discussion of the post