Authority Has to Travel With the Work

The first instinct in agent governance is to centralize everything. Put every permission, policy, approval, and audit record in one control plane. Make every agent check in before it acts. The diagram looks clean because authority has one box and every arrow points toward it.

Then the work starts moving. A coding agent needs repository access. A release agent needs an environment. A monitoring agent needs production signals. Each tool has its own permissions, state, and failure modes. If one distant service must interpret every action, the control plane becomes a translation layer for the entire business. That is not control. It is a queue with a prestigious name.

Our position is that authority has to travel with the work. The factory should decide the rules centrally, but it must enforce them at the boundary where an action becomes real. The repository protects the merge. The deployment system protects the release. The data service protects the record. Each boundary answers the question it actually owns.

Teams often hear distributed authority and imagine a collection of local exceptions. That is the failure mode, not the design. A factory needs a shared definition of who may request an action, what evidence must accompany it, how much consequence that action can carry, and where a human decision is still required.

The enforcement can live in several places without becoming several policies. A change can carry a signed identity, a declared purpose, a bounded permission, and the evidence produced so far. Each system checks the part it can prove. No component has to trust the agent's description of its own authority, and no central service has to impersonate every tool in the delivery line.

This is the practical split: policy is coherent, enforcement is local, and evidence is portable. If those three drift apart, agents learn to route around the weak point. If they stay connected, the factory can add another tool or another agent without inventing a new governance model every time.

Human access is commonly granted as a standing condition because asking for it repeatedly is annoying. Agents change that tradeoff. They can request narrow authority for one task, use it immediately, and discard it when the task ends. The factory can make temporary permission the normal path instead of the exceptional one.

Narrow means more than a short clock. The grant should name the action, the target, the task that justified it, and the maximum consequence the agent may create. Reading a deployment log is not permission to restart the service. Preparing a release is not permission to publish it. Writing a migration is not permission to touch production data.

The uncomfortable part is that many current roles exist to carry standing permission between systems. As factories make authority specific and machine-verifiable, that coordination work shrinks. Human judgment moves to defining consequences and handling true exceptions. It should not remain trapped in approving the same predictable request one ticket at a time.

Permission only tells you an action was allowed. It does not tell you the action produced the right result. An agent can stay inside its access boundary and still deploy the wrong artifact, apply the wrong change, or satisfy a check that never tested the consequence anyone cared about.

Every meaningful grant should therefore name its required evidence before the action starts. A merge needs proof tied to the actual commit. A release needs proof tied to the actual artifact and environment. A data operation needs proof of scope, outcome, and recovery. The system that owns the boundary records what happened instead of accepting the builder's summary afterward.

That evidence must travel too. The next stage should receive the decision, the identity behind it, and the proof that earned it. Otherwise each handoff resets trust and invites another manual review. Portable evidence lets the factory keep moving without turning speed into amnesia.

Do not begin with a universal governance screen. Begin with one piece of work that crosses several systems. Mark where the agent can read, write, approve, release, and recover. Name which system owns each boundary and what evidence would make its decision trustworthy. The gaps will be obvious long before a dashboard makes them pretty.

Then make the handoffs explicit. Carry identity and task context forward. Issue the smallest useful grant. Let the receiving system enforce its own boundary. Return evidence in a form the next stage can verify. When production exposes a missing rule, change the shared policy and the local check together.

A software factory is not governed because one console can see everything. It is governed when no consequential action can happen without the right authority and no authority can survive without evidence. Centralize the rules. Distribute the enforcement. Make the proof follow the work all the way home.