Cerbos vs Zanzibar

AAlex OlivierNovember 12, 202610 min read
Cerbos vs Zanzibar

If you are weighing Cerbos against Zanzibar, you are not choosing between two products. Zanzibar is the authorization system Google described in a 2019 paper and never sold. What you would actually adopt is a Zanzibar-style relationship-based access control (ReBAC) engine, such as OpenFGA or SpiceDB, or a system your own team builds from the paper. The comparison is between taking on that engine and its data, and an authorization management platform that evaluates your policies against data where it already lives.

The choice shows up for years afterwards. It sets how many engineers maintain authorization, how a leaver loses access, how a new rule reaches production and what your security team can hand an auditor. This piece compares the two on those terms.

pbac-vs-zanzibar-at-a-glance-comparison.png

Cerbos vs Zanzibar at a glance

Question Cerbos A Zanzibar-style engine (OpenFGA, SpiceDB or your own)
What it is An authorization management platform. Decision points run next to every workload, Cerbos Hub manages policy, testing and audit, and Cerbos Synapse brings in context and connects gateways, data platforms and AI agents. A ReBAC engine modeled on Google's paper, holding relationships as tuples and following them to answer checks.
What your team operates Stateless decision points that hold only policy, plus Cerbos Synapse where decisions need data the application does not send. Cerbos Hub runs hosted or on-premise. The engine, its database, the pipeline that keeps tuples in sync with your data, and the logging around it.
Where relationship data lives Where it already is. The application sends it, or Cerbos Synapse fetches it at decision time. In the engine's store, as a copy your application writes and keeps current.
Changing a rule Edit a YAML policy, run its tests in Cerbos Hub, roll it out or roll it back in one step. Change the schema, and often backfill or rewrite tuples to match.
Decision logs Every decision with its inputs, outcome and policy version, collected in Cerbos Hub. Depends on the implementation and the logging you build.
Beyond the application API gateways, service meshes, Trino, Kafka, Kubernetes admission control, MCP servers and AI agents, from one set of policies. Applications that call its API.
Standard API Cerbos PDP and Cerbos Synapse implement the OpenID AuthZEN Authorization API. Each implementation has its own API and schema language. OpenFGA's AuthZEN endpoints are experimental, behind a flag (OpenFGA documentation, read October 2026).

What your team operates with Cerbos and with a Zanzibar-style engine

The numbers in the Zanzibar paper, more than two trillion tuples and more than 10 million checks a second, came from a Google team running it on Spanner, Google's globally distributed database, across more than 30 locations. Adopting the model brings that architecture's shape to your team without that team.

A Zanzibar-style engine is a stateful service. Self-hosted, you run it in front of a database that every check reads, so that database has to be sized, replicated, backed up and kept highly available. Next to it sits a pipeline that rarely makes the architecture diagram. It writes a tuple each time a matching fact changes in your own systems, and repairs the two when they disagree. Consistency tokens, which stop a check from using relationship data older than the last change, have to be stored and passed back on later checks, and schema changes come with data migrations. A managed edition takes over the database, but not the sync pipeline or the tokens. Teams that build their own from the paper take on all of this plus the engine itself.

Cerbos PDP is a stateless decision point that holds policy and nothing else. It runs next to each workload, from a Kubernetes sidecar to a serverless function or the browser, and you add instances to scale, with no database behind them. Where a decision needs data the application does not send, Cerbos Synapse runs alongside and reads it from your own systems. Cerbos Hub manages and distributes policy, hosted or on-premise and air-gapped for enterprise customers. Decision points keep the policy they last received, so they keep serving decisions without a live connection to Cerbos Hub, and new ones start from the last built copy. For a CTO, the difference is a team that maintains authorization infrastructure against a team that maintains authorization rules.

Relationship data in Cerbos and Zanzibar, read where it lives or copied into tuples

A Zanzibar-style engine can only answer from relationships it holds. Every assignment, team change, share and deletion has to reach it as a tuple, and nothing in your database pushes it there by default. When a write fails or arrives out of order, the engine and the source disagree, which for an identity team means access nobody meant to grant, or a leaver whose access never ended. AuthZed, which builds SpiceDB, calls this the dual write problem, describes it as difficult to solve and lists six workarounds on its blog (January 2025).

Relationship data in large organizations rarely sits in one place. In a typical bank, adviser and client assignments live in a core banking system, team structure lives in the directory, and sharing lives in each application. Copying all of it into one tuple store is a data integration project before it is an authorization project.

Cerbos keeps no copy. The application sends the attributes it already loaded, and Cerbos Synapse fetches the rest at decision time from the system that owns it. That can be the core banking system, the directory or a graph database, each read where it is, with cache times set per source so revocation-sensitive facts stay fresh. When the directory moves someone to a new team, the next decision that reads the directory through Cerbos Synapse sees it, within the cache time you set, with no tuples to update or delete. Our post on reading authorization attributes from the database walks through the pattern.

In the policy, relationships become derived roles, such as owner, team member or assigned adviser, and sit in the same rule as amount, region, status and time.

Changing authorization rules in Cerbos and Zanzibar

Rules change every quarter. A new contractor tier, a regulator's restriction on one region, a product feature with its own sharing.

In a Zanzibar-style engine, effective access is the schema plus every stored tuple. A new rule is often a schema change and a data change together, a new relation to define and a backfill of tuples to populate it, and a rule that depends on an attribute such as a contract end date needs that value passed as context on every check. Reviewing a change means reviewing both halves.

In Cerbos, a rule change is a policy change. Policies are YAML with conditions in CEL that a security reviewer can read in a pull request, with test suites next to them. Cerbos Hub runs the tests on every change, only builds a deployment when they pass, shows which build every decision point runs and rolls back to an earlier build in one step. In the Cerbos Hub playground, an identity or security reviewer can try a proposed change against sample people and resources, read the permissions matrix for each role and run the tests before it ships. Existing data stays where it is. A rule that needs a new fact reads it from the system that already holds it, through the application or a Cerbos Synapse lookup, instead of a backfill.

Audit evidence in Cerbos and Zanzibar-style systems

When an auditor asks why a person could open a client record last March, the answer has to be the decision and the policy that made it.

The Zanzibar paper describes fast, consistent checks, not an audit trail. What a Zanzibar-style engine records depends on the implementation and the edition. Some enterprise and managed editions log each API call with its result, and open source deployments rely on the logging your team builds. Either way, explaining why access was granted means reading that result back against the schema and the tuples as they stood at the time.

Cerbos logs every 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, keeps them for a year on the Production tier and for a custom period on Enterprise, and exports them to your own archive or SIEM. With the Git history of every policy change alongside, the access evidence auditors ask for under SOC 2, ISO 27001, HIPAA, PCI DSS or DORA comes from a search. Cerbos itself holds a SOC 2 Type II attestation.

Gateways, data platforms and AI agents with Cerbos and Zanzibar-style engines

Relationships are an application concept, but the data they protect is reachable from more places. An API gateway sits in front of the application, an analytics platform holds a copy of the data and an AI agent works on someone's behalf.

A Zanzibar-style engine answers the applications that call it. Gateways, data platforms and agents need their own integration work, and often a second policy engine with its own language and its own audit trail.

Cerbos covers each of these from one set of policies and one audit trail. Kong, Apigee, Envoy and Istio check with Cerbos before a request reaches the service. Trino asks Cerbos which rows and columns a query may return, and Kafka asks which services may use a topic. Inside the application, a query plan turns the same policy into a filter for list pages. AI agents have each tool call checked before it runs, down to its arguments, through hooks such as Claude Code's, an MCP gateway or the MCP server, with the agent's token and the person's token in one request.

For a security team, that means approving an agent rollout with the same controls and the same evidence as everything else, instead of a separate system for agents.

Switching costs and the AuthZEN standard for Cerbos and Zanzibar-style engines

Zanzibar never had a public API, so each implementation defined its own, along with its own schema language and consistency options. OpenFGA's documentation, read in October 2026, lists its AuthZEN endpoints as experimental and behind a flag. Moving between Zanzibar-style engines means rewriting the schema and moving every tuple.

AuthZEN, the OpenID Foundation's Authorization API, standardizes how an application or gateway asks for a decision. Cerbos PDP and Cerbos Synapse both implement it, and Cerbos appears in the published interoperability results. A Cerbos policy is a readable YAML file with no data inside it, and its conditions are written in CEL, the open expression language Kubernetes and Envoy also use. Your relationship data stays in your own systems, so there are no tuples to export. Alex Olivier, our cofounder and CPO, co-chairs the AuthZEN Working Group, so weigh our view of the standard with that in mind.

Cerbos at enterprise scale

The Cerbos platform runs more than 2 billion authorization checks a month. At Utility Warehouse, it covers more than 4,500 services and thousands of non-human identities, with millions of access decisions a day.

Industry analysts list us too. Cerbos appears in the AuthZEN category of the Gartner® Hype Cycle™ for Digital Identity, 2026, and is included in KuppingerCole Leadership Compass reports on policy based access management, API security and management and generative AI defense, among others.

cerbos-vs-zanzibar-cerbos-at-enterprise-scale.png

When a Zanzibar-style engine may still fit

If the core of your product is a reverse lookup, every person who can see each object across a very large sharing graph that changes constantly, test that part on your real data before deciding. Cerbos Synapse can read that graph where it lives, and the rest of authorization, attribute rules, gateways, agents and audit, still belongs in policy.

Moving to Cerbos from a Zanzibar-style engine

Most of the move is deciding where each tuple's fact comes from afterwards, usually a column your database already has and sometimes a lookup by Cerbos Synapse. Relations become derived roles, conditions on relationships (SpiceDB calls them caveats) carry across as CEL, and checks and lookups become Cerbos checks and query plans. Teams move one resource type at a time and run Cerbos beside the engine on the same requests until every decision matches. Our guide to migrating from SpiceDB works through a SpiceDB schema, and the OpenFGA migration guide covers OpenFGA. Cerbos vs SpiceDB compares the two products side by side.

Choosing between Cerbos and Zanzibar

For most teams building fine-grained authorization across applications, APIs and AI agents, Cerbos is the better choice. Your relationship data stays in the systems that own it, a rule change is a tested policy change rather than a data migration, and every decision leaves a record of the policy that made it.

As Rob Crowe, Principal Engineer at Utility Warehouse, put it, "We needed something that wouldn't fall over under scale. Stateful systems just don't work when every service needs to make real-time decisions. Cerbos' stateless design nailed it."


Try Cerbos with your own policies. Your engineers scale authorization by adding stateless instances instead of sizing and replicating a permissions database, your identity team sees a change in the directory reach every decision without anyone touching tuples, and your security team gets one trail of decisions across applications, gateways and agents.

To plan the move off a Zanzibar-style engine, book a call with our team and work out which of your tuples already have a home in your own systems.

Go deeper:

FAQ

Tagged in

Free policy workshop

Get your first Cerbos policy written by our team.

Book a session to talk through your requirements and walk away with a working policy.

Book a session