The Agent Control Model (ACM)

Remember it asACMAgent Control Model
Forward
C1 to C5
IfC1PolicyC2Isn’tC3EnforcedC4EverywhereC5
Backward
C5 to C1
EveryC5EngineerC4InspectsC3PastC2IncidentsC1

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.

Working draft v0.1First drafted November 21, 2026Status: open for feedbackBy Ryan Thomas Huff (NetworkNerd1337)

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.

Safety controls
Lifecycle

↓ 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

C1

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.

C2

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.

C3

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.

C4

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.

C5

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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:

  1. Evidence first (C5). Turn on structured logging and tracing before you enforce anything, so you can see what the agents actually do.
  2. Identity next (C3). Give every agent its own identity and a human sponsor, and kill the shared service accounts.
  3. Policy in shadow mode (C2). Write the tiers and rules, and log the verdicts without enforcing them.
  4. Enforce at three points (C4). Tool call, write and completion. Fail closed.
  5. 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.

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.

  1. 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.
  2. 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.
  3. 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.
  4. Does ACS become the wire format for C4? If it does, ACM gets simpler, and that’s a good outcome.
  5. 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.
  6. Where do evals live? Same unresolved question as AIM. Pre-deployment evals feel like Lifecycle. Runtime evals feel like C4.
  7. 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

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.