Technical decision brief

Cerbos vs EmpowerID

Both products answer the same runtime question for users and for agents: may this principal perform this action on this resource? They differ in where the product sits in the request path, how much of the surrounding identity program comes with it, and how much of your architecture has to change to adopt it.

The decision

Choose Cerbos when

  • Your team already owns its gateway, agent framework, and secrets manager, and wants a decision layer that does not add another vendor plane to the request path.
  • Policy must be a reviewable artifact in your repository, with compile checks and test suites gating every change in CI.
  • An Apache 2.0 PDP, published pricing, and a documented exit path are material procurement requirements.
  • Authorization has to reach the data layer as a query filter your own ORM executes, rather than as a permitted-resource list the application applies.

Choose EmpowerID when

  • Credential non-custody or JWS-signed, hash-chained evidence packs are hard requirements to be met by the authorization vendor, because Cerbos provides neither today.
  • The programme is identity governance modernization, privileged access management, certification, or SAP identity migration, none of which are Cerbos categories.
  • A packaged agent runtime, including an MCP tool gateway, delegation-chain verification, and human-approval gating, is wanted from a single vendor rather than assembled.

At a glance

What enterprise buyers ask for

The table describes documented mechanisms. It does not assign winner scores.

RequirementCerbosEmpowerID
Where the decision point sits in the request pathCerbos ships as a standalone binary or container and supports shared-service, sidecar, DaemonSet, and selected serverless patterns. Your existing gateway, service, agent framework, or MCP server calls it. A standalone or Cerbos Hub-connected PDP evaluates locally without a per-decision Cerbos Hub round trip.EmpowerID can act as a PDP for integrated external applications over its REST APIs. The EmpowerNow and ARIA architecture is documented as an execution plane, with a policy and tool gateway intercepting before execution plus an orchestration service, which overlaps with gateways many teams already operate.
Evidence for Where the decision point sits in the request path
Policy authoring and source of truthCerbos uses YAML or JSON resource, principal, derived-role, and scoped policies with CEL conditions. Policies can live in Git, compile and test in CI, or use Cerbos Hub's source-agnostic policy stores and managed distribution pipeline.The suite models access through platform objects: access levels bundling low-level operations, management roles, business roles and locations, and resource systems. EmpowerNow policy is a JSON intermediate representation with a five-tier inheritance cascade and op:{app}:{object}.{action} operation references, managed inside the platform.
Evidence for Policy authoring and source of truth
Policy testing and CI/CD lifecycleThe Cerbos CLI compiles policies and runs YAML test suites, so a policy change can fail a build like any other artifact. Cerbos Hub adds managed validation, signed bundle builds, and distribution across Git, API, SDK, CLI, CI/CD, and browser-upload workflows.EmpowerNow publishes a documentation site, but no CLI policy compiler, policy test-suite runner, or Git and CI bundle pipeline was found in public sources as of 3 August 2026. This is an absence of public evidence rather than a proven absence, so ask how a policy change is reviewed, tested, promoted, and rolled back.
Evidence for Policy testing and CI/CD lifecycle
Agent and MCP runtime controlsCerbos is the decision point your MCP server, agent framework, or gateway calls before a tool executes. Cerbos Synapse adds protocol translation, including Envoy ext_authz and AuthZEN endpoints, plus decision-time enrichment. Cerbos does not ship a packaged agent runtime, tool gateway, or approval workflow.ARIA documents five sequential rails: SHA-256 tool-schema pinning, delegation-chain verification, AuthZEN PDP evaluation, budget, TTL and rate constraints, and on-behalf-of token exchange. It adds policy-scoped tool discovery, a WAITING protocol for human approval on high-risk operations, and bring-your-own orchestration. This is a material EmpowerID strength.
Evidence for Agent and MCP runtime controls
Credential custody at executionCerbos returns a decision and does not hold, broker, or inject credentials. Token custody stays with your existing secrets manager and execution boundary. If credential non-custody must be delivered by the authorization vendor, Cerbos does not provide it.The documented OAuth Vault keeps tokens server-side across an authorization, retrieval, and execution zone split, so the agent receives an outcome rather than a credential, with DPoP sender-constrained tokens. Cerbos has no equivalent.
Evidence for Credential custody at execution
Decision evidence and auditWhen enabled, Cerbos emits structured decision logs to file, Kafka, local storage, or Cerbos Hub, including decision context and matched-policy metadata. Cerbos Hub adds managed collection and search.ARIA documents per-action evidence packs rather than logs, binding request, policy decision, execution result, and an execution-environment fingerprint, JWS-signed and hash-chained to the previous receipt for tamper detection. This is a material EmpowerID strength.
Evidence for Decision evidence and audit
AuthZEN compatibilityThe current Cerbos PDP partially implements documented AuthZEN endpoints, Cerbos Synapse natively exposes AuthZEN endpoints, and Cerbos has participated in published interoperability testing. For disclosure, Alex Olivier of Cerbos is one of the current AuthZEN Working Group cochairs.EmpowerID appears in the published AuthZEN interoperability results across evaluation, batched evaluations, and the subject, resource, and action search scenarios. EmpowerNow documents batch semantics of execute_all, deny_on_first_deny, and permit_on_first_permit.
Evidence for AuthZEN compatibility
List filtering in the data layerPlanResources returns a datastore-agnostic filter plan that documented adapters translate into native queries for Prisma, Drizzle, Mongoose, Convex, SQLAlchemy, and ChromaDB through LangChain, so conditions are applied by the database rather than in application code.The AuthZEN search endpoints return permitted subjects, resources, or actions, and the suite supports precalculated access for before-the-fact reporting. Confirm how a permitted-resource set is applied to a large or paginated table in your own data layer.
Evidence for List filtering in the data layer
Identity governance, privileged access, and connectorsCerbos consumes the roles and attributes your identity systems already manage and enforces them at runtime. It does not provide joiner-mover-leaver provisioning, access certification, segregation-of-duties analytics, privileged access management, or an application connector estate.Documents identity governance and administration, privileged access management, certification, delegated administration, a low-code workflow engine, an identity warehouse aggregating connected systems, and a connector estate including native SAP connectivity. SaaS and on-premise installations are documented with equivalent functionality.
Evidence for Identity governance, privileged access, and connectors
Open source, SDK coverage, and pricing transparencyThe Cerbos PDP is Apache 2.0 with gRPC and REST APIs and official clients for Go, Java, JavaScript, Python, Ruby, Rust, .NET, and PHP, plus Laravel. Cerbos publishes Cerbos Hub pricing, including a $0 proof of concept tier; Cerbos Hub and licensed Cerbos Synapse capabilities are commercial.The platform is closed source, with three patent applications filed in May 2025. EmpowerID publishes a modular pricing page naming each module and its licensing unit, including a PDP and PBAC module licensed per authorizing Person object per month, but list prices are contact-sales and no public pricing for EmpowerNow or ARIA was found as of 3 August 2026. Integration is documented around REST APIs, OAuth-registered applications, mTLS with request signing, and a Python client library.
Evidence for Open source, SDK coverage, and pricing transparency

Deep dive 1

The difference is the integration surface, not the vintage

EmpowerNow is designed to sit in the execution path and hold credentials. Cerbos is designed to be called from a path you already own.

EmpowerNow's documented pipeline is Gate, Decide, Enforce, Prove: intercept before execution, evaluate through an AuthZEN PDP, apply runtime constraints, then emit a cryptographic receipt. ARIA implements that as five sequential rails on every agent action, comprising SHA-256 tool-schema pinning, delegation-chain verification, PDP evaluation, budget, TTL and rate constraints, and on-behalf-of token exchange, with denial as the default when any rail fails. It is a coherent architecture and it is shipped, not slideware.

The cost of that coherence is adoption surface. The gateway has to be in the call path, the OAuth Vault has to hold the tokens, and the tool catalogue has to be fronted by the platform. In organizations that already run an API gateway, an AI gateway, a secrets manager, and an agent framework, that is an overlap to resolve rather than a gap to fill, and it makes the vendor a dependency of every governed request.

Cerbos occupies the other position deliberately. The PDP is called by whatever is already in the path, including an execution boundary shaped exactly like ARIA's, and it does not take custody of credentials or traffic. That is a smaller promise: Cerbos supplies the decision, and the surrounding enforcement, credential isolation, and evidence remain the architecture's responsibility. Where those surrounding controls are required and nobody owns them yet, EmpowerNow answers more of the problem in one purchase.

This is not a legacy-versus-modern comparison and should not be argued as one. EmpowerNow launched in 2025 on a FastAPI PDP with a native AuthZEN surface, and EmpowerID has been shipping a converged identity platform since 2005.

Deep dive 2

Both have a real policy model; only one is a file you review

EmpowerNow's JSON intermediate representation with five-tier inheritance is a genuine policy model. The public difference is the toolchain around it.

EmpowerNow policy is documented as a JSON intermediate representation with structured rules, a five-tier inheritance cascade from GLOBAL through DOMAIN_SHARED, CROSS_ENVIRONMENT, and DOMAIN_ENVIRONMENT to APPLICATION, and operation references in the form op:{app}:{object}.{action}. The established EmpowerID suite models access separately through access levels that bundle low-level operations, management roles, business roles and locations, and resource systems. Both are structured models, not click-through wizards, and should not be characterized as such.

Cerbos policies are YAML or JSON resource, principal, derived-role, and scoped policies with CEL conditions. Scoped policies handle multi-authority hierarchies, and scopePermissions can require that a child scope only narrows what its parent allows, which is the same organizational problem an inheritance cascade solves. The difference is where the artifact lives: in a repository, diffed in a pull request, compiled by the Cerbos CLI, and covered by YAML test suites that fail a build.

No CLI policy compiler, policy test-suite runner, or Git and CI bundle pipeline was found in EmpowerNow's public sources as of 3 August 2026. That is an absence of public evidence, not proof of absence, and it should be put to the vendor as a question rather than asserted as a fact. The concrete request is a policy change demonstrated as a pull request containing a failing test, followed by a promotion and a rollback.

Deep dive 3

Two controls Cerbos does not provide

Credential non-custody and signed, hash-chained receipts are shipped EmpowerNow capabilities with no Cerbos equivalent today.

The OAuth Vault splits authorization, credential retrieval, and execution into separate zones so that an agent receives an outcome rather than a token, with DPoP sender-constrained tokens on the issued credentials. Cerbos has no equivalent and is not trying to have one: it returns a decision, and credential custody stays with your secrets manager and execution boundary. If the requirement is that the authorization vendor also removes credentials from the agent's reach, that is EmpowerNow's answer and not ours.

ARIA emits per-action evidence packs rather than logs, binding the request, the policy decision, the execution result, and an execution-environment fingerprint, JWS-signed and hash-chained to the previous receipt so tampering is detectable. Cerbos decision logs are structured, filterable, and exportable to file, Kafka, local storage, or Cerbos Hub, and they capture decision context and matched-policy metadata, but they are not signed or chained today. Presenting them as equivalent would not survive a technical review.

What Cerbos does offer as control evidence is different in kind: the policy itself is a versioned artifact with full change history, the test suite demonstrates that the control behaves as intended, and schema validation constrains the inputs. For many audit programmes that combination plus decision logs into a SIEM is sufficient. For programmes that need per-action cryptographic proof, including those scoping against EU AI Act record-keeping obligations, it is not, and that should be established before a proof of concept rather than after.

Deep dive 4

AuthZEN keeps the choice reversible, and the scope line clear

Both products speak AuthZEN, so you can test either decision point against your own scenarios instead of arguing feature matrices.

Cerbos and EmpowerID both appear in the published AuthZEN interoperability results. Cerbos Synapse exposes the AuthZEN endpoints natively, and the Cerbos PDP partially implements them alongside its own gRPC and REST APIs. Confirm the exact endpoint set and specification version each vendor supports in production for the integration you actually intend to build.

The value of the standard is that the decision point stays replaceable. Rather than comparing endpoint checklists, point both PDPs at the same corpus of your own scenarios and compare decisions, latency, and failure behavior directly. That test tells you more than any table on this page, and making it possible is why Cerbos invests in the standard: for disclosure, Alex Olivier of Cerbos is one of the current AuthZEN Working Group cochairs.

The scope boundary is the clearer decision line. EmpowerID documents provisioning, access certification, segregation of duties, privileged access management, delegated administration, a low-code workflow engine, an identity warehouse, and native SAP connectivity. Cerbos does none of that by design. It consumes the roles and attributes those systems manage and enforces them at runtime inside applications, which makes the two complementary in an estate that needs both rather than alternatives to be scored against each other.

Implementation

Prove the decision layer before touching the execution path

Separate three workstreams that are easy to conflate: policy translation, enforcement placement, and credential custody. Only the first has to move for Cerbos to be worth evaluating, and it is the one that carries the least risk.

EmpowerID or EmpowerNow conceptCerbosMigration or coexistence note
Access level bundling low-level operationsActions in a resource policy ruleExpand each bundle into the discrete actions it grants so the resulting policy is reviewable rather than opaque.
Management role, business role, and locationPrincipal roles, derived roles, and scoped policiesDerived roles cover conditional membership; scoped policies cover organizational hierarchy where a child scope may only narrow its parent.
JSON IR policy with five-tier inheritanceResource and principal policies with scopePermissionsMap each inheritance tier to a scope and decide explicitly whether the tier narrows or overrides, because the two produce different decisions.
op:{app}:{object}.{action} operation referenceResource kind plus action namePreserve identifiers so both engines receive equivalent inputs during shadow comparison.
AuthZEN evaluation or batched evaluations callCheckResources request, or the AuthZEN endpointNormalize both responses to allow or deny plus outputs before comparing; batch semantics differ and must be held constant.
AuthZEN resource search resultPlanResources query plan plus a data-layer adapterThis changes where filtering happens. Compare returned record sets and pagination behavior, not just the permitted set.
ARIA rail evaluation on an agent tool callPDP check from your MCP server or agent frameworkCerbos covers the policy rail only. Schema pinning, delegation verification, budgets, and credential injection stay with your execution boundary.

A migration that does not start by moving your credentials

  1. 1

    Scope

    Decide first whether credential non-custody and signed receipts are requirements or roadmap. If they are requirements, qualify honestly before spending effort on translation.

  2. 2

    Capture

    Build a corpus of representative principals, resources, actions, and context, including at least one agent tool call and one filtered list.

  3. 3

    Translate

    Express one authorization domain as Cerbos policies, mapping inheritance tiers to scopes explicitly, and encode the expected decisions as policy tests that run in CI.

  4. 4

    Shadow

    Call the Cerbos PDP alongside the incumbent without enforcing its result, then compare normalized decisions and reconcile every mismatch as an input, semantic, or output difference.

  5. 5

    Adapt

    For list endpoints, translate PlanResources output through the adapter for your ORM and compare returned records and pagination against the search-endpoint result.

  6. 6

    Cut over

    Move enforcement only after decision parity, query semantics, latency, and failure behavior meet the acceptance criteria, leaving credential custody and the execution path untouched.

Credential non-custody and signed receipts do not map to Cerbos. If they are in scope, keep the incumbent on those controls or implement and validate them explicitly in your own execution boundary.

Deployment

Deployment control spans the Cerbos platform

The components can be adopted independently and placed according to runtime, governance, and network requirements.

Cerbos PDP

The Apache 2.0 decision engine runs as a shared service, sidecar, DaemonSet, or selected serverless topology.

Explore Cerbos PDP

Cerbos Hub

Commercial Cerbos Hub is hosted by default and is available to enterprise customers on-premise for restricted and air-gapped environments. The Cerbos ePDP evaluates Cerbos Hub-managed policy bundles in-process through WebAssembly in JavaScript environments.

Explore Cerbos Hub

Cerbos Synapse

The commercial enrichment and integration layer runs in customer-controlled infrastructure in front of an embedded or external PDP.

Explore Cerbos Synapse

Cerbos capabilities

Follow the implementation details

These pages document the Cerbos mechanisms referenced throughout this comparison.

Research basis and disclosure

Claims were reviewed against public product documentation, official project material, and standards sources on 3 August 2026.

Compiled from public vendor documentation in August 2026. Three names matter and are not interchangeable: EmpowerID is the converged identity suite founded in 2005, EmpowerNow is the next-generation platform launched in 2025, and ARIA is the agent-runtime layer inside EmpowerNow. Details change, so verify current capabilities with both vendors before you decide.

Competitor documentation informed this comparison but is not linked from this page. Cerbos documentation and neutral standards or foundation sources were checked separately.

Alex Olivier, Cerbos cofounder and CPO, is one of the current OpenID Foundation AuthZEN Working Group cochairs. The Cerbos PDP API reference states that it partially implements the AuthZEN Authorization API.

Test the decision

Use Cerbos as the decision layer inside the architecture you own

Cerbos is the stronger choice when application and platform teams need an open PDP, policy as code, local decisions, managed distribution, and query-plan filtering in their own data layer, without handing the request path or the credentials to a new vendor plane. Prove it with one policy change containing an attribute condition, one filtered list, and one agent tool call. Implement them as Cerbos policies and tests, distribute through Git or Cerbos Hub, run shadow decisions against the incumbent, and apply a PlanResources result to the real data layer. Keep EmpowerNow where its credential vault, signed evidence packs, packaged agent rails, or identity governance breadth are verified requirements rather than assumed ones.