What is the difference between AI governance and AI runtime security?
AI governance decides what is allowed: which AI systems exist, who owns them, and which providers and uses are acceptable. AI runtime security enforces those decisions on each request, tool call, and connection. Governance without enforcement leaves a decision that nothing checks. Enforcement without governance leaves rules that nobody owns or reviews.
Most organizations need both layers, and the useful question is how decisions in one reach the other. This page compares the two layers by what each one answers, what it produces, and how it fails on its own.
Arcjet publishes this comparison. Arcjet sells runtime security for AI agents and coding agents, and records governance on top of that runtime layer. This page compares categories of products, not individual vendors. For a vendor-level view of governance products, see AI governance platforms compared. For the definitions behind both layers, see what is AI governance and what is AI security.
How do the governance and runtime layers compare?
The two layers answer different questions and produce different evidence. The following table compares them.
| Attribute | AI governance | AI runtime security |
|---|---|---|
| Question it answers | Should this AI system exist, who owns it, what is it for, and which providers may it use? | Should this request, tool call, prompt, or connection happen right now? |
| When it acts | At adoption, at review, and when something changes | On every action, before it runs or connects |
| Who acts | System owners, administrators, risk and compliance teams | Code: an SDK, a hook, a gateway, or an endpoint agent |
| Typical products | AI governance platforms, governance, risk, and compliance (GRC) tools, compliance automation, model registries | Guardrail SDKs, coding-agent hooks, AI gateways, secure web gateways, endpoint agents |
| Evidence it produces | Inventory, owners, purposes, risk tiers, review dates, provider decisions, policy documents | Allow, deny, and hold decisions with reasons, dry-run results, sensitive-data findings, blocked connections |
| Framework references it supports | NIST AI RMF GOVERN and MAP, EU AI Act Article 6 | NIST AI RMF MEASURE 2.4 and MANAGE 4.1, EU AI Act Articles 12 and 26(5) |
| How it fails without the other | Decisions sit in a document. Nobody can show they hold, and a prohibited provider still works on every laptop | Rules have no owner and no purpose to check against, so nobody reviews them when a system changes |
The framework references in the table are pointers, and each framework asks for more than one layer can supply. For how the frameworks line up, see NIST AI RMF vs ISO 42001 vs EU AI Act.
What goes wrong with AI governance and no runtime enforcement?
Without runtime enforcement, governance decisions are instructions that people may or may not follow, and the record can't show which. A policy that prohibits personal chat assistants for company code reads the same whether nobody uses one or half the engineering team does.
Three failures follow from that gap:
- The inventory goes stale. A register filled in by survey lists what people reported. It misses the coding agent an engineer installed last week and the MCP (Model Context Protocol) server that agent started using. For the difference, see observed vs survey-based AI inventory.
- Provider decisions don't hold. An approved-tools list in a wiki doesn't block a prohibited provider. Without device observation, you also can't count how often people use it.
- Evidence is assembled, not recorded. At audit time, someone collects screenshots and attestations. They show what someone said at one moment, not what the control did.
What goes wrong with AI runtime security and no governance?
Without governance, runtime controls work, but nobody can say whether they're the right controls. A guardrail blocks a tool call, and the record shows the decision, but there's no owner to ask whether the agent should call that tool, and no documented purpose to compare it with.
Three failures follow from that gap:
- Rules have no owner. When the engineer who wrote a policy changes teams, the policy keeps running and nobody reviews it.
- Coverage is unknown. Runtime records show what was enforced on the systems that have a control. They don't show which AI systems have no control at all, because no inventory lists them.
- Evidence doesn't map. Decision logs answer "what happened?" Frameworks also ask "who is accountable, what is this system for, and when was it last reviewed?" Without those records, runtime evidence covers part of each requirement.
How do governance decisions become runtime controls?
Governance decisions become runtime controls when each decision has a control that reads it and a record that shows the control acted. The following table traces common decisions through to the evidence they produce.
| Governance decision | Runtime control that carries it out | Record that shows it holds |
|---|---|---|
Prohibit a provider or a client, such as a consumer chat app | Endpoint agent blocks the provider on managed devices | Violations: observations after the decision time, per person |
| This agent may use these tools for this purpose | A policy on each tool call, in the SDK or a coding-agent hook | Allow and deny decisions with the rule and reason |
| This system may not handle health data | Sensitive-information detection on prompts and tool calls | Findings by type, compared with the declared data classes |
| A person approves consequential actions | A hold outcome that pauses the action | The owner's approval or rejection, with time and name |
| Policy changes need review | Test before a rule goes live, dry run, and a second approver | Revision history naming the author and the approver |
The table also works in reverse. When a runtime record shows an agent calling a tool its purpose doesn't include, that difference is a governance event: the owner should either update the purpose or tighten the policy. For how that comparison runs continuously, see how to detect AI purpose drift.
Which layer should you build first?
Build the inventory first, then the runtime controls on the systems that carry the most risk, then the rest of governance on top. An inventory tells you what to protect, and runtime controls produce the records that governance needs as evidence.
The following table matches common starting points to a first step.
| Your situation | Start with | Then add |
|---|---|---|
| An auditor or customer asks about AI governance | An observed inventory with owners | Runtime records as evidence that decisions hold |
| You ship AI agents that call tools | Runtime policies on consequential tool calls, in dry run first | Owners and purposes for each agent |
| Engineers use coding agents and chat assistants | Device discovery and coding-agent hooks | Provider decisions enforced on devices |
| You already run a GRC tool | Feed it observed inventory and runtime evidence | Map the evidence to your AI controls in that tool |
For an item-by-item list that spans both layers, use the AI governance checklist. For the runtime threats on their own, use the AI security checklist.
Where does Arcjet fit, and where doesn't it?
Arcjet sits on the runtime layer and records governance on top of it, so the decisions and the controls that enforce them share one record. Discovery finds the AI providers people reach from managed macOS and Windows devices. The SDK and coding-agent hooks for Claude Code, GitHub Copilot, Cursor, OpenAI Codex, and Muse Code report the agents you build and run. Guard decides each tool call, with dry run, and a rule must pass a test before it goes live.
On that runtime record, Arcjet builds the AI inventory and groups each actor with the providers and MCP servers it uses into an AI system. Team administrators record an owner, a purpose, a risk tier, and an EU AI Act role on each system. Provider decisions approve or prohibit a provider or a specific client, and the Discovery agent enforces them on managed devices. Hold decisions go to the system's owner, and the evidence page maps the records to NIST AI RMF 1.0, ISO/IEC 42001, and the EU AI Act, with export as JSON or CSV and push to Vanta and Drata. For the procedure, start with how to build an AI inventory that stays current.
Arcjet is the wrong fit, or only part of the answer, in the following situations:
- You need a policy library, impact assessment workflows, or a register for AI systems Arcjet can't observe. A GRC-led governance platform holds those, and Arcjet's export can feed it.
- You train your own models and need validation, bias testing, and model versioning. Model governance tools cover that life cycle.
- Your AI use is mostly on unmanaged devices. Arcjet's Discovery agent runs only on managed devices.
- You need to read prompt content in browser tabs. Arcjet doesn't decrypt TLS or inspect browser pages.
To try the runtime layer, follow the Arcjet coding agents guide and publish a starter policy in dry run.
Frequently asked questions
Is AI security part of AI governance?
They overlap but are separate layers. AI governance sets the decisions: which systems exist, who owns them, and what is allowed. AI security, especially at runtime, enforces those decisions and defends against threats such as prompt injection. Governance frameworks such as the NIST AI RMF ask for evidence from both, so a governance program depends on security controls for part of its evidence.
Can a GRC tool enforce AI policy?
Not on its own. A governance, risk, and compliance (GRC) tool tracks controls, policies, and evidence, but it doesn't sit in the path of a request or a device connection. Enforcement takes a runtime control, such as an SDK, a coding-agent hook, a gateway, or an endpoint agent, whose records the GRC tool can then use as evidence.
Do coding agents need governance or runtime security?
Both. A coding agent is an AI system with shell access, credentials, and write access to source code, so it needs an owner and decisions about which models and MCP servers it may use. Hooks then decide each tool call before it runs and record the decision, which is the evidence that the governance decisions hold.
Which should I buy first, an AI governance platform or runtime security?
Start with an inventory of what you run, because both layers depend on it. If you ship agents that call tools or your engineers use coding agents, runtime controls produce risk reduction and evidence at the same time. If an auditor's main ask is policies, assessments, and a register, a GRC-led governance platform fits first, fed by observed inventory and runtime records.
AI runtime security in your code
Protect your AI agent workflows with Arcjet
Arcjet runs inside your application, where it can use runtime context to enforce agent actions and budgets, detect prompt injection, and protect sensitive information before a workflow acts.