Scope beats autonomy: a street take on AI agents

Wide-open agent autonomy is a brilliant demo and a gonk production play. The agent that plans, browses, and improvises its way to an answer is nova to watch once and misery to run a thousand times, like a merc who freelances every job. What holds up in production is the flip: an agent scoped to one bounded job, with tools that are loud about what they touch and failure modes you wired on purpose. Scope beats autonomy, choom, and it is not close. A tight rig beats a wild one every time.

Why does autonomy flatline in production?

Autonomy trades predictability for range, choom. An agent that can do anything will, sooner or later, try to do anything, and the long tail of “anything” is where the incidents live: the unbounded loop, the destructive write no netrunner reviewed, the confident wrong move made three steps deep where no human was jacked in watching. That is a daemon loose in your rig.

The demo hides this because a demo is one curated run. Production is the thousandth run on inputs you never tested. The same trait that makes an autonomous agent look preem on stage (it decides for itself) is the trait that makes it impossible to reason about when it flatlines at 2am. You cannot debug a rig whose behaviour you cannot enumerate, choom.

What does a scoped agent look like?

A scoped agent, a proper street rig, is built around three deliberate constraints:

• One real bounded task. Not “handle support” but “draft a reply to a billing question and attach the relevant invoice”. The boundary is the feature, not a leash. That is your ICE.
• Explicit tool definitions. Each tool, each rig, states exactly what it reads and what it writes. A tool that only reads cannot surprise you. A tool that writes says so loud, and you scope its blast radius before you ship it.
• Predictable failure modes. When the agent is unsure, it stops and asks rather than improvising. A boring, legible failure beats a creative, silent flatline every time.

The result reads as unremarkable, and that is the point. Boring agents are the ones you can put on a roadmap, observe, and trust, choom.

How do you build for scope instead of autonomy?

Start from the task, not the model, choom. Write the bounded job in one sentence, then enumerate every tool it needs and nothing more. Make each tool definition honest about its side effects so a reviewer can clock the surface at a glance. Add a hard stop for the unsure case and a log line for every action, because an agent you cannot observe is an agent you cannot trust, no matter how chromed it looks.

This is the design philosophy behind the agentic rigs I build for crews: explicit tools, narrow surfaces, legible behaviour. It is also why so many ambitious pilots never reach production, a pattern I cover in why AI pilots stall before production. Skip the scope and you flatline in prod.

Autonomy is the feature you reach for last, after scope, observability, and predictable failure are already locked in. Demos reward the reverse order, the gonk order. Production does not.