If you are comparing Cerbos with SpiceDB, you probably need authorization finer than roles. Who shared this document, which team owns this folder, which adviser covers this client, and whether this agent may act for that person. SpiceDB, AuthZed's open source implementation of Google's Zanzibar paper, is on the shortlist for those questions. The decision you are making is less about the model than about the data. SpiceDB answers from its own copy of your relationships. Cerbos evaluates policy against data where it already lives.
That choice shapes the next few years of work. It decides whether your team runs another datastore, how a team change reaches every decision, how a list page knows what to show, and what your security team can hand an auditor.

Cerbos vs SpiceDB at a glance
| Question | Cerbos | SpiceDB |
|---|---|---|
| What it is | One authorization management platform. Cerbos PDP evaluates policy beside each service, Cerbos Hub tests, ships and audits that policy, and Cerbos Synapse gathers the facts a decision needs and connects gateways, data platforms and agents. | A ReBAC (relationship-based access control) engine from AuthZed, modeled on Google's Zanzibar paper. |
| What you operate | Stateless decision points that hold policy only, plus Cerbos Synapse where decisions need data the application does not send. Cerbos Hub runs hosted or on-premise. | The SpiceDB service, the datastore every check reads, and the code that writes a relationship for every change in your own systems. |
| Where relationship data lives | In the systems that already own it. | In SpiceDB's datastore, as a copy your application keeps current. |
| Who gathers context for a decision | The application sends what it has, and Cerbos Synapse fetches the rest at decision time. | SpiceDB holds relationships. Anything else a caveat needs is stored on the relationship or sent with each check. |
| "What can this person see" | Query plans return the policy as a filter your database applies. | LookupResources returns resource IDs, which your application then loads. |
| Decision logs | Every decision with its inputs, outcome and policy version, collected by Cerbos Hub from every decision point. | Request and response audit logs in AuthZed's Cloud, Dedicated and Enterprise editions, not in open source SpiceDB (AuthZed documentation, November 2026). |
| Standard API | Applications and gateways can ask Cerbos for decisions in the OpenID Foundation's AuthZEN format. | Its own gRPC and HTTP API. AuthZed's documentation lists no AuthZEN support (November 2026). |
| Pricing | Published, by monthly active principals, with no charge per decision. | Open source is free to self-host. Cloud is billed hourly, Dedicated and Enterprise are quoted (AuthZed pricing page, November 2026). |
What your team runs with Cerbos and with SpiceDB
Authorization sits in front of every request, so whatever it depends on has to be as available as your product.
SpiceDB is a stateful service. Self-hosted, it runs in front of a datastore that every check reads, and AuthZed's documentation recommends CockroachDB for multi-region deployments, Spanner on Google Cloud and Postgres for a single region (read October 2026). That datastore is one more production database your team sizes, replicates and backs up, and moving between datastores goes through SpiceDB's own APIs or backup tooling rather than a database dump. AuthZed's managed editions take the datastore off your hands. They do not take the second job, writing a relationship into SpiceDB every time a matching fact changes in your own systems, and fixing the two when they disagree.
Infisical, which builds a secrets platform, weighed exactly this in September 2026 and decided against SpiceDB and OpenFGA, because adopting either, they wrote, would mean āasking every self-hosted customer to run another stateful serviceā.
Cerbos decision points are stateless. Each one carries the compiled policy and no data, sits beside the workload as a sidecar, a service, a serverless function or in the browser, and scales by adding copies, with nothing to back up. Cerbos Hub builds, tests and distributes policy to every decision point, hosted or on-premise and air-gapped for enterprise customers, and if Cerbos Hub is unreachable, running decision points keep serving the last policy they received. For a CTO, what stays with the team is the policy, with no authorization datastore to staff.
Relationship and attribute data in Cerbos and SpiceDB
Fine-grained decisions need facts. The people on a team, the folder above a document, the client an adviser covers, a document's classification, a person's clearance, the time of day. The question for any authorization system is where those facts come from at the moment of the decision.
SpiceDB answers from the relationships it holds. Your code calls WriteRelationships for every assignment, share or team change, and a failed or reordered call leaves SpiceDB holding a different answer from your database. For an identity team, a missed write is a share that never took effect, or a person who moved teams and kept the old team's documents. Facts that are not relationships, such as a clearance level or an IP address, go into caveats, conditions written in CEL whose values are stored on the relationship or sent by the caller with each check.
With Cerbos, the application sends what it already loaded, often just IDs, and Cerbos Synapse fetches the rest at decision time from the system that owns it. That can be your identity provider, a directory, a database, an internal API or a graph database, each read where it lives, with a cache time set per source, meaning how long Synapse may reuse a fact it fetched, so a short cache on team membership keeps revocations quick. A person who changes teams in the directory gets the new team's access on the first check after that source's cache time runs out, and nobody writes anything to make it happen. We show the pattern in reading authorization attributes from the database.
A new rule that needs a new fact works the same way. Cerbos Synapse fetches the fact, so the rule ships without a change to every application that calls Cerbos. Schemas keep requests and policies in step. Mark the attributes a policy depends on as required, set schema enforcement to reject, and Cerbos denies any request that leaves one out and returns the validation errors, so a rule never runs on a missing fact.
Writing the same rule in SpiceDB and in Cerbos
Security approves rules, identity teams govern them and engineers ship them, so the rule itself has to be readable by all three.
Take one rule. Members of the team that owns a folder can view its documents, as long as their clearance is at least the document's level. In SpiceDB, the relationship part goes in the schema and the clearance part in a caveat.
definition user {}
definition team {
relation member: user
permission membership = member
}
definition folder {
relation owner_team: team
permission view = owner_team->membership
}
caveat clearance_check(document_level int, user_clearance int) {
user_clearance >= document_level
}
definition document {
relation parent: folder with clearance_check
permission view = parent->view
}
For this to answer anything, your application also writes three kinds of relationship and keeps them current, each person's team memberships, each folder's owning team and each document's folder with its level stored on the caveat. Each check then sends the person's clearance as context.
In Cerbos, the same rule is one condition over attributes. The document's folder team and level come from your database, and the person's teams and clearance come from the identity provider or directory, through Cerbos Synapse or the application.
# resources/document.yaml
apiVersion: api.cerbos.dev/v1
resourcePolicy:
version: default
resource: document
rules:
- name: owning-team-views-within-clearance
actions: ["view"]
effect: EFFECT_ALLOW
roles: ["user"]
condition:
match:
all:
of:
- expr: R.attr.folderTeam in P.attr.teams
- expr: P.attr.clearance >= R.attr.level
Both rules fit on a screen. What differs is what each depends on. The SpiceDB rule is only as current as the relationships your code wrote, and reviewing a change means reviewing the schema and the data together. The Cerbos rule reads current facts from their owners, sits in Git next to its test suite, and only reaches production when Cerbos Hub has run those tests. Relationships that repeat across rules, such as owner or assigned adviser, become derived roles that any rule can reuse. A reviewer who does not write YAML can open the Cerbos Hub playground and see who can do what before a change ships.
Listing what a person can see with SpiceDB LookupResources and Cerbos query plans
Most screens ask a bigger question than "can Ana open this document". They ask for every document Ana can open, sorted, filtered and 50 to a page.
SpiceDB answers that with LookupResources, which walks the relationship graph and returns the IDs of the resources a person can reach. Your application then loads those records, so sorting and filtering by your own fields happen after the permission step, over whatever set of IDs comes back. On very large graphs, AuthZed's answer is Materialize, which precomputes the expensive parts of the graph and went generally available on AuthZed Dedicated in September 2026 (AuthZed announcement, read November 2026).
Cerbos query plans work the other way round. Cerbos returns the policy as a condition, "the folder's team is one of Ana's teams and the level is at most her clearance", and an adapter adds it to the query you already run. The database returns only the rows Ana may see, already sorted and paginated, from the same data your product reads. Ready-made adapters exist for Prisma, Drizzle, Mongoose, Convex and SQLAlchemy, plus LangChain with ChromaDB for retrieval.
Consistency in SpiceDB and Cerbos, ZedTokens or reading the source
A permission system that answers from its own copy of the data has to say how fresh that copy is. SpiceDB's answer is the ZedToken, a token for a point in time that your application stores after a write and passes on later checks, so a check never uses relationships older than the change it follows. Without it, SpiceDB's default mode favors speed over freshness, which is how a person removed from a folder can still see a document added to it moments later. Getting this right is application code your team writes and maintains.
Cerbos keeps no standing copy of your relationships, so there is no token to carry. Facts are read from the system that owns them, and how stale a fact fetched by Cerbos Synapse can get is the cache time you set for that source, short for revocation-sensitive facts such as team membership and longer for facts that rarely change. Those cache times sit in Cerbos Synapse configuration, where a reviewer can check them.
Cerbos and SpiceDB for AI agents, gateways and data platforms
The case for ReBAC engines in AI rests on three claims, that agents should be treated like people, that policy engines hide the cost of gathering data before every decision, and that a relationship graph already holds that data.
Every agent needs an identity of its own. Beyond that, an agent is not a person, and Cerbos checks it as itself. An agentās token and the personās token travel in the same request, so one policy can check both the agent's own permissions and the permissions of the person it acts for. The second point is the job Cerbos Synapse does, fetching the person, the resource and the relationships between them at decision time. The third point covers the facts a graph holds, and agent decisions also depend on facts that are not relationships, the tool being called, its arguments, the amount, the data's classification and the time. SpiceDB can take those as caveat context, which puts the calling code back in charge of gathering them.
What matters for a security team is where the check happens. With Cerbos, every tool call is checked against policy before it runs, down to its arguments, wherever you enforce it, in the agent through hooks, as with Claude Code, at an MCP gateway, or in the MCP server itself. Agents follow access, not instructions, so the prompt is never the control. You can put Cerbos in front of an agent's tool calls before writing any policy, with audit logging on, so every call is logged with the person behind it, then write the policy from that record and narrow it, read-only on payment systems or no deletes in production, without taking the agent offline. AuthZed ships no hook or gateway that checks tool calls in flight, so with SpiceDB each tool's code makes the check through an SDK (AuthZed documentation, November 2026).
The same policies reach past the application. Cerbos Synapse is the external authorization service for Envoy and Istio, Cerbos works with Kong and Apigee, Trino checks rows and columns with Cerbos, and Kafka checks topic access. On the SpiceDB side, checks come from applications that call its API, and an Envoy external authorization integration has been an open request on its GitHub tracker since 2021 (read November 2026). With Cerbos, it is one policy set and one audit trail, wherever the request arrives.
Audit logs and compliance evidence in Cerbos and SpiceDB
When an auditor picks one access from six months ago, your team has to show the request, the answer and the rule that applied.
In SpiceDB, audit logging comes with AuthZed's Cloud, Dedicated and Enterprise editions, and open source SpiceDB does not include it (AuthZed documentation, read November 2026). Where it is on, each API call is logged with its request and response.
Every Cerbos decision point can log each decision with its inputs, its outcome and the policy version behind it. Cerbos Hub collects those logs from every decision point into one searchable trail, filtered by person, resource, action or outcome, and exports them for your own archive. Because every policy change is versioned, the record a SOC 2, ISO 27001, HIPAA, PCI DSS or DORA auditor asks for is already there, decision and rule together. Cerbos itself holds a SOC 2 Type II attestation.
Standards and lock-in with Cerbos and SpiceDB
SpiceDB has its own API and its own schema language, and its data model is a set of relationships in SpiceDB's own format. As of November 2026, AuthZed's documentation lists no support for AuthZEN, the OpenID Foundation's standard Authorization API, ratified in January 2026. Every relationship you write is stored in SpiceDB's own format, inside SpiceDB.
Cerbos PDP and Cerbos Synapse both implement AuthZEN, so your applications and gateways ask for decisions in a standard format. Cerbos policies hold rules only, and your data never moves into Cerbos, so there is no second copy of your data to keep in sync or export. Alex Olivier, our cofounder and CPO, co-chairs the AuthZEN Working Group, so take that into account when you read our case for it.
Cerbos and SpiceDB pricing
SpiceDB open source is free to self-host, and the cost is the datastore, the people who run it and the code that keeps relationships in sync. AuthZed Cloud is billed by the hour, and AuthZed's rate card, effective 16 October 2026, lists a region charge of $2.17 an hour in AWS us-east-1 before the per-vCPU charges for SpiceDB and its datastore. Dedicated and self-hosted Enterprise are quoted, and Enterprise is licensed per region and per vCPU (AuthZed pricing page, read November 2026).
Cerbos publishes its pricing, based on monthly active principals, the people and services that get an authorization decision in a month, with no charge per decision and no datastore to size.
- Proof of concept. $0, with a week of decision logs.
- Development. From $25 a month, with three months of decision logs.
- Production. From $933 a month, with unlimited workspaces, decision points and tenants, and a year of decision logs.
- Enterprise. Custom, adding SSO, self-hosted Cerbos Hub, custom log retention and phone support.
With Cerbos, the bill follows the people and services you authorize.
Cerbos at enterprise scale
The Cerbos platform handles more than 2 billion authorization checks a month. Utility Warehouse uses it for millions of access decisions a day, across more than 4,500 services and thousands of non-human identities, with millions of access decisions a day
Analyst firms cover the category too. The Gartner® Hype Cycle⢠for Digital Identity, 2026 recognizes Cerbos in its AuthZEN category, and KuppingerCole includes Cerbos in Leadership Compass reports covering policy based access management, API security and management and generative AI defense, among others.

When SpiceDB may still fit
Where the screen your product depends on is LookupResources over millions of objects shared ad hoc, run that screen against a Cerbos query plan on your own data before you commit. Materialize exists for that case on AuthZed Dedicated. Cerbos Synapse can read the graph from where it already lives, so the attribute rules, gateway checks, agent checks and audit trail stay in one policy. When you are ready to move, the SpiceDB migration guide works through a schema one resource type at a time.
Choosing between Cerbos and SpiceDB
If you are choosing SpiceDB for its relationship model, Cerbos evaluates the same relationship rules in policy without a second datastore, and it is the better choice for most teams. Relationships and attributes sit in one readable policy, the facts come from the systems that own them, list pages are filtered by your own database, and every decision is logged with the policy behind it.
As Rob Crowe, Principal Engineer at Utility Warehouse, put it, "The number of NHIs we authorize isn't just the number of services, it's that, multiplied by the number of users, multiplied again by the call depth. Cerbos is the only thing that makes that manageable."
Try Cerbos with one of your relationship rules. Your engineers stop writing a relationship for every change in your own database, your identity team sees a leaver lose access once the directory changes and the cache time they set runs out, and your security team can show an auditor the rule and the inputs behind any access.
To plan the move from SpiceDB, book a call with our team, bring your heaviest LookupResources screen, and leave with the query plan that replaces it.
Go deeper:
FAQ
Tagged in






