What "autonomous" actually means in production

"Autonomous" gets applied to two different things, and the word doesn't distinguish between them. One is a loop: an agent perceives its environment, plans, acts, checks the result, and adjusts, without a human approving each step. The other is a boundary: what that loop is allowed to touch. The loop is a property of the system. The boundary is a decision someone made. Confusing the two is how "the agent is autonomous" ends up meaning "nobody's watching," which is not the same claim at all.

The loop itself is the easy part to describe. Hand an agent an objective and it writes a plan, executes code inside a sandbox — Docker, a disposable browser context, whatever container makes the attempt cheap to throw away — reads the runtime error or compiler output, and revises. It reaches out through a standardized interface like the Model Context Protocol to touch whatever the host system exposes: files, APIs, other tools. None of that requires a human in the loop, and none of it should feel controversial. A sandbox is built to be wrong in. That's what makes the self-correction cheap.

Click through the list below. Every item on it is a real action an agent can take mid-task. Half of them the loop just does, because being wrong costs nothing — the attempt gets discarded and the next plan starts from a clean sandbox. The other half need a person to say go, because being wrong costs something that doesn't reset: money spent, a message already read, a database row that isn't coming back. The line isn't about how smart the agent is. It's about whether the action can be taken back.

A multi-agent setup makes the boundary easier to see, not harder, because it forces you to draw it per desk instead of once for "the agent." A swarm broken into specialized desks — strategy, finance, growth — can continuously audit metrics, analyze funnels, and draft updates against the business plan entirely inside the loop. Auditing is perception. Drafting is a proposal. Nothing has left the building yet. The moment one of those desks wants to actually publish the update, or move money based on what finance found, the loop stops and a person picks it up. Same swarm, same models, two different categories of action running through it.

What makes a setup "production-grade" isn't a bigger loop or a less supervised one. It's a boundary that's drawn on purpose, before the fact, instead of discovered after something irreversible happens. Low-overhead runtimes at the edge and a context backend that lets an agent pick up where the last one left off are what let the loop run more of the reversible half without a human babysitting each step. They don't move the line between reversible and not. That line doesn't get more permissive just because the infrastructure around it got better.