If you are comparing Cerbos with Permit.io, you are probably turning authorization into a shared service. That might be a bank or a mobile carrier where every channel has to follow the same rules and weigh live context, like a fraud signal, on each decision. It might be a SaaS product whose enterprise customers now expect to manage their own roles. Either way, the choice you make now will hold the rules for every application, gateway and AI agent you run for years.
Both products answer the same question at runtime, whether this person, service or agent may take this action on this resource. They differ in where the source of truth for policy lives, what each decision point has to hold before it can answer, how far one set of policies reaches, and what the platform costs once you count millions of users and every non-human identity.

Cerbos vs Permit.io at a glance
| Question | Cerbos | Permit.io |
|---|---|---|
| What it is | An authorization management platform. Decision points run next to every workload, Cerbos Hub manages policy and audit, and Cerbos Synapse brings in context and connects gateways, data platforms and AI agents. | An authorization service with a control plane in Permit's cloud, a policy editor, embeddable UI components called Elements, and decision points that are either managed by Permit or run by you. |
| Source of truth for policy | Readable YAML policies with CEL conditions, reviewed in pull requests and tested before they ship. | A model of resources, roles and relationships held in Permit's control plane. Permit generates Rego for OPA from it, and custom Rego, added through Permit’s GitOps feature, runs only on the Edge PDP. |
| What a decision point holds | Policy only. The request carries the attributes, or Cerbos Synapse fetches them from the system that owns them, so there is no second copy of your data to keep in sync. | Policy plus a synced copy of your users, roles, tenants and relationships, pushed from Permit's control plane. |
| RBAC, ABAC and relationship checks | Roles, attribute conditions and derived roles are evaluated in every deployment of Cerbos decision points, as a service, sidecar, DaemonSet or serverless function. | According to Permit’s documentation (November 2026), ABAC runs only on the Edge PDP, the decision point you run yourself. The managed Cloud PDP “does not evaluate ABAC policies”. |
| Coverage | One set of policies across applications (SDKs in eight languages plus Laravel), Envoy and Istio gateways, Trino, Kafka, Kubernetes, MCP servers and AI coding agents. | Applications and APIs through SDKs, plus an MCP gateway for agent tool calls. |
| Where policy is managed | Cerbos Hub, hosted, or fully on-premise and air-gapped for enterprise customers. | Permit's cloud by default. A light on-premise mode moves policy administration into your network, and full on-premise is on the Enterprise plan. |
| Audit evidence | Every decision logged with its inputs and outcome and linked to the policy version that made it, collected from every decision point. Retention runs from one week on the free tier to a year on Production, and custom on Enterprise. | Decision logs on an Audit Log screen and API. The free Community tier lists 14 days of log retention on Permit's pricing page (October 2026). |
| Standards | Alex Olivier, Cerbos cofounder and CPO, co-chairs the OpenID AuthZEN Working Group. Cerbos PDP implements the AuthZEN API. | Took part in the AuthZEN interoperability testing alongside Cerbos, and exposes AuthZEN endpoints. |
| Pricing | Public, by monthly active principals. $0 proof of concept, Development from $25 a month, Production from $933 a month, Enterprise custom. | A free Community tier listing 1,000 monthly active users. Paid tiers are priced on monthly active users and tenants, and the Pro tier showed no list price when we read the page. Enterprise is by quote. |
| Company | Founded 2021, London. | Founded 2020, Tel Aviv. |
Where authorization policy lives in Cerbos and Permit.io, and who reviews it
Once authorization is a shared service, the rules stop belonging to one team. Security has to approve them, identity has to govern them, and an auditor will eventually ask to see the policy that was in force when something happened. So the first question is what the policy actually is, and where its history lives.
In Permit.io the source of truth is a model in Permit's control plane. You define resources, actions, roles and relationships in the policy editor, the API or Terraform, and Permit generates policy code from that model in Rego, the language of the Open Policy Agent (OPA), and can sync it to a Git repository you own. The editor lets product and support staff change roles without a release. The rules it writes are allow rules only, though. A rule like "deny this regardless of other policies" needs custom Rego written into the generated repository, and the Rego in Git is output generated from Permit's model, not the place where the policy is decided.
In Cerbos, the policy is the file. A rule like "account managers can approve payments up to their own limit" is a few lines of YAML that a security reviewer can read, with the condition written in CEL, the open expression language Kubernetes and Envoy also use. Policies live in Git or in Cerbos Hub policy stores. Changes go through the pull request review your organization already uses for production code, so every change has an author, a reviewer and a timestamp. Deny rules, allow rules and conditions sit in the same file. Tests run against every change, and Cerbos Hub only builds a deployment when they pass, so a failing policy never reaches a decision point. Hub records which build was live on every decision point at any moment and rolls back to an earlier build in one step.
People who do not write YAML every day work in the Cerbos Hub playground, where an RBAC policy generator builds a starting policy from plain answers about roles and actions, and a permissions matrix shows who can do what before a change is proposed.
When the policy is a file your reviewers approve, the review history sits in a system your auditors already trust, and nothing about the rule depends on a vendor's model to make sense.
What Cerbos and Permit.io decision points hold, and how decision data stays fresh
Every authorization decision needs data, such as the user's roles, the tenant, the account's owner or the region of a record. The design question is whether the decision point keeps its own copy of that data or reads it from the system that owns it.
Permit.io keeps a copy. Its control plane holds your users, role assignments, tenants and relationship tuples, records such as "folder finance is the parent of document q3", and OPAL, the open source sync layer Permit maintains, pushes them to each decision point, which answers from its local copy. That design gives quick local answers, and it also gives your team a second copy of authorization data to keep in step with your own databases.
Permit's own documentation, read in October 2026, describes what that costs. The Edge PDP, the decision point you run in your own network, holds the data "in OPA's in-memory JSON document, so a large environment needs a large PDP". Permit's newer Permit’s newer Nexus PDP keeps the data in an embedded database on disk instead.
Cerbos decision points are stateless. They hold policy and nothing else. The application sends the attributes it already has with each request, and where an attribute lives somewhere else, Cerbos Synapse fetches it at decision time from the identity provider, database or API that owns it, with caching set to how often it changes. Your database stays the only copy of who manages which account, so a change there applies on the next decision. There is no sync to monitor and no data set growing inside the decision point, and the same roles, attribute conditions and derived roles are evaluated in every deployment.
How Cerbos and Permit.io handle relationship checks and ReBAC
Relationship checks are where this difference matters most. "A relationship manager can see the accounts they manage" and "an editor of a folder can edit the documents in it" are relationship-based access control (ReBAC) rules, and both products support them in different ways.
Permit.io stores relationships as tuples in its control plane and syncs them to decision points, and it derives roles from them, so an editor on a folder becomes an editor on its documents. The free Community tier lists a limit of 2,000 relationship tuples on Permit's pricing page (October 2026), and the tuples are one more set of data to replicate from your systems into Permit.
Cerbos handles relationships with derived roles. A derived role turns a relationship into a role at decision time, so "relationship manager" plus "this account's manager is me" becomes "account manager" for that one request. The relationship itself comes from wherever it already lives. The application can send it with the request, or Cerbos Synapse can query it from the database that holds it, an approach we walk through for org and regional hierarchies. The relationship never has to be copied into a separate store first. For nested structures such as regions, departments or folder paths, Cerbos conditions include hierarchy functions that check whether one path sits under another, so "a manager for EMEA can see records in EMEA.UK.London" is a single condition.
That covers ownership, team and tenant membership, account management, approval chains and hierarchies like region or department.
Authorization across applications, gateways, data platforms and AI agents in one policy set
An authorization service that stops at the application leaves the gateway, the data platform and the agent to someone else's rules. Permit.io covers applications and APIs through SDKs, and has added an MCP gateway for AI agent tool calls.
Cerbos covers each of these layers from one set of policies and one audit log, and most of it needs no application code at all.
- Applications call Cerbos through an SDK, one call in place of the permission checks scattered through most codebases.
- API gateways and service meshes use Cerbos Synapse as the external authorization service for Envoy and Istio, so every request through the gateway or mesh is checked.
- Data platforms get Cerbos answering Trino's authorization calls, so a query returns only the rows and columns a person may see, and Kafka's, so only approved services read or write a topic.
- Kubernetes admission requests go through a Cerbos Synapse route extension, so what may run in the cluster follows the same policy language.
- Applications you cannot change are governed at the gateway in front of them, with no code changes.
A role change made once applies on the next request in every one of these places, and every decision goes into the same audit trail.

AI agent and MCP authorization in Cerbos and Permit.io
Permit.io's agent story is its MCP gateway, a proxy you put in front of MCP servers. It signs the user in, asks for consent, classifies tools by risk and authorizes each tool call against Permit's policies.
Cerbos starts from one premise. Agents follow access, not instructions. A prompt is a request, not a control, so the decision about what an agent may do has to happen when it acts.
- Tool calls. Every tool call an agent makes through an MCP server or gateway is checked against policy before it runs, down to the arguments the agent passes.
- AI coding agents. For tools like Claude Code, Cerbos Synapse checks each tool call through the agent's hooks, and the settings roll out through device management so nobody switches them off locally. We wrote up how that works in governing AI coding agents.
- The person behind the agent. The user's identity can be sent alongside the agent's in the same request, so one decision checks both.
- Retrieval. Query plans filter what an agent can retrieve, including a documented adapter for LangChain with ChromaDB.
The difference is that the agent's tool call, the API it reaches, the database query behind it and the Kafka topic it writes to all answer to the same Cerbos policies. Put Cerbos in front of an agent's tool calls without enforcing anything at first, and every call is logged with the user behind it, the tool, its arguments and what policy would have decided. Write the policy from that record, then tighten it step by step, read-only on financial systems or no payments above a set amount. Each change applies on the next call, without redeploying the agent. A security team can approve an agent rollout with controls it can show an auditor, rather than blocking it or signing a risk acceptance.
Customer-managed roles and multi-tenancy in Cerbos and Permit.io
B2B products reach a point where every enterprise customer wants its own roles, and the product team does not want to build them one ticket at a time.
Permit.io ships Elements, prebuilt screens for user management, access requests, approvals and audit logs, embedded in your product as iframes. Cerbos gives you the APIs to build role management into your own product, the way your product needs it.
Per-tenant policies live in their own Cerbos Hub policy stores, one per tenant or group of tenants, combined with your base policies into one versioned, tested deployment. Your customer admin portal updates a tenant's roles through the Cerbos Hub API and SDKs, which are documented for exactly this, per-tenant roles and user-defined permissions. Scoped policies let a tenant override a base rule without touching anyone else's.
The screen your customers see is your own, in your product's design, and every change they make is versioned, tested and traceable to the decision it affects. We walk through the pattern in self-service custom roles.
Where Cerbos and Permit.io run decisions, and what happens when something is down
Permit.io runs in a hybrid model by default. The control plane stays in Permit's cloud, and the decision points run either in Permit's cloud as the managed Cloud PDP or in your network as the Edge PDP. The Cloud PDP is the fastest start, and according to Permit’s documentation (November 2026) it counts requests per client IP address, allowing 1,000 single checks and 3,000 requests in all each minute, and, in Permit’s words, ABAC and custom policy as code “need an Edge PDP”. Production teams that need either end up running Edge PDPs. Light on-premise moves policy administration into your network while the management interface stays in Permit's cloud, and full on-premise, the whole stack on your Kubernetes, is on the Enterprise plan.
Cerbos evaluates every request inside your infrastructure. Decision points run wherever the workload does, as a shared service, a sidecar, a DaemonSet, a serverless function or in the browser through WebAssembly, and they scale by adding instances. Cerbos Hub sends policy to them encrypted with each deployment's own credentials, so only that deployment's decision points can read it. If Hub is unreachable, running decision points keep serving the last policy they received, and new ones start from the last built copy. Decisions never wait on a vendor service, and there is no data sync to fall behind.
For regulated teams that cannot depend on a hosted control plane at all, Cerbos Hub runs on-premise, including in air-gapped environments. Large financial services teams often raise a self-hosted control plane as one of their first requirements.
Audit logs and compliance evidence in Cerbos and Permit.io
Both products log decisions. What matters to a security team is how quickly they can answer "show me the policy that was in effect at the time", and for how long.
Cerbos logs every decision with the request inputs and the outcome, linked to the policy version that made it, and each decision can also return the matched policy and any derived roles to the caller. Cerbos Hub collects those logs from every decision point into one searchable trail. You filter by person, resource, action or decision, follow a decision back to the policy version that produced it, and export the logs for long-term archiving. Hub keeps them for three months on Development, a year on Production and as long as you need on Enterprise. Pair that with the Git history of every policy change and the evidence for an access question is a search, not a reconstruction.
Permit.io shows decision logs on an Audit Log screen and through an API, and a log forwarder can send Edge PDP logs to your own stack. Its Community tier lists 14 days of log retention.
Cerbos itself holds a SOC 2 Type II attestation, and so does Permit. The decision and policy change records are what give your own SOC 2, ISO 27001, HIPAA or PCI DSS audits their evidence.
Policy languages, portability and lock-in in Cerbos and Permit.io
Permit.io’s case for portability is that it generates Rego, the policy language of OPA, the open source engine its decision points run. The generated code is open, but it is generated from Permit's model, so leaving Permit means keeping code nobody wrote by hand, or rebuilding the model somewhere else. Either way the policy has to be re-expressed, not copied.
Cerbos policies are readable YAML with conditions in CEL, an open expression language from Google that Kubernetes and Envoy also use, and that your engineers may already know. The policy structure is short enough that a reviewer can read it without vendor tooling. The decision engine at the core of the platform, Cerbos PDP, is open source under Apache 2.0, so the component in your request path can be inspected line by line, and the policies come with their own test suites.
On standards, Cerbos PDP implements the AuthZEN Authorization API, the OpenID Foundation standard for how applications ask for authorization decisions, and Permit exposes AuthZEN endpoints too. The two took part in the same AuthZEN interoperability testing. Alex Olivier, our cofounder and CPO, co-chairs the AuthZEN Working Group, so read our view on it with that in mind. A standard request format means your enforcement points do not have to change if your decision service does.
Cerbos and Permit.io pricing at enterprise scale
Both products price on active identities. Cerbos counts monthly active principals and publishes every tier except Enterprise, while Permit.io counts users and tenants and adds quotas on roles, resource types and rules.
Cerbos publishes its pricing, based on monthly active principals, the people and services that get an authorization decision in a month.
- Proof of concept. $0, with a week of unified audit logs.
- Development. From $25 a month, with three months of audit logs.
- Production. From $933 a month, with unlimited workspaces, decision points and tenants and a year of audit logs.
- Enterprise. Custom, adding SSO, self-hosted Cerbos Hub, custom audit log retention and phone support.
Permit.io lists a free Community tier of 1,000 monthly active users and 20 tenants, with quotas such as 25 roles, 50 resource types and 2,000 role assignments, according to its pricing page (October 2026). Paid tiers are priced on monthly active users and tenants with quotas on resources and rules, and Enterprise removes the limits by quote.
At millions of users, both end up on an enterprise contract. Model it before the first sales call. Count your human users, your tenants and your non-human identities, because services and AI agents need decisions too. Then add the infrastructure each option asks you to run. With Cerbos that is stateless decision points. With Permit.io it is decision points that hold a synced copy of your data, plus that sync.
Cerbos at enterprise scale
The Cerbos platform runs more than 2 billion authorization checks a month. Utility Warehouse uses it to govern access across more than 4,500 services and thousands of non-human identities, with millions of access decisions a day. Analysts cover it too, in our posts on Gartner's AuthZEN research and on KuppingerCole's policy-based access management and API security reports.

When Permit.io may still fit
If your product depends on dropping prebuilt access request and user management screens into it this quarter, or on a sharing graph many levels deep that you want stored and traversed by the authorization service itself, Permit.io covers those cases directly. For everything else, including the teams that build their own role screens on Cerbos Hub, the migration guide shows how to run both side by side until the decisions match.
Choosing between Cerbos and Permit.io
For a team making authorization a shared service across applications, gateways, workloads and AI agents, Cerbos is the stronger choice. The policy your reviewers approve is the policy that runs, in the review process you already trust. Decision points hold no copy of your data, so there is nothing to sync and nothing to drift, and every one of them evaluates roles, attributes and relationships the same way. One policy set reaches the gateway, the data platform and the agent, the control plane can run in your own infrastructure, and every decision is on record when someone asks.
As Je Sum Yip, Chief Engineer at Human Managed, put it, "Having to modify authorization is a five-minute job now."
Try Cerbos to see your own policies tested, versioned and distributed, or book a call to map your Permit.io setup to Cerbos with our team and leave with a migration plan your security and audit teams can review.
Go deeper:
FAQ
Tagged in






