Robots Atlas>ROBOTS ATLAS
Safety

Cedar

2023ActivePublished: 6 August 2026Updated: 6 August 2026Published
Key innovation
Separating authorization logic from application code into a dedicated, declarative policy language with guaranteed termination and formal verification (a model in Lean), enabling fast and analyzable access control.
Category
Safety
Abstraction level
Building block
Operation level
ToolingOrchestrationApplication
Use cases
Authorization in applications (resource access control)Access control for AI agent actions and toolsAmazon Verified PermissionsAWS Verified AccessFine-grained authorization (RBAC/ABAC/ReBAC)Policy analysis and validation

How it works

A developer defines a schema describing the types of principals, actions, resources and their attributes, and then a set of policies in the Cedar language (e.g. 'permit(principal in Group::"admins", action, resource);'). At runtime the application passes the Cedar engine an authorization request made of four elements: principal (who), action (what), resource (on what) and context (extra data, e.g. time, IP, MFA). The engine evaluates all matching policies and returns a decision: Deny by default, unless a matching 'permit' policy exists and no 'forbid' applies. Because the language allows no loops or unbounded recursion, evaluation always terminates, and a validator can statically check policies against the schema and analyze their equivalence.

Problem solved

Traditionally authorization logic is woven directly into application code, making it hard to audit, test, reuse and change without risking security bugs. Cedar externalizes this logic into declarative policies that can be analyzed, versioned and verified independently of the application.

Components

PolicyDefines the conditions for granting or denying access.

A single permit/forbid rule expressed in the principal-action-resource-context model.

SchemaA type contract for policies and the validator.

A declaration of principal, action and resource types and their attributes, enabling static validation of policies.

Authorization engineEnforces access decisions at runtime.

The component that evaluates an authorization request against the policy set and returns an Allow/Deny decision with the determining policies.

Validator / analyzerStatic analysis and policy safety.

A tool that checks policies against the schema and analyzes their properties (e.g. equivalence after refactoring).

Official

Implementation

Implementation pitfalls
Default denyMedium

Absence of a matching 'permit' policy means denial. Missing a required policy silently blocks access.

Fix:Test policies and use the validator plus coverage analysis for critical scenarios.
Schema-data driftMedium

If the attributes passed in a request do not match the schema, validation and decisions can be wrong.

Fix:Keep the schema as the source of truth and validate request data against it.

Evolution

Original paper · 2024 · OOPSLA 2024 (arXiv:2403.04651) · Joseph W. Cutler
Cedar: A New Language for Expressive, Fast, Safe, and Analyzable Authorization
Joseph W. Cutler, Craig Disselkoen, Aaron Eline, Shaobo He, Kyle Headley, Michael Hicks, Kesha Hietala, Eleftherios Ioannidis, John Kastner, Anwar Mamat, Darin McAdams, Matt McCutchen, Neha Rungta, Emina Torlak, Andrew Wells
2023
Cedar released as open source (Apache 2.0)
Inflection point

AWS announced and open-sourced the Cedar language and its Rust implementation; Amazon Verified Permissions launched in parallel.

2024
Research paper and formal Lean model published
Inflection point

A paper describing the language and a formal Lean model with proofs of key properties (soundness, safety, analyzability) was published.

Hyperparameters (configurable axes)

Access-control modelHigh

Cedar can express different authorization models within one language.

RBACRole/group based
ABACBased on principal/resource/context attributes
ReBACRelationship-based (in hierarchies)

Computational complexity

Time complexity: O(P) — liniowa wzgledem liczby i rozmiaru polityk.

Hardware requirements

Primary

Cedar is a policy-evaluation engine running on a general-purpose CPU; it needs no accelerators.