AI agents get tired too

Every few weeks someone asks me a version of the same question: "When will agents be reliable enough that I can just trust the output?" The honest answer is never, and I don't say that as pessimism. I say it the way I'd say it about a person. Your best engineer ships bugs. Your most careful accountant fat-fingers a number after lunch. Some days we work at our peak, some days we're tired, and nobody concludes from this that people are useless. We just build our work around the fact.

Agents deserve the same deal. Not blind trust, not dismissal — a process that assumes error.

Perfection isn't late, it's impossible

This isn't a "current models are immature" situation that the next release fixes. In 2025 OpenAI published Why Language Models Hallucinate, a paper that treats hallucination as a statistical inevitability rather than a bug: for facts that appear rarely in training data, some error rate is mathematically unavoidable, and the way we score models makes it worse — benchmarks that grade answers as simply right or wrong reward a confident guess over an honest "I don't know", so models learn to bluff exactly the way a student bluffs on an exam.

You can shrink the error rate. You cannot buy it down to zero, at any model size, from any vendor. A plan that requires a zero-error agent is a plan that fails on contact with mathematics.

The fatigue analogy is more literal than it sounds

Here's the part I find genuinely interesting: agents don't just err like people, they degrade like people. A human's tenth hour of work is worse than their second. An agent's hundred-thousandth token of context is worse than its thousandth. Chroma's research team documented this as context rot: the same model, asked the same question, answers less reliably as the context window fills up — even when everything it needs is right there. I've written before about the related lost-in-the-middle effect — information buried mid-context simply gets less of the model's attention.

So a long agent session has a shape a manager would recognize. Fresh context, sharp answers. Twenty tool calls later, the agent starts missing constraints it respected an hour ago. That's not a broken model. That's the system's version of tired. And the remedy is the manager's remedy too: don't give one worker a twelve-hour shift — break the work up, hand off with a clean summary, start fresh.

We already know how to work with fallible workers

Nothing about managing imperfect intelligence is new. We've been doing it with humans for a century, and the machinery is familiar: code review, because authors miss their own bugs. Tests, because "it works, trust me" isn't evidence. Checklists, because even experts skip steps under load — that's the whole argument of Gawande's Checklist Manifesto. Four eyes on anything irreversible.

Every one of those transfers directly:

• Tests are ground truth. An agent's claim that the code works is worth exactly what a colleague's claim would be worth: run the suite.
• Review scales with blast radius. Let the agent loop freely on things that are cheap to undo. Anything irreversible — deploys, deletes, money, emails to real people — gets a human look first.
• Small tasks, fresh context. The agent equivalent of "go home, look at it again tomorrow". Most of the quality I get from agents comes from scoping work down, not from better prompts.
• Verification beats trust. Not because agents are bad, but because verification is how we've always turned unreliable parts into reliable systems. Aviation doesn't have zero-failure components. It has redundancy.

The question that actually matters

"Is the agent 100% accurate?" is the wrong question, and it was always the wrong question — we just never asked it about people, because the answer was obviously no and we hired them anyway.

The right question is the one every functioning team already answers: what happens when this worker is wrong? If the answer is "the test suite catches it", or "a human reviews it before it ships", you can put an imperfect agent to work today and get real leverage. If the answer is "nothing catches it", the problem isn't the agent's error rate. It's that you built a system with no immune response — and that system was going to fail with humans in it too, just more slowly.

Reliability was never a property of the worker. It's a property of the system around the worker. That was true before AI, and it's the most useful thing to carry into working with it.