cerbos.dev

Cerbos helps with compliance and access visibility by centralizing authorization logic and logging every access decision, so you can see who can access what and prove it during an audit. According to Cerbos, it provides "instant logs for every decision: who, what, when, which policy" and is "audit-ready for SOC 2, ISO 27001, HIPAA, GDPR, NIS2, DORA, FedRAMP." This applies if your authorization decisions run through Cerbos; it is not a standalone compliance certification or a replacement for your identity provider or governance tooling.

Access visibility: seeing what every identity can access

Cerbos is positioned to give "full visibility into what every identity can access." The problem it targets is scattered authorization logic: when permission checks are written as if-statements across many services, no single place shows the full picture, creating blind spots.

Cerbos addresses this by letting you "define, approve, and update policies centrally." Instead of embedding authorization rules in application code, you replace them with a single function call to Cerbos. The practical effect for visibility:

• Authorization logic lives in one place rather than being duplicated per service.
• You can review what a given identity is allowed to do by reading the policy, not by tracing code paths.
• Coverage extends across identity types — users, service accounts, non-human identities (NHIs), and AI agents — managed "in one place."

This matters especially for AI agents, which Cerbos notes "act on behalf of users through MCP clients and other interfaces, masking who initiated the action." Centralized policy plus decision logging is how Cerbos makes that activity visible rather than inherited and invisible.

Decision logs: the audit trail

The core compliance mechanism is per-decision logging. Cerbos states you get "instant logs for every decision: who, what, when, which policy." Each authorization decision produces a record covering:

Because every decision is evaluated against a named policy, the log ties an outcome back to a specific, reviewable rule. That is what makes the trail useful for auditors: you can show not just that access happened, but which policy permitted or denied it.

Compliance frameworks Cerbos says it supports

Cerbos describes itself as "audit-ready" for the following frameworks:

• SOC 2
• ISO 27001
• HIPAA
• GDPR
• NIS2
• DORA
• FedRAMP

"Audit-ready" here means Cerbos produces the decision logs and centralized policy records that these audits typically ask for. It does not mean Cerbos certifies your organization — you still need your own controls, processes, and evidence. Treat the framework list as the set of audit contexts Cerbos is designed to feed evidence into, not as a guarantee of compliance.

How this fits your existing IAM stack

Cerbos is explicit that it fills a specific gap rather than replacing your existing tools:

• Your IdP authenticates (establishes who the identity is).
• Your IGA provisions roles (assigns entitlements).
• Cerbos "controls what identities actually do at the resource level, at runtime."

So compliance and visibility from Cerbos cover the runtime authorization layer — the decisions made after login. If your audit questions are about authentication or role provisioning, those come from your IdP and IGA; Cerbos supplies the resource-level decision record.

Where the visibility payoff is largest

The scenarios Cerbos highlights are the ones where blind spots are most costly:

• Over-permissioned access — agents and services "can do more than they should," and one mistake can expose data or trigger unauthorized actions.
• AI agents blurring identity lines — when the system can't distinguish an agent from the user it acts for, the agent "inherits permissions they should never have."
• Standing access that never expires — long-lived tokens and shared credentials stay valid longer than needed.
• No fine-grained kill switch — without per-action revocation, access continues until credentials are rotated or systems restarted.

Centralized policy plus decision logging is what turns each of these from an invisible risk into something you can see and, where policy allows, revoke "in seconds through policy."

What to verify before relying on it for an audit

• Confirm that the decisions you care about actually route through Cerbos — decisions made outside it won't appear in the logs.
• Check that your policy set is complete; visibility is only as good as the policies you've defined and approved.
• Match the framework list to your specific audit scope and confirm with your auditor which Cerbos outputs satisfy which evidence requirements.
• Remember that Cerbos covers runtime authorization; authentication and provisioning evidence still comes from your IdP and IGA.

For pricing, deployment specifics, and current capabilities, see the Cerbos site and its pricing page, since those details are not covered here.

Cerbos is a runtime authorization layer that sits after authentication and role provisioning. Your identity provider (IdP) confirms who a user is, and your identity governance and administration (IGA) tool assigns roles — but neither decides, at the moment of a request, whether this specific identity can perform this specific action on this specific resource. Cerbos fills that gap: it evaluates fine-grained, contextual policies at runtime and returns an allow/deny decision for every access request across applications, gateways, workloads, and AI agents. It's a fit if you already have authentication and role provisioning in place but still find authorization logic scattered across services as if-statements, or if you need to govern non-human identities and AI agents alongside users.

The three layers, and where Cerbos sits

Cerbos describes its position in the IAM stack with a simple division of labor:

The key distinction is after login. Authentication and role assignment are necessary but not sufficient — Cerbos controls what happens once an identity is already inside, deciding each action at the resource level rather than relying on a static role that may over-permit.

What Cerbos replaces

In many systems, authorization logic lives inside application code as scattered conditional statements. Each service re-implements its own rules, which creates blind spots: no single view of who can access what, and no consistent way to audit or change a decision.

Cerbos replaces that pattern with a single function call against centrally defined policies. Policies are defined, approved, and updated in one place, and roles and permissions can be deployed without code changes. The platform supports RBAC, ABAC, ReBAC, and PBAC out of the box, so you can express rules based on roles, attributes, relationships, or policy conditions as your requirements demand.

What you gain operationally

• Visibility and governance — See and govern every access decision, with full visibility into what each identity can access, instead of scattered logic creating blind spots.
• Audit-ready logs — Every decision produces a log recording who, what, when, and which policy applied. Cerbos states this supports audit readiness for SOC 2, ISO 27001, HIPAA, GDPR, NIS2, DORA, and FedRAMP.
• Scale and deployment flexibility — The engine is stateless and handles millions of authorization decisions per second across distributed systems. It can be deployed in cloud, on-prem, or air-gapped environments.
• Faster delivery — Because policies are decoupled from application code, roles and permissions ship without code changes.

Governing identities beyond human users

A conventional IAM stack is built around human users. Cerbos extends the same centralized policy model to service accounts, non-human identities (NHIs), and AI agents — managing access across the entire identity fabric in one place.

This matters because AI agents introduce authorization problems that traditional IAM handles poorly:

• Over-permissioned access — Agents and services can do more than they should, so a single mistake can expose sensitive data or trigger unauthorized actions.
• Blurred identity lines — Agents act on behalf of users through MCP clients and other interfaces, masking who initiated an action. When the system can't distinguish them, agents inherit permissions they should never have.
• Standing access that never expires — Long-lived tokens and shared credentials remain valid long after they're needed, increasing compromise risk.
• No fine-grained kill switch — If an agent exceeds its scope, access typically continues until someone rotates credentials or restarts systems, with no way to revoke a single action in seconds.

Cerbos addresses these by letting you define AI agent and MCP boundaries before they go live, and revoke access in seconds through policy — so you always know exactly what each agent can access.

How to decide whether it fits your stack

Cerbos is likely a fit if:

• You have authentication (IdP) and role provisioning (IGA) in place, but authorization decisions are still hardcoded or duplicated across services.
• You need resource-level, contextual decisions at runtime rather than static role checks.
• You must govern service accounts, NHIs, or AI agents with the same rigor as human users.
• You need per-decision audit logs for compliance frameworks.
• You want to change permissions without redeploying application code.

It may be less of a fit if your authorization needs are trivial and fully satisfied by role claims already issued at login, or if you have no requirement to govern non-human identities.

To evaluate it against your own environment, the site offers a demo booking path and a "See how Cerbos works for your team" entry point; pricing details are available on the Cerbos pricing page.

Cerbos is an authorization management platform for enterprise software and AI systems. It answers the question that comes after login: not "who is this user?" but "what is this identity actually allowed to do, right now, to this specific resource?" It enforces fine-grained, contextual, and continuous authorization across applications, gateways, workloads, and AI agents — and it does so from a single set of centrally managed policies rather than scattered code.

If you already have an identity provider handling authentication and an IGA tool provisioning roles, Cerbos fills the runtime gap between them: it controls what identities do at the resource level while requests are happening.

The problem Cerbos addresses

Authentication tells you an identity is who it claims to be. It does not tell you whether that identity should be able to read a particular record, call a particular endpoint, or have an AI agent act on its behalf. Cerbos frames this as the authorization gap, and highlights four failure modes it is built to close:

• Over-permissioned access — agents and services can do more than they should, so a single mistake can expose sensitive data or trigger unauthorized actions.
• Blurred identity lines — AI agents act on behalf of users through MCP clients and other interfaces, masking who initiated an action. When the system can't tell them apart, agents inherit permissions they should never have.
• Standing access that never expires — long-lived tokens and shared credentials stay valid long after they're needed, increasing compromise risk.
• No fine-grained kill switch — if an agent exceeds its scope, access continues until someone rotates credentials or restarts systems, instead of being revoked in seconds.

What Cerbos actually does

Centralizes authorization logic

Instead of scattering if statements across services, you define, approve, and update policies centrally and replace that logic with a single function call. Cerbos supports RBAC, ABAC, ReBAC, and PBAC out of the box, and its materials state you can deploy roles and permissions without code changes.

Governs every identity type

Policies cover users, service accounts, non-human identities (NHIs), and AI agents in one place, so the same control plane manages access across your identity fabric.

Secures AI agents with guardrails

You define what each AI agent can access before it goes live, and revoke that access in seconds through policy if something changes. This is the "define boundaries before launch, revoke after" model rather than relying on credential rotation.

Provides visibility and audit evidence

Cerbos logs every decision — who, what, when, and which policy — so you can see what every identity can access and produce audit-ready records. Its materials cite alignment with SOC 2, ISO 27001, HIPAA, GDPR, NIS2, DORA, and FedRAMP.

Scales across architectures

It handles millions of authorization decisions per second across distributed systems and AI agents, is stateless, and can be deployed in cloud, on-prem, or air-gapped environments.

Where it fits in your stack

Cerbos positions itself explicitly as the layer that closes the gap in an existing IAM stack, not a replacement for the IdP or IGA you already run.

When Cerbos is a fit

Cerbos is worth evaluating if you recognize one or more of these conditions:

• Authorization logic is duplicated across services and creating blind spots.
• You are deploying AI agents or MCP-based integrations and need to bound what they can reach before launch.
• You need a fast, policy-driven way to revoke a single agent's or service's access without rotating credentials.
• You need per-decision audit logs to satisfy compliance frameworks.
• You run distributed or air-gapped infrastructure and need authorization that scales independently of your application code.

If your needs stop at authentication and coarse role assignment, the runtime layer Cerbos targets may be more than you need.

Getting started

The site offers a demo booking path and a "Try Cerbos" option for hands-on evaluation. Pricing is published on a dedicated pricing page, so check that page directly for current tiers and terms rather than assuming a free or self-serve tier.

Cerbos controls AI agent access by letting you define an agent's boundaries and MCP scope before it goes live, then enforcing those boundaries at runtime through centralized policy. If an agent goes out of scope, you revoke its access in seconds by changing policy rather than rotating credentials or restarting systems. This applies to teams running AI agents or MCP clients that act on behalf of users and need a runtime authorization layer on top of their existing identity provider.

The problem Cerbos is aimed at

Cerbos frames authorization as the gap that authentication and role provisioning leave open. Your identity provider (IdP) authenticates an identity; your identity governance (IGA) tool provisions roles. Neither controls what an identity actually does at the resource level, at runtime. For AI agents, four specific failure modes make that gap worse:

• Over-permissioned access — agents and services can do more than they should, so one mistake can expose sensitive data or trigger unauthorized actions.
• Blurred identity lines — agents act on behalf of users through MCP clients and other interfaces, masking who initiated the action. When the system can't tell them apart, agents inherit permissions they should never have.
• Standing access that never expires — long-lived tokens and shared credentials stay valid long after they are needed, increasing the chance of compromise.
• No fine-grained kill switch — if an agent goes beyond its scope, access continues until someone rotates credentials or restarts systems. There is no way to revoke a single action in seconds.

How the control actually works

Define boundaries before the agent goes live

You define what each AI agent can access before it is deployed, including AI agent and MCP boundaries. Policies are defined, approved, and updated centrally, replacing scattered authorization logic with a single function call. This is the point where you decide scope rather than discovering it after the fact.

Enforce contextual authorization at runtime

Cerbos enforces fine-grained, contextual, and continuous authorization across applications, gateways, workloads, and AI agents. Because policy is evaluated per decision, the agent's access is checked against current policy each time — not granted once and trusted indefinitely.

Revoke through policy, in seconds

If an agent goes beyond its scope, you revoke access in seconds through policy. You do not need to rotate credentials or restart systems to cut off a single action. This is the kill-switch capability the product positions against standing access.

See and govern every decision

Every decision produces a log: who, what, when, and which policy. That gives you full visibility into what every identity can access and what every agent can access, and it supports audit readiness for frameworks including SOC 2, ISO 27001, HIPAA, GDPR, NIS2, DORA, and FedRAMP.

Where it sits in your stack

Cerbos is not a replacement for your IdP or your IGA tool. The division of labor is:

It manages access across users, service accounts, non-human identities (NHIs), and AI agents in one place, with centralized policies for the whole identity fabric. Supported models include RBAC, ABAC, ReBAC, and PBAC out of the box, and roles and permissions can be deployed without code changes.

Operational characteristics to weigh

• Scale: handles millions of authorization decisions per second across distributed systems and AI agents.
• Stateless: designed to be stateless, which matters for distributed enforcement points.
• Deployment: cloud, on-prem, or air-gapped.
• Time to ship: the product claims authorization can ship in one sprint, since policy changes don't require code changes.

When this fits and when it doesn't

Cerbos is a reasonable fit if you already have authentication and role provisioning in place but lack runtime, resource-level control — especially if you are deploying AI agents or MCP clients that act on behalf of users and you need a fast way to revoke a single agent's access. It is less relevant if you have not yet solved authentication or role provisioning, since Cerbos explicitly positions itself as closing the gap in an existing IAM stack rather than replacing it.

For current pricing and plan details, check the pricing page at https://www.cerbos.dev/pricing, since the available material does not specify cost or access terms.

Cerbos supports RBAC, ABAC, ReBAC, and PBAC out of the box, and it can be deployed in cloud, on-prem, or air-gapped environments. Its stateless architecture is designed to handle millions of authorization decisions per second across distributed systems and AI agents. If you need to centralize authorization logic without changing application code, Cerbos covers both the model and deployment side.

Authorization models supported

Cerbos describes its policy engine as supporting four common authorization models out of the box:

The platform positions these as a replacement for scattered if-statements: you define, approve, and update policies centrally, then call a single function from your application to get an authorization decision. According to the site, roles and permissions can be deployed without code changes, and authorization can be shipped in one sprint.

Deployment options

Cerbos lists three deployment environments:

• Cloud — managed deployment for teams that don't want to run the authorization service themselves.
• On-prem — self-hosted within your own infrastructure.
• Air-gapped — isolated environments with no external network access, for high-security or regulated settings.

The architecture is stateless, which is what allows it to scale horizontally across distributed systems and AI agents. Cerbos claims it can handle millions of authorization decisions per second in this configuration.

What this means in practice

If you're evaluating Cerbos against your existing stack, the relevant questions are:

1. Do you need more than roles? If your access rules depend on attributes, relationships, or centralized policy, Cerbos covers those models without you building a custom engine.
2. Where must the decision run? Cloud, on-prem, and air-gapped are all listed, so regulated or isolated environments are in scope.
3. How much traffic? The stateless design is aimed at high-volume, distributed authorization rather than a single monolithic app.

Cerbos also positions itself as filling the gap after authentication: your identity provider authenticates, your IGA provisions roles, and Cerbos controls what identities actually do at the resource level at runtime. That includes users, service accounts, non-human identities (NHIs), and AI agents.

Where to verify specifics

Pricing and plan details are not covered in the available page evidence, so check the Cerbos pricing page directly before assuming cost or licensing terms. For model-specific policy syntax and deployment configuration, the product documentation is the authoritative source.