The Agent Restraint Problem

Runtime length isn't autonomy. Decision scope is.

Barry Zhang at Anthropic explains in How We Build Effective Agents—the path from simple LLM features to production agents requires restraint, not enthusiasm.

Agent fever hits every team building with LLMs. First comes summarization and extraction. Then workflows that chain multiple calls. Finally, the inevitable question: why not make everything agentic? From enterprise deployments, I've seen this pattern destroy more projects than it creates.

The Selectivity Filter

Don't build agents for everything.

Don't build agents for everything. Second, keep it simple. And third, think like your agents. — Barry Zhang, Anthropic

This sounds obvious. Most teams ignore it anyway.

The workflow-to-agent jump feels natural. You're already orchestrating model calls, managing state, handling failures. Why not add decision-making? Because agent complexity scales quadratically with domain size. Workflows break predictably. Agents break creatively.

In enterprise deployments, I've watched teams spend months debugging agent decisions that would take hours to fix in deterministic workflows. The cognitive overhead of understanding "why did it choose that path?" compounds across every interaction.

Simple Architecture Beats Clever Engineering

Strip scaffolding from frontier models. The old orchestration patterns—heavy RAG layers, multi-step reasoning chains, complex tool routing—often hurt more than help.

Unlike workflows, agents can decide their own trajectory and operate almost independently based on environment feedback. — Barry Zhang, Anthropic

This autonomy comes with a tax. Every decision point doubles your debugging surface. Every tool doubles your failure modes.

The teams shipping agents successfully use minimal architectures. Single-model decision makers with clear guardrails. Direct tool access with simple verification loops. No clever orchestration that requires a PhD to debug.

But here's the catch—simple doesn't mean limited. It means intentional.

The Mirror Test

Think like your agents. This isn't anthropomorphizing. It's understanding their actual decision process.

Most teams build agents like black boxes then wonder why they make strange choices. The mental model gap kills production deployment. You need to predict agent behavior before users discover edge cases.

The fix involves decision transparency. Log reasoning paths. Make tool choices explicit. Track confidence scores. When agents fail, you should know why within seconds, not hours.

I could be wrong here, but the agents that ship successfully feel predictable to their builders. Those that don't feel like magic—which breaks in production.

The Verification Gap

Agent demos look amazing. Production agents need verification loops.

The difference between showing an agent and shipping an agent is feedback quality. Demos run on curated data with human supervision. Production runs on chaos with automated oversight.

This changes everything about architecture. Verification becomes the primary design constraint. Can you automatically check if the agent succeeded? Can you recover from failures? Can you explain decisions to users?

The painted doors problem hits here—agents ship features that look complete but break when stressed. The verification system determines which agents survive contact with real users.

Why This Matters

Agent restraint prevents technical debt at AI velocity. Build agents for everything and you get systems nobody understands. Build agents selectively and you get tools that actually ship.

The economic impact compounds. Failed agent projects cost more than failed traditional software because debugging AI decision-making requires specialized expertise. Most teams don't have that expertise.

Context quality determines agent success more than model capability. Teams focusing on model upgrades miss the bigger lever. Those investing in decision transparency and verification infrastructure build agents that scale.

What Works

Start with workflows, not agents. Build the deterministic version first. Understand the decision points. Then consider where autonomy adds value.

Keep architectures minimal. Single-model decision makers with clear tool boundaries. Avoid complex orchestration that requires deep debugging.

Build verification before autonomy. If you can't automatically check agent success, you're not ready for production deployment.

Think like your agents. Understand their reasoning paths. Log decisions. Track confidence. Make failures debuggable.

This works with frontier models that can handle complex reasoning. Earlier models need more scaffolding—stripping it breaks them entirely. Know your model generation.

The teams doing this right see sustained productivity gains. Those building agents for everything watch demo magic evaporate in production (and this pattern repeats across every deployment).

Full talk: Watch on YouTube