---
title: What is the difference between guardrails, policies and controls for AI agents?
url: https://opencontroller.lyzr.com/blog/guardrails-policies-and-controls-for-ai-agents
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# What is the difference between guardrails, policies and controls for AI agents?

**A policy is a rule that says what must or must not happen. A control is any mechanism — technical or procedural — that makes the policy true and can be tested. A guardrail is one kind of technical control that checks an agent's inputs or outputs at runtime and allows, changes or blocks them. Every guardrail is a control, but most controls are not guardrails.**

The terms get used interchangeably in vendor material, which makes it hard to compare products or answer auditors. This post fixes the definitions. The pillar for this cluster is [what an AI agent control plane is](/blog/what-is-an-ai-agent-control-plane).

## What is a policy?

A policy states intent as a rule. Example: "Agents must not send customer personal data to model providers outside the EU."

A policy on its own changes nothing. It needs controls behind it. Policies can be written as documents, or as policy as code — machine-readable rules a system evaluates. See [what policy as code is for AI agents](/blog/what-is-policy-as-code-for-ai-agents).

## What is a control?

A control is a safeguard that implements a policy and can be checked. NIST defines security controls as safeguards or countermeasures prescribed to protect the confidentiality, integrity and availability of a system and its information. For agents, controls fall into three groups:

- **Preventive** — stop something before it happens. Example: a tool allow-list per agent.
- **Detective** — find it when it happens. Example: an alert when an agent's behaviour drifts from its baseline.
- **Corrective** — fix or contain it. Example: automatic quarantine of an agent.

Controls can be procedural too. A production-readiness review before an agent goes live is a control. So is a quarterly access review.

## What is a guardrail?

A guardrail is a runtime technical control that inspects what goes into or comes out of a model or agent step, and acts on it. Examples:

- A groundedness check that flags answers not supported by the retrieved sources. See [what a groundedness guardrail is](/blog/what-is-a-groundedness-guardrail).
- PII redaction on prompts before they reach the model.
- A task-adherence check that flags when an agent wanders off its assigned task.
- A prompt-injection detector on tool outputs.

Guardrails are different from evaluations, which test an agent before release or score samples afterwards; see [guardrails vs evaluations](/blog/guardrails-vs-evaluations-for-ai-agents).

## How do they compare side by side?

| | Policy | Control | Guardrail |
|---|---|---|---|
| What it is | A rule | A mechanism that makes the rule true | A runtime check on inputs or outputs |
| Example | "No customer PII to non-EU providers" | Gateway routing rule that sends PII-tagged traffic only to EU endpoints | PII detector that redacts personal data in prompts |
| Testable? | Only through its controls | Yes | Yes |
| Where it lives | Document or policy as code | Anywhere: process, identity, network, gateway, platform | Model call, gateway or agent framework |
| Who owns it | Policy owner (often risk or security) | Control owner (often platform or security) | Platform or agent team |
| Audit evidence | Approved policy version | Configuration and test results | Logs of checks and actions taken |

## Where does each one live in an agent stack?

1. **Process** — policies, approvals, reviews, exception handling.
2. **Identity** — per-agent identities, least-privilege scopes, delegation rules.
3. **Gateway** — routing, rate and spend limits, redaction, blocking in the request path.
4. **Platform** — agent-platform settings, tool permissions, deployment gates.
5. **Model call** — guardrails on prompts and responses.

A single policy usually needs controls at several layers. "Agents must not leak customer data" might need identity scoping (layer 2), egress rules and redaction (layer 3), and an output guardrail (layer 5).

## How should you use these terms with auditors and vendors?

- **Map each policy to named controls.** An auditor asks "how do you know this rule is followed?" The answer is a list of controls and their evidence.
- **Ask vendors which layer they act at.** A product that offers "guardrails" may only act on model calls, not tool calls or identity.
- **Don't count guardrails as your whole control set.** Guardrails catch content problems; they do not handle ownership, credentials or retirement.

## How Opencontroller does this

Opencontroller supports policy as code with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001 (policies), Posture for risky permission and configuration detection, rogue-agent handling and per-agent Block and Quarantine (controls), and live groundedness and task-adherence guardrails. The LLM Gateway and Agent Gateway put control in the path to allow, route, redact or block. [Book a demo](https://www.lyzr.ai/book-demo/) to see policies mapped to controls.

## Frequently asked questions

**Is a guardrail a policy?**
No. A guardrail is a runtime technical control that enforces part of a policy.

**Can a control be non-technical?**
Yes. Approvals, access reviews and readiness gates are procedural controls.

**Where should agent guardrails run?**
On model calls and, where possible, in a gateway in the request path, so they apply to every agent using that path.

## Key facts

- A policy is a rule; a control is a testable mechanism that makes the rule true; a guardrail is a runtime technical control that checks inputs or outputs.
- Every guardrail is a control, but most controls (identity scoping, approvals, access reviews) are not guardrails.
- Controls can be preventive, detective or corrective, and technical or procedural.
- One policy usually needs controls at several layers: process, identity, gateway, platform and model call.
- Opencontroller provides policy as code, Posture, per-agent Block and Quarantine, and live groundedness and task-adherence guardrails.
- Opencontroller pricing starts from $250K per deployment per year.

## Related

- [What is the difference between guardrails and evaluations for AI agents?](https://opencontroller.lyzr.com/blog/guardrails-vs-evaluations-for-ai-agents.md)
- [What is policy as code for AI agents?](https://opencontroller.lyzr.com/blog/what-is-policy-as-code-for-ai-agents.md)
- [What is a groundedness guardrail and when should it block a response?](https://opencontroller.lyzr.com/blog/what-is-a-groundedness-guardrail.md)
- [More on Agent governance basics](https://opencontroller.lyzr.com/blog/cluster/agent-governance-basics)
