TL;DR
Enterprise AI guardrails are mostly an old engineering problem in new clothes. Limit the blast radius before you widen autonomy, keep responsibility and accountability with different people who meet on the loop, make agents earn autonomy with measured results, and treat token spend as an architecture decision.
Somebody asked a question in my LinkedIn comments this week that I haven’t been able to put down: how do we keep the next generation of technology from becoming another dependency that only a few engineers truly understand? It may have been rhetorical. I don’t think it should be, because it’s the same question every enterprise is fixin’ to answer about AI, whether they ask it out loud or not.
I’ve spent more than 20 years in enterprise networking, voice and IT/OT, and I’ve watched a few of these waves roll through. Voice went from TDM to SIP. Networks went from hand-typed configs to templates and automation. Every time, the technology was the easy part. The hard part was deciding who gets to push the button, and who answers for it when the button does the wrong thing. AI is that same problem, except now the thing pushing the button works faster than any of us can read.
So here’s my rationale for bringing AI into enterprise business execution in a way that is safe (or at least has clearly defined risks), confidently capable, secure, and built so you aren’t lighting money on fire one token at a time.
Compliance Is the Marquee Concern, but It Isn’t the Only One
When AI comes up in a boardroom or a change advisory board, compliance and governance usually get top billing, and in OT and regulated environments they should.
But I’d put three concerns on the banner, side by side: security, compliance and governance, and safety. They overlap, and they aren’t the same thing. Security asks whether the wrong somebody can make the agent do something. 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. That last one is the one that keeps me up at night.
Safety Is About Blast Radius, Not Just Passwords
The obvious safety advice is good advice: don’t hand an agent your personal user credentials. If the agent logs in as you, every mistake it makes is your mistake, made with your access, and the audit trail says you did it. That’s table stakes.
The less obvious part is the one I care about more. Sooner or later, one of two things goes wrong with any agent you put in production. Either it gets compromised (a poisoned tool, a sketchy skill, or instructions hiding in a web page or a ticket), or it gets a change confidently wrong. Not maliciously. Just wrong, with total confidence, at scale and at machine speed.
Think about how a person makes a bad change. They push it to one switch, something looks a little off, and somewhere around the third box they get that funny feeling in their gut and stop. An agent doesn’t get a funny feeling. If it’s wrong on device one, it can be wrong on device four hundred before anybody finishes reading the first alert. So the design question isn’t only “how do we keep it from being wrong?” It’s “when it’s wrong, how far can the damage travel before something stops it?” That’s blast radius, and you have to define it, direct it and limit it on purpose, before the first run.
Here are the controls I’d want in place, and where each one lives in the Agent Interconnection Model (AIM), the seven-layer way I’ve been thinking about agents. Execution (Layer 2) is where code runs and whose credentials it runs with. Connectivity (Layer 3) is where MCP sits, along with gateway auth and policy. Trust and Telemetry are planes that cut across every layer, the way the control and management planes do on a router.
| Control | What it limits | Where it lives in AIM |
|---|---|---|
| Scoped, short-lived, non-human credentials for each agent | Who it can act as, and for how long | L2 Execution, Trust plane |
| Least privilege on tools and on the systems behind them | What it can touch | L3 Connectivity, L1 Resource |
| Gateway authorization and policy | Which tools it can call, with which arguments | L3 Connectivity, Trust plane |
| Rate limits and circuit breakers | How fast it can do damage | L3 gateway, Trust plane |
| Change windows and approvals | When it can act, and who said yes | L7 Interaction, Trust plane |
| Staged rollout and canaries | How much it changes before you learn something | L6 Reasoning, L7 Interaction |
| Dry run and diff before commit | What it was about to do | L2 Execution, L1 Resource |
| Automatic rollback | How long the damage lasts | L1 Resource |
| Refusing to act when the source of truth is missing | Acting on a guess | L5 Context |
| A kill switch somebody actually owns | Whether you can stop it at all | Trust plane |
| Audit trails and traces | Whether you can reconstruct what happened | Telemetry plane |
A few of those deserve a word. The source of truth one is near and dear to me. An agent is only as good as what it knows, and if the inventory, IP plan or intended state it’s supposed to check against is missing or stale, the right move is to stop and say so, not to improvise. (The bottom-up AIM mnemonic, “Real Engineers Check Configs Constantly, Rarely Improvising,” ends the way it does for a reason.)
Dry run and diff turns the agent’s intent into something a human or a second agent can read before it becomes reality. Canaries turn “confidently wrong at scale” into “confidently wrong on two boxes,” which is a bad afternoon instead of a bad quarter.
The gateway at Layer 3 is where I’d put most of the policy. The 2026-07-28 revision of the Model Context Protocol puts the method and tool name in HTTP headers so a gateway can route and authorize without cracking open the request body. That’s the natural spot for allow lists, rate limits and circuit breakers, the same way we put ACLs and policers at the network edge. One caution: a skill’s scripts can run straight at Layer 2 without going through MCP at all, which means they skip the gateway. Treat installing a skill like installing software, because that’s what it is.
In the Loop, On the Loop, Out of the Loop
This is the heart of the answer I gave on LinkedIn, and I want to build it out properly here. There are three places a human can stand relative to an automation:
- In the loop. The human approves each action before it happens. Nothing moves without a yes.
- On the loop. The automation runs on its own, and the human watches it with a hand on the brake. They can see what it’s doing, and they have a real way to stop or steer it.
- Out of the loop. The automation runs without a human in the run at all. People look at outcomes afterward.
Here’s my claim. Nearly everything in the agent stack can be automated except two things: responsibility and accountability. A model can’t own either one. And I’d argue they shouldn’t live with the same person, either. They belong to different humans in different business domains.
The responsible person builds and operates the automation: the engineer or automation owner who knows how it works. The accountable person owns the outcome for the business: the service, process or risk owner who answers for it when it goes sideways. If you’ve ever filled out a RACI chart, none of this is new. What’s new is where each of them stands relative to the loop.
The placement rule is one question: what is the assessed risk of this automation being confidently wrong? The person responsible sits in or on the loop depending on that risk. The person accountable sits on or out of the loop depending on that same risk. Laid out, it looks something like this:
| Risk if it’s confidently wrong | Responsible (builds and runs it) | Accountable (owns the outcome) |
|---|---|---|
| High | In the loop, approving each action | On the loop, aware and able to stop it |
| Moderate | On the loop | On the loop |
| Low | On the loop | Out of the loop, reviewing results and owning the risk decision |
Now look at where the circles overlap. The responsible person moves between in and on. The accountable person moves between on and out. The only place both of them can stand is on the loop. That’s the intersection of the Venn diagram, and it’s where I think most enterprise automation should live once it has earned some trust. Both know what the automation does, and both have a real way to stop or steer it from their own side of the business.
That overlap is the answer to the question I started with. If the only person who understands the agent is the engineer who built it, you didn’t remove a dependency. You built a new one with a nicer interface. Putting the responsible and accountable parties in different domains, and giving both of them a seat on the loop, means the understanding of the automation lives outside any single knowledge domain. That’s the same fight I wrote about in Key-Person Risk in Technology, just with a robot in the middle of it. It also gives you honest separation of duties: the person who wants the change done fast isn’t the only one who can stop it.
I’m not the only one drawing it this way. Article 14 of the EU AI Act says human oversight of high-risk AI systems should be commensurate with the risks, the level of autonomy and the context of use. It also calls for the people doing that oversight to stay aware of automation bias, and to be able to interrupt the system with a “stop” button or a similar procedure that brings it to a halt in a safe state. That’s on the loop, written by lawyers. The ISA/IEC 62443 series for industrial control systems lists shared responsibility as a founding principle. And the NIST AI Risk Management Framework puts Govern alongside Map, Measure and Manage as one of its four core functions, which is where roles and accountability get spelled out.
Confidently Capable Has to Be Earned
Here’s the thing about a language model’s confidence: it’s a property of the text, not of the answer. The model sounds exactly as sure when it’s wrong as when it’s right. So “confidently capable” can’t mean the agent sounds confident. It has to mean we are confident, because we measured it.
Think of how we bring along a new engineer. Nobody gets enable on the core on day one. An agent should climb the same ladder and show its receipts at every rung:
- Shadow mode. The agent proposes, a human executes, and you compare the two.
- Test against known-good. Score the agent against tasks with known correct answers (golden configs, past tickets with verified resolutions, lab scenarios). Measure accuracy before you widen autonomy, not after.
- In the loop. The agent executes only after approval. Track how often humans edit or reject what it proposes. That override rate is your best early warning.
- On the loop. The agent executes within its blast radius limits while people watch. This is earned, not granted.
- Keep the demotion path. A new model version is a change, and so is a new tool. Either one, or a drop in accuracy, sends the agent back down a rung until it proves itself again.
One pattern I’d recommend at every rung is splitting the builder from the reviewer. When I had two agents take a blank router to a working config in my home lab, the most important piece wasn’t the configuration agent. It was the QA agent checking its work against what I’d asked for. (I wrote that up in AI Agents and Network Engineering.) Whoever builds the change shouldn’t be the only one who checks it, whether it’s a person or an agent.
Security: Treat the Agent Like a New Kind of Identity
An agent is a new kind of identity. It needs its own credentials, scoped to the job, short-lived, and minted for the system it’s actually talking to. It should never borrow a person’s identity, and it should never share one with three other agents “because it was easier.”
The OWASP Top 10 for LLM Applications has a name for what goes wrong here: Excessive Agency. OWASP traces it to excessive functionality, excessive permissions and excessive autonomy, and one of its strongest recommendations is complete mediation, meaning authorization is enforced in the downstream systems rather than leaving it to the model to decide whether an action is allowed. One more time for the folks in the back: the model is not your access control. The systems behind the tools are.
Then there’s prompt injection. Instructions can hide inside anything an agent reads: a ticket, a log line, a tool description, or a web page with hidden text addressed to AI agents. The MCP specification itself says tool descriptions should be treated as untrusted unless they come from a trusted server. The rule I’d build around is simple. Only the human principal gives instructions. Everything else the agent reads is data, no matter how politely it asks.
Finally, log like you’ll need it in court. Every tool call should record who asked, which agent acted, which credential it used and what it changed. OpenTelemetry has GenAI semantic conventions for agent and MCP tracing (still in Development status), so one trace can follow a task from the ask all the way down to the device. That’s the Telemetry plane earning its keep.
Compliance and Governance, Especially in OT
In OT and other regulated environments, the bar is higher because the consequences are physical. I wrote about how even reading from a plant floor can tip things over in Safe OT Asset Discovery. An agent doing discovery or troubleshooting in OT has to follow the same slow, careful rules a person would: passive first, selective queries done the gentle way, and nothing that writes without a human in the loop. In those environments, I’d expect the responsible person to stay in the loop for any change for a long time, and that’s fine. Slow is smooth, smooth is fast.
The good news is that the frameworks line up with the engineering. Beyond the AI RMF itself, NIST has published a Generative AI Profile (NIST AI 600-1) and, in April 2026, a concept note for a profile on trustworthy AI in critical infrastructure. None of them will design your guardrails for you, but if you build the controls above and keep the receipts, you’ll have most of what an auditor is going to ask for.
(Usual disclaimer: this is my engineering opinion, not legal or compliance advice. Check the current text of any regulation with whoever owns compliance in your shop.)
Token Efficiency Is an Architecture Decision
Here’s the part of the conversation that usually shows up late, right around the first invoice. Tokens are the new bandwidth bill. Overbuy and you pay for capacity you don’t use. Underbuy and you hit rate limits in the middle of the workday, and I’ve already written about how AI inference rationing could make that worse before it gets better. It’s an architecture decision, and it belongs in the same design review as safety and security.
Right-size the model. Not every task needs a frontier model. Classification, extraction, routing and summarizing a show command can often go to a smaller, cheaper model, saving the big one for the reasoning that actually needs it.
Cache what repeats. Providers offer prompt caching so a request can resume from a prefix they’ve already processed, which Anthropic describes as significantly reducing processing time and cost for repetitive prompts. Put the stable stuff first (system instructions, tool definitions, reference material) and the stuff that changes last, so the cache actually hits.
Trim the context. Every token you send gets processed before the first word comes back. That’s the prefill step I traced in What Actually Happens When You Hit Enter on an AI Prompt. Bolting sixty tool servers onto one agent drowns the model in tool descriptions and runs up the bill on every turn. Agent Skills are a good model here: only a short name and description load up front, and the full instructions load when the task calls for them.
Retrieve, don’t stuff. Pull the three relevant pages of the runbook, not the whole binder.
Batch what can wait. Nightly compliance reports, config audits and ticket classification don’t need an answer in two seconds. OpenAI’s Batch API, for example, advertises a 50% discount compared to its synchronous APIs, with each batch completing within 24 hours. If it can wait until morning, let it.
Own the steady, rent the burst. Predictable, steady workloads are where local or on-prem inference starts to make sense, and bursty or frontier-grade work is where renting from the cloud usually wins. I built a free rent vs. own vs. hybrid TCO model for exactly this decision, and Run Your Own AI at Home for the Price of a Gaming PC covers the hardware side at small scale. The catch with owning is utilization. An idle GPU depreciates just the same as a busy one, so if you buy hardware, keep it fed.
Measure cost per completed task, not cost per token. A cheap model that needs three retries and a human cleanup isn’t cheap. Give each agent a token budget (in AIM terms, budgets are part of the Trust plane), track spend in your telemetry right next to accuracy, and let both numbers decide where a workload runs.
A Pre-Flight Checklist Before an Agent Touches Production
If I were sitting in the design review, these are the questions I’d want answered out loud before anything gets turned loose:
- Who is responsible for this automation, and who is accountable for it? Are they different people in different parts of the business?
- What is the assessed risk if it’s confidently wrong, and where does each of them sit relative to the loop because of it?
- What identity does the agent use? Is it scoped, short-lived and its own?
- What’s the largest thing it can change in one run, and how fast?
- Is there a dry run, a diff and a canary stage, and what result stops the rollout?
- How does it roll back, and has anybody tested that?
- What happens when the source of truth is missing or stale?
- Where’s the kill switch, and does the accountable person have access to it too?
- What accuracy did it show against known-good tasks, and what drop sends it back down a rung?
- Could somebody other than the builder explain what it does and stop it at 2 AM?
Hope Isn’t a Strategy, and Neither Is a Confident Model
None of this is brand new. Least privilege, change windows, canaries, rollback, separation of duties and audit trails are the same tools we’ve used for decades to keep people from taking down production. What’s new is the speed and the confidence. An agent sounds just as sure of itself on its worst day as on its best, so the guardrails have to do the doubting for it.
Automate the work. Don’t try to automate responsibility or accountability. Put them with different people, give both of them a seat on the loop, limit the blast radius before you widen the autonomy, and make the machine earn every inch it gets. Do that, and AI stops being the next thing only a few engineers understand. It becomes something the whole business can see, steer and stop.
If you’re working through this in your own shop, or you think I’ve put somebody on the wrong side of the loop, I’d like to hear about it. My contact page is open, and so are my LinkedIn comments.
Sources
- EU AI Act, Article 14: Human Oversight
- NIST AI Risk Management Framework, including the Generative AI Profile (NIST AI 600-1) and the critical infrastructure profile concept note
- ISA, ISA/IEC 62443 Series of Standards
- OWASP Gen AI Security Project, LLM06:2025 Excessive Agency
- Model Context Protocol specification, revision 2026-07-28
- OpenTelemetry semantic conventions for generative AI
- Anthropic, Prompt caching documentation
- OpenAI, Batch API guide
- The Agent Interconnection Model (AIM)

No responses yet