C1 to C5IfC1PolicyC2Isn’tC3EnforcedC4EverywhereC5
C5 to C1EveryC5EngineerC4InspectsC3PastC2IncidentsC1
Two I layers and two E layers. Going forward, Intent (the why) comes before Identity (the who), and Enforcement (the gate) comes before Evidence (the record).
The model in one paragraph
This page lays out a five-layer control model for AI agents, built the way network engineers already separate the control plane from the data plane. Agents decide and act. Control planes govern. Execution environments enforce. Systems produce evidence. ACM is the companion to my Agent Interconnection Model (AIM): AIM maps how an agent’s work flows, and ACM maps who gets to say yes, under what conditions, and how you prove it later. It’s a working draft and a mental model, not a standard.
What this is, and why I wrote it
When I drew AIM, I put two skinny bars down the right side of the stack and called them the Trust plane and the Telemetry plane. That was honest, but it was also a cop-out. Those two bars are where almost every hard question about agents in production actually lives, and I squeezed them into a couple of sentences.
Here’s the question those bars were hiding: should this action happen at all, under what conditions, with whose authority, and how do we prove it later? MCP doesn’t answer that, and it was never supposed to. Neither does A2A, Agent Skills, or OpenTelemetry. Each one does its own job well, and each one quietly assumes somebody else is handling governance.
Plenty of smart people are working on that somebody else. Analyst firms have published control plane reference models, researchers are posting multi-plane governance architectures on arXiv, OWASP has a runtime control standard, NIST has an agent standards initiative and an identity project, and the IETF and OpenID Foundation are shipping the identity and authorization plumbing underneath. I’ve listed them in the related work section below, and I give credit where I borrowed. What I couldn’t find was a short, practical, layered map that an engineer can carry around in their head and use in a design review or at 2 AM during an incident. That’s the gap I’m trying to fill.
Network folks solved a version of this problem a long time ago. A router has a data plane that forwards packets as fast as it can, and a control plane (plus a management plane) that decides what the data plane is allowed to do. Nobody lets the forwarding ASIC make up its own routing policy. AAA, ACLs, 802.1X, TACACS+ command authorization, syslog and NetFlow all exist because we learned the hard way that “the box did what it was told” and “the box was allowed to do it” are two different questions. Agents need the same split, and the industry doesn’t have a common vocabulary for it yet.
Same disclaimer as AIM: I’m not proposing this to anybody. The layer names, the order and the boundaries are my opinion. I fully expect to move things around as the standards settle.
How to read this page. Facts about the standards and efforts I cite are current as of the drafted date above, with sources at the bottom. Anything marked My take is opinion. The YAML and JSON examples are illustrative sketches, not a spec.
The model at a glance
ACM is numbered in the order a control decision gets built, C1 to C5. The C stands for control, and it keeps ACM layers from getting confused with AIM’s L1 to L7 when I map one onto the other.
The full layer names are C1 Intent, C2 Policy & Authority, C3 Identity & Delegation, C4 Enforcement and C5 Evidence. I shorten them in tables.
↓ C4 evaluation points sit on the AIM data path, L7 to L1 ↓
Read it top to bottom, in the order a control decision gets built: why, the rules, who, the gate, the record. The forward mnemonic runs down the left; the backward one, the order you walk after an incident, runs up the right (on a phone they sit inside each band). C4 is highlighted because that’s where ACM touches AIM. The two bars on the right cut across every layer.
Remembering the order
AIM got “In Real Change Control, Capture Every Rollback.” ACM gets two of its own, one for each direction you’ll actually walk it:
- Forward, C1 to C5: If Policy Isn’t Enforced Everywhere. (Intent, Policy, Identity, Enforcement, Evidence) That’s the design direction, and honestly it’s the whole thesis in four words plus an implied “you don’t have a control plane.”
- Backward, C5 to C1: Every Engineer Inspects Past Incidents. (Evidence, Enforcement, Identity, Policy, Intent) That’s the forensic direction. After something goes wrong you start with the record and walk back up to what the agent was supposed to be doing.
The tricky part is that there are two I layers and two E layers. Going forward, the first I is Intent (the why) and the second is Identity (the who). The first E is Enforcement (the gate) and the last is Evidence (the record). The gate always comes before the record.
The five layers
Intent
An explicit, machine-readable declaration of why the agent is working, what it’s allowed to touch, what done looks like, and what it must not do.
- What lives here
- The purpose of the run, its scope (systems, data, time window), success criteria, explicit non-goals, the human or agent that asked for it, and an expiry. The key word is referenceable: the mandate has an ID, and every later decision can point back to it at runtime.
- Real-world examples and protocols
- A change ticket with a method of procedure and a backout plan. A spec in a spec-driven development workflow. A task handed over A2A with its context. The goal and constraints section of an
AGENTS.md. None of these is a standard mandate format for agents yet, and that’s part of the gap. - Data unit
- the mandate. One task’s purpose, scope, done criteria and non-goals, with an ID and an expiry.
- When it breaks
- The goal was vague so the agent invented one. Scope crept because nothing said where the edges were. A prompt injection quietly swapped the goal (OWASP lists agent goal hijack as the first risk in its Top 10 for Agentic Applications). Or the agent declared success against criteria nobody wrote down.
My take: If you can’t write the intent down in a few lines, you’re not ready to let an agent act on it. Network engineers already know this one: no MOP, no change window. A mandate is just a MOP an agent can read and a policy engine can check against.
Policy & Authority
The rules that decide what’s allowed, what’s forbidden, what needs a human, and what it’s allowed to cost.
- What lives here
- Authority tiers, constraints, cost and token ceilings, rate limits, risk classifications for tools and actions, data handling rules, and escalation paths. I use three authority tiers, the same way I’d think about privilege levels on a switch:
- Tier A, agent free: the agent decides and acts. Read-only lookups, drafts, anything easily undone.
- Tier R, AI recommends, human decides: the agent proposes and a named human approves. Production writes, spending money, anything customer-facing.
- Tier H, human only: the agent can gather context but never executes. Irreversible, regulated or safety-critical actions.
- Real-world examples and protocols
- Policy-as-code engines like Open Policy Agent (Rego) and Cedar. The OpenID AuthZEN Authorization API 1.0, a final specification since January 2026, which standardizes how an enforcement point asks a decision point for an answer. On the governance side, the NIST AI Risk Management Framework gives you the risk vocabulary, not the rules.
- Data unit
- the rule. One condition and its outcome, versioned and shipped inside a policy bundle.
- When it breaks
- Policy lives in the system prompt, so it’s a suggestion, not a control. Rules are so broad that everything ends up at Tier A, or so tight that everything goes to a human and people rubber-stamp approvals. Cost ceilings don’t exist until the bill shows up. Two policy engines disagree and nobody knows which one won.
My take: A system prompt is not a policy. It’s a strongly worded request to a statistical model. Real policy is evaluated outside the model, by something that can’t be talked out of it. If the rule only exists in the prompt, I count it as missing.
Identity & Delegation
Establishes who is acting, on whose behalf, and with how much of their authority, as work passes from person to agent to agent to tool.
- What lives here
- A portable agent identity, binding to an accountable human owner or sponsor, delegation chains, capability attenuation (every hop can only narrow authority, never widen it), time limits on every grant, and identity propagation across MCP, A2A and plain APIs. It also covers composite principals: the real actor is often “this agent, running this model, on behalf of this user, under this mandate,” and authorization has to consider all of it.
- Real-world examples and protocols
- OAuth 2.0 Token Exchange (RFC 8693), which already defines how to swap one token for another and how to record an actor acting on behalf of a subject. The Identity Assertion JWT Authorization Grant (ID-JAG), an IETF OAuth working group draft that the MCP project uses in its enterprise-managed authorization extension, so a company’s identity provider can decide which MCP servers an agent’s client may reach. SPIFFE for workload identity. MCP’s own OAuth 2.1 based authorization at Layer 3.
- Data unit
- the grant. A credential plus its claims: who, on behalf of whom, which audience, which scopes, which mandate, and until when.
- When it breaks
- Everything runs as one shared service account, so the logs say “svc-agent did it.” A sub-agent inherits the parent’s full token instead of a narrowed one. A token minted for one server gets replayed at another. The human sponsor left the company and the agent kept running. Nobody can tell whether a write came from the person or the agent acting for them.
My take: Delegation has to work like summarizing routes on the way out of an area: you can always advertise less than you received, never more. If a sub-agent can end up with more authority than the agent that spawned it, your model is broken, no matter how good the rest of it is.
Enforcement
Evaluates a proposed action at a defined point in the agent’s run and returns a verdict that the execution environment actually carries out.
- What lives here
- Evaluation points, the policy enforcement point (PEP) that intercepts the action, the decision point (PDP) that answers, and the verdict. ACM uses five verdicts:
- Allow: go ahead as proposed.
- Deny: stop, with a reason the agent and the log can both read.
- Modify: go ahead with changes, like a narrower query, a redacted field or a lower limit.
- Pause for approval: hold the action until a named human says yes or no, with a timeout that defaults to no.
- Escalate: hand the decision up to a higher authority tier or a different owner.
- Real-world examples and protocols
- The OWASP GenAI Security Project’s Agent Control Standard (ACS), which defines hooks where an agent asks a separate Guardian before it acts, and the Guardian answers allow, deny, modify, ask or defer. MCP gateways, which the 2026-07-28 MCP spec made easier by putting the method and tool name in HTTP headers. AuthZEN, for the PEP to PDP call. Sandboxes and network egress controls at AIM Layer 2.
- Data unit
- the verdict. One decision about one proposed action at one evaluation point, with the rule and grant that produced it.
- When it breaks
- The check is advisory and the action runs anyway. The check fails open when the policy engine times out. The agent found a path around the enforcement point, like a skill script calling an API directly. The verdict was “modify” but nobody verified the modification took. Approval prompts piled up until a human clicked yes on all of them.
My take: Enforcement that the agent can skip is just telemetry with extra steps. The enforcement point has to sit in the path, outside the model, and fail closed. It’s the same lesson as a firewall in monitor mode: useful for learning, useless for protection.
Evidence
Produces a structured, tamper-evident record that lets anyone reconstruct intent, policy decision, action and outcome for any agent run.
- What lives here
- Evidence events for every mandate, verdict, grant, action and outcome, all linked by IDs. Hash chaining or signing so edits show. Retention, export to the SIEM, and the ability to replay a run’s decisions against a newer policy version.
- Real-world examples and protocols
- OpenTelemetry’s GenAI semantic conventions, which already define spans for agent invocation and tool execution, though they’re still in Development status. OCSF as a security event schema. The trace context MCP carries in
_meta. ACS’s hash-chained Guardian audit record. On the network side, TACACS+ accounting, syslog and IPFIX. - Data unit
- the event. One timestamped, signed or chained record of something that happened, pointing back to its mandate, grant and verdict.
- When it breaks
- You have logs but they don’t connect, so you can see the API call but not the intent or the approval. The agent’s own narration is the only record (that’s a story, not evidence). Logs can be edited by the same identity that did the work. Prompts and outputs with sensitive data got logged in the clear. Or retention ran out before the auditor showed up.
My take: The agent’s explanation of what it did is not evidence. Models can and do confidently report success on changes that never happened. Evidence comes from the systems around the agent: the gateway, the PDP, the device, the API. If the only witness is the defendant, you don’t have an audit trail.
The cross-cutting controls
Like the Trust and Telemetry planes in AIM, these aren’t layers you stack. They show up at every layer.
Safety controls
The things you reach for when the model above isn’t enough. A kill switch that stops one agent, one mandate, or every agent at once, and actually revokes grants instead of asking nicely. Circuit breakers that trip automatically on error rates, denied-action rates, loops or anomalous spend, the same way storm control or err-disable shuts a port before it takes down the switch. Budgets and rate limits on tokens, money, tool calls and writes per minute. Human-in-the-loop wired into C2 tiers and C4 pause verdicts, with timeouts that default to no and approval screens that show the diff, not just a yes button.
Lifecycle
Every artifact in ACM is versioned: mandates, rules, policy bundles, identity descriptors and evidence schemas. Policy goes through the same path as a config change: write it, test it against recorded runs, run it in shadow mode where verdicts are logged but not enforced, enforce it, and eventually retire it. Every verdict records the policy version that produced it, so you can answer “would the new rule have stopped last Tuesday’s incident?” by replaying the evidence.
How ACM complements AIM
AIM is the data plane: how a task flows from Interaction at L7 down to a Resource at L1. ACM is the control plane: whether each step along that path is allowed. AIM’s Trust plane breaks out into ACM’s C1 through C4, and AIM’s Telemetry plane is where ACM’s C5 gets most of its raw material.
The place they meet is the evaluation point. Each one sits at a specific AIM layer:
| Evaluation point | When it fires | AIM layer | Typical verdicts | Network analogy |
|---|---|---|---|---|
| EP1 Task intake | A task arrives and gets bound to a mandate | L7 Interaction | Allow, deny, escalate | Change ticket approved before the window opens |
| EP2 Context load | Sensitive data is about to enter the context window | L5 Context | Allow, modify (redact), deny | Data classification at a DLP inspection point |
| EP3 Skill activation | A skill loads or a new one gets installed | L4 Capability | Allow, deny, pause | Approved software image list |
| EP4 Tool invocation | Before an MCP tools/call or equivalent |
L3 Connectivity | All five | TACACS+ per-command authorization |
| EP5 State-changing action | Before any write to a system of record | L1 Resource (through L3 or L2) | Pause, allow, deny, modify | commit confirmed on a change |
| EP6 Code execution | Before a script or command runs | L2 Execution | Allow, deny, modify (sandbox) | Control plane policing |
| EP7 Memory write | Before anything persists beyond this run | L5 Context | Allow, modify, deny | Writing to startup config |
| EP8 Sub-agent spawn or delegation | Before an agent hands work or authority to another agent | L7 (A2A) or L3 | Allow with attenuated grant, deny, escalate | Route summarization at an area border |
| EP9 Outbound egress | Before results, messages or data leave the boundary | L7 Interaction | Allow, modify, pause, deny | Egress ACL at the edge |
| EP10 Completion | The agent claims the task is done | L7 Interaction | Allow (close), escalate | Post-change verification against the MOP |
EP10 is the one I’d add first if you only add one. An agent declaring success is a claim, and the control plane should check that claim against the mandate’s success criteria and the actual state of the systems before the task closes. That’s the idea behind what I call a gap metric: measure the difference between what the agent says happened and what the systems say happened.
My take: Ten evaluation points sounds like a lot. Start with EP4, EP5 and EP10. That’s the tool call, the write, and the claim of victory. Most of the expensive failures I can imagine go through one of those three.
Mapping to how networks already do this
My take, start to finish. Same deal as the OSI mapping on the AIM page: it’s an analogy, so I’m grading each row honestly.
Control plane versus data plane
| Network concept | ACM equivalent | Does it hold? | Why |
|---|---|---|---|
| Data plane forwarding | AIM’s L1 to L7 path | Holds | The work itself. Fast, high volume, and it shouldn’t be making policy up as it goes. |
| Control plane (routing protocols, policy) | ACM C1 to C4 | Holds | Decides what the data path is allowed to do, separately from doing it. |
| Management plane (AAA, syslog, SNMP, NetFlow) | ACM C3 and C5 | Holds pretty well | Who’s logged in, what they ran, and what happened. |
| Route policy (route-maps, prefix lists) | C2 rules | Holds | Declarative match and action, evaluated outside the forwarding decision. |
| Route summarization at area borders | C3 capability attenuation | Holds by role | You advertise less than you learned. Grants should only shrink as they move outward. |
| Control plane policing (CoPP) | Safety controls: budgets and rate limits | Holds | Protect the expensive thing from being overrun, even by legitimate traffic. |
| Intent-based networking | C1 Intent | Weak | IBN intent is mostly about desired network state. Agent intent includes purpose and non-goals, which a network never needed. |
AAA, with a why
Classic AAA is Authentication, Authorization and Accounting. ACM is basically AAA with a why stapled on the front.
| AAA piece | Network protocol | ACM layer | What ACM adds |
|---|---|---|---|
| (nothing) | Change ticket, MOP | C1 Intent | A machine-readable reason the session exists, checked at runtime |
| Authentication | 802.1X, RADIUS, TACACS+ | C3 Identity | Delegation chains and composite principals: agent plus model plus user plus mandate |
| Authorization | TACACS+ command authorization, privilege levels | C2 Policy and C4 Enforcement | Authority tiers, cost ceilings, and verdicts richer than permit or deny |
| Change of authorization | RADIUS CoA (RFC 5176) | C4 mid-run verdicts, kill switch | Revoking or narrowing a live agent’s grant without waiting for it to finish |
| Accounting | TACACS+ accounting, syslog, NetFlow/IPFIX | C5 Evidence | Linking every action back to intent and the decision that allowed it |
Where the analogy breaks for real
- The data plane has opinions. A forwarding ASIC doesn’t argue with its FIB. An agent reasons, plans and can be manipulated by what it reads. Enforcement has to assume the thing being governed may actively look for a way around the rules.
- Intent is new. Networks never needed a “why” field on a packet. Agents do, because the same API call can be fine for one purpose and a disaster for another.
- Authority moves sideways. In a network, a user’s privilege level doesn’t hop from switch to switch. In agent systems, authority gets handed from person to agent to sub-agent to tool, and every hop is a chance to widen it by accident.
- The verdicts are richer. An ACL permits or denies. Agent enforcement also needs modify, pause and escalate, because “no” is often the wrong answer and “yes, but narrower” is the right one.
- Nobody blessed this one either. AAA has RFCs. ACM has a guy with a website. Same bar as AIM: useful as a way to think, or it’s not useful at all.
The portable artifacts
ACM doesn’t define a wire protocol. It argues that three artifacts should be portable, meaning they travel with the agent across platforms, clouds and vendors instead of being locked inside one product. Forrester has made a similar point about the lack of a standard, portable agent identity descriptor. These sketches are illustrative only. Field names are mine, not anybody’s standard.
1. Agent identity descriptor (C3)
Who the agent is, who answers for it, and the most it could ever be allowed to do.
# agent-identity.yaml (ACM v0.1 illustrative sketch)
acm_version: "0.1"
agent_id: "spiffe://example.net/agents/vlan-change-bot"
display_name: "VLAN change agent"
sponsor:
owner: "neteng-oncall@example.net" # accountable humans, not a person who might leave
escalation: "neteng-manager@example.net"
runtime:
models: ["approved-model-family-a"]
skills: ["change-window-precheck@1.4.2"]
mcp_servers: ["netbox-mcp", "switch-config-mcp"]
max_authority: # ceiling; every grant is a subset
tier: "R" # AI recommends, human decides
scopes: ["dcim:read", "switch:config:vlan"]
cost_ceiling_usd_per_day: 25
delegation:
may_spawn_subagents: true
attenuation: "strict" # children get a subset, never a superset
max_chain_depth: 2
2. Policy bundle (C2)
A versioned set of rules a PDP loads. In real life this compiles to Rego, Cedar or whatever engine you run. ACM cares about what the bundle has to express, not the syntax.
# policy-bundle.yaml (illustrative)
bundle: "neteng-agents"
version: "2026.11.21-1"
mode: "shadow" # shadow -> enforce, per the lifecycle
defaults:
verdict_on_error: "deny" # fail closed
approval_timeout: "15m" # unanswered approval = deny
rules:
- id: R-READ-001
match: { action_class: "read", system: "dcim" }
tier: A
verdict: allow
- id: R-VLAN-010
match: { action_class: "write", tool: "switch.vlan.set" }
tier: R
verdict: pause_for_approval
require: ["mandate.change_ticket", "window.open"]
- id: R-CORE-001
match: { action_class: "write", device_role: "core" }
tier: H
verdict: deny
reason: "Core changes are human only."
- id: R-COST-001
match: { spend_today_usd: { gt: 25 } }
verdict: escalate
3. Evidence event (C5)
One event per verdict, chained to the one before it, with enough IDs to rebuild the whole story.
{
"acm_version": "0.1",
"event_id": "evt-000412",
"time": "2026-11-21T19:42:07Z",
"trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
"mandate_id": "MND-CHG-48213",
"principal": {
"agent": "spiffe://example.net/agents/vlan-change-bot",
"on_behalf_of": "user:jdoe",
"grant_id": "grt-7f2c",
"chain_depth": 1
},
"evaluation_point": "EP5_state_change",
"action": { "tool": "switch.vlan.set", "target": "idf2-sw03", "params_hash": "sha256:9c1e..." },
"verdict": "pause_for_approval",
"rule_id": "R-VLAN-010",
"policy_version": "2026.11.21-1",
"approval": { "by": "user:rsmith", "result": "approved", "at": "2026-11-21T19:44:51Z" },
"outcome": { "status": "applied", "verified_by": "show vlan brief diff", "matches_intent": true },
"prev_hash": "sha256:51d0...",
"hash": "sha256:e8a4..."
}
I’d expect a real version of this to ride on OpenTelemetry spans and land in the SIEM as OCSF, not to invent its own pipeline. The ACM-specific parts are the fields that link an action back to a mandate, a grant, a rule and a policy version.
What ACM is not (non-goals)
Knowing what a model leaves out is half of knowing where it fits.
| ACM doesn’t… | That belongs to… |
|---|---|
| Replace MCP, or define how agents reach tools | MCP, at AIM L3. ACM says where MCP calls get evaluated. |
| Replace A2A, or define how agents talk to each other | A2A, at AIM L7. ACM says what authority rides along. |
| Replace Agent Skills | Agent Skills, at AIM L4. ACM treats skill activation as an evaluation point. |
| Replace OpenTelemetry, OCSF or your SIEM | Those carry the events. ACM says which fields the evidence needs. |
| Replace OPA, Cedar or any policy engine | Engines evaluate rules. ACM says what the rules have to cover. |
| Replace OAuth, RFC 8693, ID-JAG or SPIFFE | Those move identity. ACM says delegation has to attenuate. |
| Compete with OWASP ACS | ACS is a wire-level runtime control standard. If it wins, it’s a great way to implement C4 and part of C5. |
| Govern model training, alignment or content safety | Model providers and AI safety work. ACM governs delegated action, not what the model thinks. |
| Act as a compliance framework | NIST AI RMF, ISO/IEC 42001, the EU AI Act and your auditors. ACM can help you produce their evidence. |
| Pick a vendor | Nobody. ACM is vendor neutral on purpose, because the whole point is portability. |
How to use the model
1. Design reviews
Walk a proposed agent down the five layers and make somebody answer one question per layer:
- C1: Where’s the mandate written down, and what are the non-goals?
- C2: Which actions are Tier A, R and H, what’s the cost ceiling, and who gets the escalation?
- C3: What identity does it run as, who’s the sponsor, and how does authority shrink when it delegates?
- C4: Which evaluation points are in the path, and does each one fail closed?
- C5: Could you reconstruct last Tuesday’s run from the evidence alone, without asking the agent?
- Cross-cutting: Where’s the kill switch, what trips the breaker, and which policy version is live?
If a team can’t answer a layer, that’s your risk register. Same as AIM.
2. Troubleshooting: which control failed?
AIM tells you which layer of the agent broke. ACM tells you which control let it happen.
| Symptom | Likely layer | First thing to check |
|---|---|---|
| Agent did something reasonable that nobody actually asked for | C1 Intent | Was there a written mandate with scope and non-goals? Was it bound at intake? |
| Agent did something it was told not to do | C2 Policy | Was the rule in a policy engine, or only in the prompt? |
| Approvals happen but nobody reads them | C2 / Safety | Too many actions in Tier R? Does the approval screen show the diff? |
| Logs say a service account did it, and nobody knows who asked | C3 Identity | Is the on-behalf-of user carried in the grant? Is there a sponsor? |
| Sub-agent could do more than its parent | C3 Identity | Did the delegation attenuate, or pass the whole token down? |
| Policy said deny, the action happened anyway | C4 Enforcement | Was the check advisory? Did it fail open? Is there a path around the PEP? |
| Agent said it succeeded, the device says otherwise | C4 / C5 | Is there an EP10 completion check against real system state? |
| Can’t tell why something was allowed | C5 Evidence | Does every verdict record its rule ID, grant ID and policy version? |
| Runaway spend or a loop that won’t stop | Safety controls | Budgets, rate limits and breaker thresholds. Does the kill switch revoke grants? |
3. Maturity, the honest version
You don’t need all five layers on day one. A sane order, the way I’d roll it out on a network team:
- Evidence first (C5). Turn on structured logging and tracing before you enforce anything, so you can see what the agents actually do.
- Identity next (C3). Give every agent its own identity and a human sponsor, and kill the shared service accounts.
- Policy in shadow mode (C2). Write the tiers and rules, and log the verdicts without enforcing them.
- Enforce at three points (C4). Tool call, write and completion. Fail closed.
- Mandates everywhere (C1). Require a written intent for anything above Tier A.
My take: That order is the opposite of the layer numbers, and that’s fine. You design top down and you deploy bottom up. Same as building a network: you plan the routing policy first, but you rack the switches and turn on logging before you trust any of it.
Related work
ACM stands on a lot of other people’s work, and I’d rather over-credit than under-credit. Here’s how I see the landscape as of November 2026.
- Futurum Agent Control Plane Framework (ACPF). Published by Futurum analyst Mitch Ashley on April 3, 2026. A five-layer reference architecture (Layer 0 Execution Environment, Layer 1 Knowledge Authority, Layer 2 Behavior Guardrails, Layer 3 Governance, Layer 4 Coordination) with three cross-cutting foundations (Observability-Native, Governance and Trust, Open Ecosystem), aimed at procurement, vendor roadmaps and standards bodies. ACM’s one-line summary is ACPF’s foundational principle: “agents decide, control planes govern, execution environments enforce, and systems generate evidence.” I think that’s exactly right, and I’m borrowing it with credit. Where ACM differs is the cut: ACPF organizes by capability area for buyers and vendors, and ACM organizes by the question an engineer asks at each step of one decision, with a data unit per layer and a mapping onto AIM. The full ACPF report is subscription-only, so I’m working from the public summary.
- Forrester’s three-plane model. Introduced by Forrester’s Leslie Joseph in December 2025: a build plane, an orchestration plane, and an agent control plane that sits outside both so governance stays independent. A March 2026 follow-up argued the standards stack under control planes is incomplete, and called out the lack of a portable agent identity descriptor in particular. ACM’s identity descriptor is my sketch of what that might hold.
- “A Five-Plane Reference Architecture for Runtime Governance of Production AI Agents” (Krti Tallam, arXiv 2606.12320, June 2026). A reasoning plane that adjudicates intent and authority, plus four enforcement planes (network, identity, endpoint, data). It introduced composite principals with capability attenuation through delegation chains, “stop-anywhere” mediation, six interruption primitives that generalize allow and deny (pause, escalate, narrow, modify, defer, rollback), and audit as a structured evidence substrate. ACM’s C3 and C4 owe a lot to it. Other recent arXiv papers propose intent-aware control planes and unified policy architectures; the area is busy.
- OWASP Agent Control Standard (ACS). Part of the OWASP GenAI Security Project. Defines hooks at an agent’s decision points, a separate Guardian that returns allow, deny, modify, ask or defer, signed JSON-RPC messages, a hash-chained audit record, mapping to OpenTelemetry and OCSF, and an Agent Bill of Materials (AgBOM). The current release is v0.1.5 with reference adapters and Guardians. It’s the closest thing I’ve seen to a wire protocol for ACM’s C4.
- NIST. The AI Risk Management Framework (AI RMF 1.0) is the governance vocabulary most US organizations already use. In February 2026, NIST’s Center for AI Standards and Innovation (CAISI) launched the AI Agent Standards Initiative, and the NCCoE published a concept paper on applying identity and authorization standards to software and AI agents, covering identification, authorization, access delegation, and logging and transparency. The NCCoE has since stood up a project resource hub and says the end product will be an SP 1800 practice guide. That’s C3 and C5 territory, and I’ll be watching it closely.
- Identity plumbing. OAuth 2.0 Token Exchange (RFC 8693) and its actor claims for delegation. The Identity Assertion JWT Authorization Grant (ID-JAG), an IETF OAuth draft used by MCP’s enterprise-managed authorization extension. SPIFFE for workload identity. These are the parts ACM’s C3 assumes rather than reinvents.
- Policy plumbing. OPA/Rego and Cedar as policy engines, and the OpenID AuthZEN Authorization API 1.0 for the PEP to PDP call.
- Risk taxonomies. The OWASP Top 10 for Agentic Applications, published December 2025, is a good list of what C1 through C5 are supposed to stop.
My take: These efforts aren’t competing so much as working at different heights, the same way MCP, Skills and A2A turned out to be. Analyst models help buyers. Research architectures prove properties. ACS is a wire protocol. NIST and the IETF are building the identity floor. What I want ACM to be is the map that lets you point at any of them and say which layer it covers and which it leaves open.
Open questions (what might change)
All opinion. These are the spots where I’d bet the model moves.
- Is Intent really a control layer? You could argue a mandate is just L7 data in AIM. I keep it in ACM because the control plane has to reference it at runtime, and because “why” is the field every other governance model leaves out.
- Should Identity come before Policy? In AAA, authentication comes first. I put policy first because you can write the rules before you know which agent will run them, but I could see flipping C2 and C3.
- Will one verdict vocabulary win? ACS uses allow, deny, modify, ask and defer. The five-plane paper uses six interruption primitives. ACM uses five. I’d happily adopt whichever one the industry settles on.
- Does ACS become the wire format for C4? If it does, ACM gets simpler, and that’s a good outcome.
- How tamper-evident is tamper-evident enough? Hash chains and signing cover most cases. Whether anyone needs more than that for agent evidence is an open question.
- Where do evals live? Same unresolved question as AIM. Pre-deployment evals feel like Lifecycle. Runtime evals feel like C4.
- Can intent be checked, or only recorded? Checking an action against a mandate’s scope is easy. Checking it against a mandate’s purpose is a judgment call, and judgment calls tend to end up back at a model or a human.
Glossary
- ACM (Agent Control Model): This page. A five-layer control model for AI agents: Intent, Policy & Authority, Identity & Delegation, Enforcement, Evidence.
- AIM (Agent Interconnection Model): My seven-layer model of the agent data path, with MCP as the narrow waist at L3. ACM’s companion.
- ACM mnemonics: Forward (C1 to C5): “If Policy Isn’t Enforced Everywhere.” Backward (C5 to C1): “Every Engineer Inspects Past Incidents.”
- Authority tier: How much an agent may decide alone. A is agent free, R is AI recommends and a human decides, H is human only.
- Capability attenuation: Each delegation hop can keep or narrow authority, never widen it.
- Composite principal: The full identity behind an action: agent, model, user, mandate and delegation chain together.
- Evaluation point: A defined moment in an agent’s run where the control plane gets asked for a verdict.
- Evidence event: ACM’s C5 data unit. A linked, chained record of one decision or action.
- Grant: ACM’s C3 data unit. A credential plus the claims that say who, for whom, for what and until when.
- Kill switch: A control that stops an agent or a class of agents and revokes their grants.
- Mandate: ACM’s C1 data unit. Purpose, scope, success criteria and non-goals for one task, with an ID.
- PEP / PDP: Policy enforcement point (intercepts the action) and policy decision point (decides). Terms borrowed from long-standing access control architecture.
- Policy bundle: A versioned set of rules shipped to a PDP.
- Shadow mode: Policy evaluated and logged but not enforced, so you can see what it would have done.
- Verdict: ACM’s C4 data unit. Allow, deny, modify, pause for approval, or escalate.
Version history
- v0.1, November 21, 2026: First public working draft. Five layers, two groups of cross-cutting controls, ten evaluation points mapped to AIM, three illustrative artifacts.
Sources
- The Agent Interconnection Model (AIM), this site
- Futurum, “Futurum Agent Control Plane Framework: A Reference Model for Production AI Agents” (April 3, 2026)
- Forrester, “Announcing Our Evaluation Of The Agent Control Plane Market” (Dec 4, 2025) and “Agent Control Planes Still Need A Robust Standards Stack” (Mar 20, 2026)
- K. Tallam, “A Five-Plane Reference Architecture for Runtime Governance of Production AI Agents”, arXiv 2606.12320 (June 2026)
- OWASP GenAI Security Project Agent Control Standard (ACS) and its specification
- OWASP Top 10 for Agentic Applications (Dec 2025)
- NIST, “Announcing the AI Agent Standards Initiative” (Feb 17, 2026)
- NIST NCCoE, “Accelerating the Adoption of Software and AI Agent Identity and Authorization” concept paper (Feb 2026) and the project resource hub
- NIST AI Risk Management Framework
- RFC 8693, OAuth 2.0 Token Exchange
- Identity Assertion JWT Authorization Grant (IETF draft) and MCP’s enterprise-managed authorization extension
- OpenID AuthZEN Authorization API 1.0 (Final, Jan 2026)
- Open Policy Agent and Cedar
- SPIFFE
- OpenTelemetry GenAI semantic conventions
- Model Context Protocol specification, revision 2026-07-28
- RFC 8907, TACACS+ and RFC 5176, RADIUS Dynamic Authorization
Working draft v0.1. Feedback’s welcome through the contact page. If you think a control is in the wrong layer, or I’ve mis-described somebody’s work, I want to hear why.