Gouvernance

7 AI Agent Controls: Who Owns Each, What Proves It

· founder of ETCSEC · updated November 17, 2026 · 9 min
Illustration of a robot wearing a blue work cap, representing ownership of AI agent controls.
The short answer

A framework on paper proves nothing on the day an incident review asks who approved an AI agent's production access and where the record is. This checklist maps seven controls to a specific owner, a specific artifact to keep, and a NIST AI RMF subcategory, building on Atipol's six-step governance framework rather than repeating it.

Having a framework is not the same as proving it runs

A DSI telling an executive committee that AI agents are under control usually means two different things are true at once: a framework exists on paper, and nobody can produce the record that proves it was followed for the agent that just shipped to production last week. The harder, more frequent question is not which controls a framework lists, but who owns each one day to day and what artifact an auditor, a regulator, or an incident review can actually pull up as proof.

This gap matters more as agents move from a pilot a few people use to a system touching customer data, financial reports, or production code. A framework that lives only in a policy document answers the first question, the one about completeness. It does not answer the second one, about evidence, which is the one that actually gets tested the week something goes wrong and someone asks who approved it and where the record is.

That gap also complicates a question boards ask more directly every quarter: can the organization show, agent by agent, that production access was earned rather than granted by default. A framework answers that only in the aggregate; the evidence described below is what answers it one agent at a time, which is the level an incident review or a regulator actually asks the question at.

Framework vs. evidence

A framework describes what should happen in general; evidence proves it happened for one named agent, one named owner, and one dated artifact. An audit, a regulator, or an incident review tests the second one, not the first.

Building on six steps, not rewriting them

A six-step framework, inventory, job description and scope, rights and tools, tickets with written criteria, human review before merging, and cost measurement with an audit log, is already covered at atipol.ai/agentic-ai-blog/ai-agent-governance, along with the RACI table and sample usage policy that go with it. Repeating that framework here would not add anything a DSI does not already have. What follows instead maps each of those steps, plus one more, to a specific owner and a specific piece of evidence, using the NIST AI Risk Management Framework's own Govern function as the vocabulary for what regulators and auditors already expect that evidence to look like.

Seven controls, seven owners, seven artifacts

Each row below assumes the underlying control already exists, described in the governance guide linked above, and asks the next question: who is accountable for it running, and what do they hand over when asked to prove it.

ControlOwnerEvidence kept
Inventory of active agentsWhoever maintains the catalog (per NIST Govern 1.6)A dated list naming each agent, its agent lead, and its project
Job description and file scopeThe agent lead who declared the agentThe written scope and forbidden actions, reviewed before first run
Role-based tool permissionsThe administrator who set the catalog modeAn exported permission list, allowed, approval, or denied, per tool
Approval before sensitive or irreversible actionsThe approver named at the time of the callA log entry linking the call, the approver, and the decision
Review before merge, by someone other than the requesterA reviewer distinct from the person who opened the ticketThe reviewed diff and the merge decision, not only the agent's summary
Risk and impact documented per agent (NIST Govern 4.2)The team that designed or deployed that agentA short risk note kept alongside the job description
Contingency for a third-party model or MCP server (NIST Govern 6.1/6.2)Whoever owns the dependency on that providerA documented fallback if the provider changes, fails, or is deprecated

What NIST's own Govern function expects as evidence

The first four rows above are not an invention; they translate language already written into the NIST AI Risk Management Framework's Govern function. Govern 2.1 requires that "roles and responsibilities and lines of communication related to mapping, measuring, and managing AI risks are documented... and are clear to individuals and teams throughout the organization," and the framework's own Playbook turns that into a documentation question an auditor would ask directly: "Are the responsibilities of the personnel involved in the various AI governance processes clearly defined?" An agent lead's name on an inventory entry is one concrete answer to that question; a policy document describing agent leads in the abstract is not.

Govern 1.6 does the same for the inventory itself, requiring "mechanisms... in place to inventory AI systems... resourced according to organizational risk priorities," with the Playbook asking "who is responsible for documenting and maintaining the AI system inventory details." The answer has to be a name or a role, not a statement that an inventory exists somewhere.

Govern 2.3 adds a layer above the agent lead: "Executive leadership of the organization takes responsibility for decisions about risks associated with AI system development and deployment." Read alongside the first two subcategories, the chain an auditor is really checking runs from a declared agent, to a named agent lead, to an executive who accepted the risk of developing and deploying it, not from a framework document to an assumption that someone, somewhere, is accountable.

Read together, the three subcategories above describe a chain of accountability:

Declared agentGovern 1.6Named agent leadGovern 2.1ExecutiveGovern 2.3Declared agentGovern 1.6Named agent leadGovern 2.1ExecutiveGovern 2.3

The Playbook's suggested actions for these same subcategories are written the same way, as policies an organization adopts rather than abstract goals: for Govern 2.1, "Establish policies that promote regular communication among AI actors participating in AI risk management efforts"; for Govern 1.6, "Establish policies that define a specific individual or team that is responsible for maintaining the inventory." Both point back to the same artifact, a named person or team written into a policy, rather than a diagram of roles that nobody is required to keep current.

None of these four subcategories require new tooling to satisfy; they require the inventory entry, the job description, and the executive sign-off to exist as named, dated records rather than as a shared understanding inside the team that built the first agent. The NIST language above is the vocabulary an external reviewer will likely already use, which is one reason to produce evidence in those terms rather than inventing a different one.

Documenting risk and impact per agent, not only per project

Govern 4.2 asks organizational teams to "document the risks and potential impacts of the AI technology they design, develop, deploy, evaluate," which in practice is a short note attached to each agent's job description, not a single risk assessment covering an entire platform. The NIST Playbook frames this as something that can "be applied at the beginning of a process but also iteratively and regularly since goals and outcomes can evolve over time," and that can "assist in 'go/no-go' decisions for an AI system," which is the operational version of the sixth row in the table above: a risk note a team updates, not a document written once and filed.

Govern 6.1 and 6.2 extend the same logic to what an agent depends on outside the organization: "policies and procedures... that address AI risks associated with third-party entities," and "contingency processes are in place to handle failures or incidents in third-party data or AI systems deemed to be high-risk." That second requirement is explicitly scoped to dependencies judged high-risk, not every third-party connection; for an agent built on a model or an MCP server the organization treats that way, the contingency plan, what happens if the provider changes terms, deprecates an endpoint, or has an outage, is the seventh control, and the one most often missing because it sits outside the team that built the agent.

Neither Govern 4.2 nor Govern 6.1/6.2 specifies a template for this note or this plan, which is deliberate: a risk note for an internal support agent and one for an agent that touches financial reporting will not look the same, and a contingency plan should name the actual provider and the actual fallback, not a generic statement that one exists somewhere in an incident response document.

The reviewer in your evidence cannot be the requester

The fifth row's evidence is only as good as who is named in it. GitHub's own documentation on reviewing a pull request created by its Copilot coding agent makes the same requirement explicit for a comparable workflow: an approval from the person who assigned the work does not count toward a repository's required reviews, and a different reviewer has to approve the change before merge. The evidence an auditor wants here is not a timestamp showing a review happened, it is the reviewer's identity checked against the requester's, which a log that only records "reviewed: yes" cannot provide.

The same applies to the fourth row: an approval log that cannot distinguish the approver from the agent, or from the person who triggered the call, documents that something happened without documenting the control it was supposed to satisfy.

Evidence has a review cadence of its own

A control that was true when the framework launched is not automatically true six months later: an agent's scope can expand, a reviewer can leave the project, a third-party model can change its terms. Treating the inventory, the risk notes, and the permission list as live records to revisit on a fixed schedule, rather than documents produced once for a launch review, is what keeps the evidence in row one through seven matching what the agents are actually doing, instead of describing a system that existed at the time of the last audit.

This is also where the sixth and seventh controls differ most from the first five: an inventory entry or a permission list can be checked against the system itself, but a risk note and a contingency plan age silently, since nothing breaks visibly when they go stale until the day the scenario they were supposed to cover actually happens.

The same Playbook guidance that asks who maintains the inventory does not set a review interval either, which mirrors the pattern across every Govern subcategory cited here: NIST specifies the artifact and the accountable role, not a calendar. An organization still has to pick that cadence itself, and the safest default is to tie it to events that already happen, a new agent declared, a reviewer leaving a project, a provider changing terms, rather than to a fixed date on a compliance calendar alone.

Putting the ownership and evidence model into practice

None of these seven controls replace the framework, the RACI table, or the usage policy already described at atipol.ai/agentic-ai-blog/ai-agent-governance; they name who is accountable for each one and what to keep on hand when someone asks for proof. The underlying permission model, the approval logging, and the MCP server review practice that produce much of this evidence are covered at atipol.ai/agentic-ai-blog/mcp-security, and the guided tour of applying all of it across a team of agents is at atipol.ai/security.

Frequently asked questions

What is the difference between an AI agent governance framework and the controls described here?

The framework, inventory, scope, tool rights, ticket criteria, review before merge, and cost tracking, already exists, covered at atipol.ai/agentic-ai-blog/ai-agent-governance. This checklist adds an owner and a specific piece of evidence to each of those steps, plus a seventh control for third-party dependencies, so a DSI can produce proof the framework is actually being followed.

Which NIST AI RMF subcategories apply to enterprise AI agent control?

Govern 2.1 covers documented roles and responsibilities, Govern 1.6 covers maintaining an AI system inventory with a named owner, Govern 2.3 covers executive accountability for decisions about AI system development and deployment, Govern 4.2 covers documenting risks and impacts per system, and Govern 6.1 and 6.2 cover policies and contingency plans for third-party AI dependencies judged high-risk.

Who should own the inventory of AI agents running in an organization?

NIST's AI RMF Playbook frames this as a named individual or team responsible for maintaining the inventory details, not an assumption that it exists somewhere. In Atipol's model, that maps to each agent's declared agent lead at the entry level and an administrator or organization owner at the catalog level.

Sources

Try it on a real project

The public demo shows a fictional organization at work, no account needed. The free plan includes a project, three agents and an agent lead.