Better Models, Worse Tools: Why AI Agents Still Feel Dumb in 2026

If the models keep getting smarter, why does your agent still break? That question is everywhere right now, and in early July 2026 two very different sources landed on the same uncomfortable answer within days of each other.

On July 4, Simon Willison published "Better Models: Worse Tools", arguing that frontier models keep improving while the harnesses and agent tooling wrapped around them lag or actively regress. Two days earlier, on July 2, TechCrunch reported that Mark Zuckerberg told Meta staff AI agents haven't progressed as quickly as he'd hoped. A frontier-lab-adjacent leader and one of the most-read independent voices in AI tooling, pointing at the same gap from opposite ends.

The takeaway isn't that models stopped improving. It's that raw model capability has outrun the layer that turns capability into reliable work. If you build agents, that distinction is the whole game — and it changes where you should spend your time.

Why do smarter models still produce dumb agents?

An "agent" is not just a model. It's a model plus a harness: the loop that feeds it context, exposes tools, parses its tool calls, handles errors, retries, and decides when it's done. When people say an agent "feels dumb," they're usually describing a failure somewhere in that harness, not a failure of the model's underlying reasoning.

Willison's framing in "Better Models: Worse Tools" is that this scaffolding layer has become the constraint. The model can reason about a task, but the tools it's handed are flaky, the context it's given is incomplete, and the loop wrapping it can't recover gracefully when a tool returns something unexpected. Swap in a smarter model and you often get the same brittle behavior, because the thing that broke was never the reasoning.

This is why teams routinely report that a model upgrade "didn't feel like much" in their agent even when benchmark scores jumped. The benchmark measures the model in a clean harness. Your production agent runs in your harness — and that's the part that didn't get upgraded.

Is it the model or the tooling? A quick way to tell

You can usually localize the failure without deep instrumentation:

Read the transcript, not just the output. If the model requested the right tool with the right arguments and the tool returned garbage — or nothing — that's a tooling failure, not a reasoning failure.
Check whether the model had what it needed. Many "hallucinations" in agents are the model reasoning correctly over context that was silently truncated, stale, or never retrieved. The gap is in context assembly.
Watch the recovery path. Good models often notice a tool failed and try to adapt. If your harness swallows the error, retries blindly, or loops, the intelligence is there — the scaffolding is throwing it away.
Change one variable. Upgrade only the model and hold the harness fixed. If behavior barely moves, your ceiling is the tooling.

If most of your failures cluster in the last three, more model won't save you.

Why is agent tooling getting worse, not just lagging?

"Worse tools" sounds counterintuitive in a field moving this fast. A few forces push in that direction:

Models change faster than harnesses. Every model revision shifts prompt sensitivity, tool-call formatting, and context-window behavior. Harnesses tuned for the last model can quietly degrade against the next one.
Tool surfaces sprawl. As agents get more integrations, each one is another thing to keep reliable, well-described, and correctly error-handled. Breadth outruns maintenance.
Evals lag reality. Teams often can't measure harness quality as precisely as they can measure model quality, so regressions in scaffolding go unnoticed until users complain.

None of this is a knock on the models. It's a statement about where the engineering debt now lives.

What does the enterprise pushback tell us?

There's a governance dimension too. On July 4, TechCrunch reported that Alibaba reportedly banned employees from using Claude Code. That's a policy and data-control story, not a capability story — but it reinforces the same underlying point from a different angle: adopting agentic coding tools is now a decision organizations weigh carefully, with real friction, rather than a frictionless "the model is smart, ship it" upgrade. The hard parts of agents are increasingly organizational and infrastructural, not purely about intelligence.

If tooling is the bottleneck, where should builders spend?

The practical reframe: stop treating "wait for the next model" as your roadmap. Invest where the failures actually are.

Harden the tools before you chase the model. Reliable, well-described tools with clean error semantics buy more real-world reliability than a model bump.
Fix context assembly. Make sure the model reliably receives what it needs — the right documents, the current state, the actual error text.
Build evals for the harness, not just the model. Measure end-to-end agent success on tasks you care about, so scaffolding regressions surface before users find them.
Design for recovery. Assume tools will fail and give the model room to notice and adapt, rather than papering over failures with blind retries.

The good news hidden in "better models, worse tools" is that the bottleneck is now something you control. Model quality is largely handed to you by a lab. Tooling quality is yours to fix this week.

Are AI agents overhyped, then?

Not exactly — but the hype has been pointed at the wrong layer. The models are genuinely strong. What's overhyped is the assumption that strong models automatically yield strong agents. They don't, and 2026's most telling signals — an independent tooling expert and a major-lab leader converging on the same disappointment — are a reality check, not a eulogy. Agents work when the scaffolding is good enough to let the model's capability through.

For a concrete look at what "good tooling" produces when it's done right, see our companion case study on what AI-written code actually costs — a real, itemized library release shipped largely by an agent. It's the counter-example to everything that goes wrong above: the same class of model, a harness that actually worked, and a shippable result.

Takeaways for Clawvard readers

The bottleneck in 2026 is the tooling/harness layer, not model intelligence.
A model upgrade rarely fixes an agent whose failures live in tools, context, or recovery.
Localize failures by reading transcripts and changing one variable at a time.
The upside: tooling is the part you control — invest there instead of waiting for the next model.

Building agents and hitting exactly this ceiling? That's the problem Clawvard is built to attack — the scaffolding, not just the model. Explore the tooling-first approach, and read the companion case study for what good harnesses can ship.