What does AI governance for coding agents involve?
Coding agents are AI systems with shell access, credentials, and write access to source code, and most governance programs have no record of them. Treat each agent your engineers run as an AI system. Give it an owner, approve or prohibit the models and Model Context Protocol (MCP) servers it may use, and keep the hook decisions it produces as evidence of runtime control.
AI governance is the set of decisions an organization makes about the AI systems it builds and uses, and the evidence that those decisions are followed. For the full definition and the frameworks behind it, see what is AI governance. This guide applies that model to Claude Code, GitHub Copilot, Cursor, OpenAI Codex, and Muse Code. It covers which decisions apply to a coding agent, where each decision is enforced, what evidence the enforcement produces, and how that evidence maps to the NIST AI Risk Management Framework (AI RMF) 1.0, ISO/IEC 42001, and the EU AI Act.
Why do coding agents belong in the AI inventory?
Coding agents belong in the AI inventory because they act on your systems with your engineers' access, and that makes them AI systems in the sense every framework uses. An AI system is an application or agent together with the model providers and tools it uses. A Claude Code installation that calls Anthropic's API and three MCP servers fits that definition as well as a customer-facing chatbot does.
Coding agents are often missing from governance registers for three reasons:
- They arrive as developer tools. An engineer installs a CLI with
npmor Homebrew, or turns on agent mode in an editor. Nobody files an intake form, so a survey-based register never hears about it. - Their scope changes without a release. Adding an MCP server is one line in a configuration file. The agent gains a new tool, and possibly a new data source, without a code review.
- They act, not only answer. A coding agent runs shell commands, edits files, fetches URLs, and calls MCP servers with the developer's SSH keys, cloud tokens, and
.envfiles. For the full risk picture, see coding agent security.
An AI inventory that leaves coding agents out understates both the number of AI systems you run and the access they hold. Arcjet builds the inventory from what it observes, so a coding agent appears once it sends hook events or once the Discovery agent sees its connections to a model provider. For how the inventory is built and how complete it is, see AI inventory.
Group the agent with what it uses. In Arcjet, the hooks for one coding agent report to an actor, and Arcjet suggests an AI system that groups that actor with the providers and MCP servers it observes in captured tool calls. A person confirms the grouping. The result is one record per coding agent with its providers and MCP servers attached, and the owner, purpose, and review sit on that record.
Which governance decisions apply to a coding agent?
Four decisions apply to a coding agent: who owns it, what it's for, which models and providers it may reach, and which tools and MCP servers it may call. Each decision needs a place where it's enforced, or it stays a statement in a policy document. The following table lists each decision, where it's recorded, and where it's enforced.
| Decision | Where you record it | Where it's enforced | Caveats |
|---|---|---|---|
| Owner | Owner field on the AI system | Weekly owner digest; ownership lapses when the owner leaves the team | The owner must be a member of the Arcjet team |
| Purpose, data classes, and tools | Purpose, declared data classes, and declared tools | Purpose drift compares the declaration with sensitive-information findings and captured tool calls | Drift raises a notice to the owner; it doesn't block |
| Model providers | Provider decision: approve or prohibit, per provider or client | The Discovery agent on managed devices; violations for use after a prohibition | A hostname doesn't separate a personal account from a company one |
| Models | A model allowlist in a Guard policy | The agent's hooks, before the model is used | GitHub Copilot and Muse Code hooks don't report a model |
| MCP servers and tools | An MCP allowlist and tool rules in a Guard policy | The agent's hooks, before each tool call | Covers clients where the hook is installed |
Provider decisions and model allowlists work at different layers, and you usually want both. A provider decision says which AI services people on your devices may reach at all, and the Discovery agent enforces it on the connection. You can decide at the client level, for example approving the OpenAI API while prohibiting the ChatGPT app. A model allowlist says which models an approved agent may use, and the agent's own hook enforces it. For the list of providers, see approved AI providers. For the model rule on each agent, see how to restrict which models developers can use. For the MCP rule, see how to restrict which MCP servers a coding agent can use.
Write the tool decision as a policy, not as a sentence in a purpose field. Arcjet translates each agent's hook payload into one fixed set of inputs, including tool_kind, mcp_server, paths, domains, and model, so a Rego policy written once applies to every supported agent. A rule must pass a test before it goes live, and you publish it in dry run first to see what it would deny. A second approver can be required before a Guard policy publishes, which gives you a two-person record for each change to the rules that govern your agents.
What evidence do coding-agent hooks produce?
Coding-agent hooks produce a decision record for each tool call, prompt, and model switch that a hooked agent sends, made before the agent acts. Each record carries the conclusion (allow or deny), the rule that fired, and the reason. Records from dry-run rules are kept too, so you can show that a rule was measured against real activity before it started blocking.
The following list describes the evidence types that a governed coding agent produces in Arcjet:
- Decisions. Allow or deny, with the rule and reason, for each event the hook sends before the agent acts.
- Captures. Hook events that arrive after the agent acts, such as tool results, recorded with the session they belong to.
- Policy history. Each published change to a Guard policy, naming the person who made it, and the second approver where you require one.
- Sensitive-information findings. Personally identifiable information (PII) and secrets detected in prompts and tool calls, plus protected health information (PHI) in a pilot.
- Session taint and clears. A session flagged as tainted after risky activity, and the human approval that cleared it. For how tainting works, see what is session tainting.
- Governance changes. Each change to an owner, purpose, review, or provider decision, written to the WorkOS audit log with the fields that changed. The log never records the purpose text.
- Drift notices. Each difference between the declared tools and data classes and what the hooks observed, sent to the owner.
This is evidence from the control itself. A survey can say that engineers use only approved MCP servers. A decision record shows the policy that checked each MCP call, the call it denied, and the date the policy went live.
The evidence page rolls these records up across every standard project in your team and maps them to framework requirements. You can export it as JSON or CSV, or push it to Vanta or Drata. There is no point-in-time recompute, so keep the export as the record for a given date. For the export workflow, see AI governance evidence export.
Decision history in the Arcjet Console follows your plan's log retention. Long-term decision retention is opt-in. On the Enterprise plan, a log drain also exports decisions to your SIEM or log store. For retention choices, see AI system log retention.
How does coding-agent evidence map to NIST AI RMF, ISO/IEC 42001, and the EU AI Act?
Coding-agent evidence supplies evidence for a handful of inventory, accountability, third-party, and monitoring requirements in each framework, and nothing for the organizational ones. The following table lists the references it supports. Titles are paraphrases. The table leaves out ISO/IEC 42001, whose text is sold rather than published openly; the evidence page also maps this evidence to ISO/IEC 42001. For the frameworks themselves, see the NIST AI RMF, ISO/IEC 42001, and Regulation (EU) 2024/1689 on EUR-Lex.
| Requirement | Our short title | Coding-agent evidence |
|---|---|---|
| NIST GOVERN 1.6 | AI systems are inventoried | Each coding agent as an AI system, with its providers and MCP servers |
| NIST GOVERN 2.1 | Roles and responsibilities are documented | A named owner per coding agent |
| NIST GOVERN 6.1 | Third-party AI risk is addressed | Provider decisions and violations |
| NIST MAP 1.1 | Intended purpose is documented | Purpose, declared data classes, and declared tools |
| NIST MEASURE 2.4 | Behavior is monitored in production | Hook decisions and the share of agents with a live policy |
| NIST MANAGE 4.1 | Post-deployment monitoring is in place | Decision records, sensitive-information findings, and log export |
The EU AI Act needs more care. Most coding-agent use isn't a high-risk use under the Act, and the deployer duties in Article 26 apply to high-risk systems. Classification is a legal judgment, so get advice before you cite a row. If a coding agent is part of a system you classify as high-risk, the decision records support monitoring under Article 26(5), and long-term retention or a log drain supports keeping logs under Article 26(6). Article 4, on staff AI literacy, applies more widely, and it's training that your organization provides, not a runtime record. For how to record a classification, see AI risk tiers.
How do you set up governance for coding agents?
To set up governance for coding agents, install the hooks, let Arcjet build the inventory, and then attach decisions to what it finds. The following steps assume you're a team administrator in Arcjet, because only administrators edit owner, purpose, and decisions.
- Install hooks for each agent through managed configuration. Use each vendor's managed settings or your mobile device management (MDM) tool, so developers can't remove the hooks. The per-agent guides in the following section cover each install.
- Turn on observe-only paths as a backstop. OpenTelemetry and the Claude Compliance API record sessions that the hooks missed. For setup, see Observe agent activity.
- Confirm each AI system. Review the grouping Arcjet suggests for each coding agent, and confirm the providers and MCP servers that belong to it.
- Assign an owner and a purpose. Pick a team member who can answer for the agent, and write a purpose that names the declared data classes and tools. For how to choose an owner, see AI system owners.
- Decide each provider. Approve or prohibit each model provider and client the agents reach. The Discovery agent enforces the decision on managed devices.
- Publish policies in dry run. Start with the model and MCP allowlists and the starter policies for destructive commands and secrets. Review what each rule would deny, then set it live.
- Mark the system reviewed. Reviews fall due every 180 days. Review sooner after a drift notice or a new provider. For the review routine, see AI system review.
- Export the evidence. Download the evidence page as JSON or CSV, or push it to Vanta or Drata, and keep the export as the dated record.
What differs between Claude Code, Copilot, Cursor, and Codex?
The governance decisions are the same for every coding agent, but each vendor controls which hook answers it honors. One policy applies to all five agents, and the differences show up in what each agent enforces. The following table summarizes the differences that matter for governance and links each install guide.
| Agent | Tool calls | Prompts | Model allowlist | Install guide |
|---|---|---|---|---|
| Claude Code | Enforced | Enforced | Denies the model switch | Secure Claude Code in the enterprise |
| GitHub Copilot | Enforced on the CLI and cloud agent | Recorded, not enforced | Not covered; no model field | Secure GitHub Copilot's agents |
| Cursor | Enforced | Enforced in the IDE | Denies the prompt and tool call | Secure Cursor's agent |
| OpenAI Codex | Enforced; hosted tools skip the hook | Enforced | Denies the prompt and tool call | Secure OpenAI Codex |
| Muse Code | Enforced | Enforced | Not covered; no model field | Coding agent security |
Where a hook can't enforce a decision, record that gap on the AI system and cover it another way. For Copilot, set model restrictions in GitHub's own admin settings. For per-vendor details, including what happens when a hook can't reach Arcjet, see what each coding agent can enforce.
What does Arcjet not cover for coding agents?
Arcjet governs coding agents only where it observes them, and it supplies evidence for runtime control, not for everything a framework asks. The following list names the gaps:
- Agents without hooks. A second agent, an unmanaged machine, or a developer calling a model API from another tool sends no hook events. Compare hook decisions with OpenTelemetry and Claude Compliance API activity to find these sessions.
- Hooks that fail open. Claude Code and Copilot HTTP hooks let a call through on a timeout or network error, except Claude Code's model switch. For details, see coding agent hooks fail open.
- Personal accounts. A personal Claude or ChatGPT login reaches the same hostnames as your company tenant. Use the vendors' tenant controls. For details, see how to block personal AI accounts on work laptops.
- Tool results. Arcjet doesn't withhold what a tool returned. Policies stop what the agent tries to do next.
- Code quality and intellectual property. Arcjet doesn't review the code an agent writes or assess license and IP risk in generated code.
- Organizational requirements. Policies, training, risk tolerance, and impact assessments are your organization's work. Arcjet records a risk tier, but the assessment behind it is yours.
Where Arcjet fits
Arcjet builds the governance record for coding agents from the control that enforces it. The hooks report each agent as an actor, and Discovery finds the providers the agents reach on managed macOS and Windows devices. Arcjet groups each agent with those providers and the MCP servers in its tool calls into an AI system that a person confirms. Owner, purpose, and review sit on that system, and provider decisions are enforced on devices.
Guard decides each tool call, prompt, and model switch before the agent acts, with one policy across Claude Code, GitHub Copilot, Cursor, OpenAI Codex, and Muse Code. Purpose drift tells the owner when an agent starts calling tools or handling data its purpose doesn't cover. The evidence page maps the result to NIST AI RMF 1.0, ISO/IEC 42001, and the EU AI Act, and lists every requirement as supported or not covered.
To start, install the hooks for one agent from its guide, then publish a starter policy in dry run from the coding agent policies documentation. For the governance model across all your AI systems, return to what is AI governance.
Frequently asked questions
Is a coding agent an AI system for governance purposes?
Yes. An AI system is an application or agent together with the model providers and tools it uses. A coding agent such as Claude Code or GitHub Copilot calls a model provider and runs tools, including shell commands, file edits, and MCP servers, with a developer's access, so it belongs in the AI inventory with an owner, a purpose, and a review date.
Who should own a coding agent in the AI inventory?
Pick one person who can answer for how the agent is configured and used, often an engineering platform or developer-experience lead. In Arcjet, the owner must be a member of the team, and an owner who leaves the team reads as no owner automatically, so the record never points at a former employee.
Can I restrict which models a coding agent uses?
Yes, with a model allowlist in a hook policy, paired with each vendor's admin settings. Claude Code blocks a switch to a disallowed model, and Cursor and OpenAI Codex block the prompt and tool calls while a disallowed model is selected. GitHub Copilot and Muse Code hooks don't report a model, so set Copilot's model controls in GitHub's admin settings.
Does coding-agent hook evidence make me compliant with the EU AI Act?
No. Hook decisions supply evidence for some requirements, such as monitoring operation, but they don't make an organization compliant with any framework. Most coding-agent use isn't a high-risk use under the EU AI Act, and classification is a legal judgment. Organizational duties such as staff AI literacy under Article 4 remain your organization's work.
What happens to governance evidence when a hook can't reach Arcjet?
It depends on the agent. Claude Code and GitHub Copilot HTTP hooks fail open, so the tool call runs without a decision record, except Claude Code's model switch. Cursor, OpenAI Codex, and Muse Code use a command wrapper that can fail closed. Compare hook decisions with OpenTelemetry or Claude Compliance API activity to find sessions that ran without one.
AI runtime security in your code
Protect your AI agent workflows with Arcjet
Install Arcjet hooks for one coding agent, publish a starter policy in dry run, and see each agent appear in your AI inventory.