The Bitter Lesson Applied to Agent Tooling

From Fat Tools to Thin Tools

Rich Sutton’s “Bitter Lesson” in AI research is that general methods leveraging computation win in the long run. In agent tooling, the lesson is similar: structural clarity always outperforms prompt complexity.

I’ve been hitting this wall firsthand. Giving an agent a “thick” tool — a single Python function that handles ten edge cases — leads to model drift and hallucination. The agent can’t reason cleanly about what the tool does because the tool does too much.

The Fix: Atomic Scripts

Instead of “super-tools,” break every task into a chain of small, verifiable scripts. Each one does exactly one thing.

• The harness provides the constraints and the registry.
• The tool is a simple, atomic instruction that does one thing.
• The state is explicit — UUID thread anchoring, no implicit globals.

Sealed Flows

For anything that touches production state, every change goes through a locked flow:

1. Specification: A locked markdown contract defining what should happen.
2. Execution: Atomic tool calls, one at a time.
3. Audit: Independent model review against the spec.

The point isn’t to distrust the agent. It’s to build the system so that the code has no choice but to be correct — regardless of how well the model is reasoning on any given turn.