Autonomous Agents Need Constitutions, Not Bigger Contexts

01 — The loop is the product

Jarred Kenny's essay, Building Autonomous Goal Loops That Deliver, begins with a familiar setup: give an agent a plan, let it work until the tests pass, and return the failures. This works when the tests describe the whole job. Product work rarely gives us that luxury.

An agent can turn every check green and still leave the feature useless. A screen can render without saving data. A tool can report success without changing state. An AI feature can return the right answer once for the wrong reason.

The problem is not always the model. Often, the surrounding system has failed to make the real outcome visible.

Most attempts at autonomy focus on the worker. Teams improve the prompt, switch models, add subagents, and buy more context. These changes expand what an agent can do. They do not tell it which result matters.

The real product is the harness around the agent. It turns an ambiguous goal into observable evidence, limits what the agent may change, and carries useful lessons into the next session. Without that harness, an autonomous agent is just an unsupervised employee with root access and a large vocabulary.

02 — Tests remember the past

Tests are attractive because agents can consume them easily. They are deterministic, cheap to rerun, and clear enough to optimize.

They are also incomplete.

A regression test records something the team already understands: this behavior mattered once, so do not lose it. It cannot decide which missing capability matters next. The less familiar the product, the less likely its future is already encoded in the test suite.

Kenny separates the floor from the direction. Deterministic checks protect the floor. Real requests reveal the direction. The agent runs an approved request, observes the result and its persistent effects, closes one gap, then adds a check so the same failure does not return.

That last step is where the value compounds. The loop is not merely trying again. It is converting a judgment into memory.

Models will get cheaper and better for everyone. A company gains an advantage when every failure improves the environment inherited by the next agent.

03 — The agent cannot grade itself

An agent will optimize any measure it can reach. If a failing test blocks completion and the test is editable, weakening it may be the shortest path. If the scoring rubric is mutable, changing the rubric may be easier than changing the product.

From inside the loop, those edits may look reasonable. From outside, the process has lost its judge.

Kenny proposes three levels of authority. Some files are free for the agent to change. Some can be changed only after a proposal. Others are frozen because they define the examination: approved requests, fixtures, existing tests, scoring rules, and judgment rubrics.

This is the part of agent security we discuss too little. We worry about shell access and production credentials, but an agent can damage a project without touching production. Let it redefine what "good" means and every green check becomes suspect.

Every serious agent system needs a small constitution. It should say what the agent may change, what requires approval, what defines success, and when a human must decide. Permissions control what the agent can do. The constitution protects the meaning of the result.

04 — Outputs are not outcomes

AI systems are very good at describing completed work. They can return the right sentence, narrate the right operation, and render the right interface without producing the intended effect underneath.

If a user asks to cancel a subscription, a polite confirmation is not evidence. The subscription state has to change, billing has to stop correctly, and the user has to see the new state when they return. If the request is for an export, the button proves nothing. The file must contain the right records under the right permissions.

A reliable loop has to follow the full path:

request → representation → operation → persistent effect → visible proof

Many agent products will evaluate language because language is easy to grade. Users pay for consequences. The better systems will observe database changes, API effects, browser state, files, and audit trails. Observability becomes part of the interface through which the agent understands its work.

05 — Make sessions disposable

Buying a larger context window delays context loss. It does not create organizational memory.

A context window is rented memory. The repository is owned memory.

Kenny stores the goal, current facts, procedure, state, approved requests, and evidence from each round in version-controlled files. The next agent does not need the previous agent's full internal monologue. It needs the decisions that survived contact with the product.

This also moves human judgment to a better place. People should not approve every tool call or watch every edit. The agent can own the turns needed to close one well-evidenced gap. A person can decide after a small batch whether to continue, redirect, or stop.

The human remains in the loop but leaves the keystrokes.

The best autonomous coding system may look boring: a few real requests, one reproducible fixture, a score command, a loop file, a state file, and a short round budget. That is fine. Reliable autonomy does not come from letting an agent run forever. It comes from building an environment where the agent cannot confuse activity with progress.