This is a condensed version. The full post, with the controls table, the loop table and all the sources, is on my site.

Somebody asked a question on LinkedIn that I haven't been able to put down, about how we keep the next generation of technology from becoming another dependency that only a few engineers truly understand. It may have been rhetorical, but I don't think it should be. Every enterprise is fixin' to answer that same question about AI.

Compliance is the marquee concern, but it isn't the only one

In OT and regulated environments, compliance and governance get top billing, and they should. But I'd put three concerns side by side on that banner, security, compliance and governance, and safety. They overlap. Security asks whether the wrong somebody can make the agent do something, and governance asks whether we can prove who decided what, and why. Safety asks what happens when everything is authorized, everything is logged, and the agent is still wrong.

Safety is about blast radius

Don't hand an agent your personal credentials. That's table stakes. The bigger problem is the day an agent gets a change confidently wrong, at scale and at machine speed. A person gets a funny feeling around the third switch and stops. An agent doesn't. So the question becomes how far the damage can travel, once it's wrong, before something stops it.

Here are the controls I'd want. Each agent gets scoped, short-lived, non-human credentials and least privilege. On top of that I'd want gateway policy, rate limits and circuit breakers, plus change windows, staged rollout and canaries. Every change gets a dry run and diff before commit, with automatic rollback behind it. The agent refuses to act when the source of truth is missing, somebody owns a kill switch, and audit trails record what happened. In my Agent Interconnection Model (AIM), credentials live at the Execution layer, gateway policy lives with MCP at Connectivity, and Trust and Telemetry run across every layer.

In the loop, on the loop, out of the loop

A human can be in the loop and approve each action, sit on the loop and watch with a hand on the brake, or stay out of the loop and review outcomes afterward.

What you can't automate is responsibility and accountability, and they belong to different people in different parts of the business. The person responsible for the automation sits in or on the loop, depending on the assessed risk of it being confidently wrong. The person accountable sits on or out of the loop, scaled by that same risk.

They overlap on the loop. That's where both of them know what the automation does and both can stop or steer it from their own side of the business, so the understanding doesn't live inside one knowledge domain and turn into the next bus factor.

Confidently capable has to be earned

A model sounds just as sure when it's wrong as when it's right. So confidence has to come from measuring it. Run it in shadow mode, test it against known-good answers, put it in the loop and track the override rate, and only then move it on the loop. A new model version or a new tool is a change that can send it back down a rung.

Token efficiency is an architecture decision

Right-size the model for the task, cache what repeats, trim the context, retrieve instead of stuffing, batch what can wait, and own the steady workloads while renting the burst. Then measure cost per completed task instead of cost per token.

So by all means automate the work, and leave responsibility and accountability with the people who answer for it.

Read the full post on ryanthomashuff.com