Research
Cryptographically verifiable authorization for autonomous AI agents: a falsifiable hypothesis and proof of concept
Autonomous AI agents now invoke tools, call APIs and touch protected resources with limited human oversight, but existing mechanisms (OAuth 2.0, OpenID Connect, SAML, credential delegation) only…

- arXiv
- 2607.21325
- Published
- 2026-07-23
- Authors
- M. Llambí-Morillas, D. Fernández-Fernández
AI summary
Overview
Research area: Applied cryptography and computer security (cs.CR), specifically access control and authorization for autonomous AI agents, using zero-knowledge proof systems.
Technical level: Advanced. The paper is written in formal cryptographic notation (security games, relations, commitment schemes) and assumes familiarity with zk-SNARKs, commitment schemes, and standard authentication/authorization concepts. The prose framing is accessible, but the core model is not beginner material.
Scope (one sentence): The paper proposes and formally sketches a cryptographically verifiable authorization relation that binds an agent principal, a specific request, an execution context, and policy satisfaction, then instantiates parts of it in an executable Groth16-based proof of concept and argues that the gap between authorization binding and runtime execution binding is a structural open problem.
What This Paper Is About
Autonomous AI agents now invoke tools, call APIs and touch protected resources with limited human oversight, but existing mechanisms (OAuth 2.0, OpenID Connect, SAML, credential delegation) only establish who an agent is or what authority was delegated — they do not produce cryptographic evidence that a specific request from a specific agent in a specific context satisfies an applicable policy. The authors formalize this missing object as "authorization evidence" and hypothesize that authorization can be represented as a request-bound, zero-knowledge-verifiable relation that also keeps private authorization attributes confidential. Their goal is a falsifiable hypothesis plus a working proof of concept, not a finished security proof.
Key Contributions
-
A preliminary formal abstraction of Cryptographically Verifiable Agent Authorization (CVA). The authors define a relation
R_CVA(x, w) ∈ {0,1}together withSetup(1^λ, R_CVA),Prove(pp, x, w)andVerifyAuth(pp, x, π) = 1, where the public statement isx = (id_i, h_q, h_c, pid_j, n, t)and the private witness isw = (sk_i, ρ_i, attrs_i, q_priv, c_priv). -
A compact set of candidate security properties. Authorization soundness, principal binding, authorization-request binding, policy binding, context binding, and replay resistance — each stated as a game or inequality with negligible-advantage bounds, explicitly labeled as candidate definitions rather than established guarantees.
-
An executable zero-knowledge proof of concept instantiating selected elements of the model over a Groth16 zk-SNARK construction, with the identity commitment simplified to
id_i = Poseidon(sk_i)for circuit efficiency. -
Formalization of a structural separation among identity binding, authorization-request binding, and runtime execution binding as a central open problem, connected to the classical confused-deputy problem and time-of-check-to-time-of-use (TOCTOU) race conditions, and argued to be absent from current agentic security frameworks.
Main Findings
-
Authentication and delegation do not imply authorization. The paper's motivating claim is stated as a logical non-implication:
AuthN(A_i) ⇏ AuthZ(q_i)andDelegate(U, A_i, κ) ⇏ AuthZ(q_i). Authentication or delegation may be necessary, but neither is sufficient to establish that a concrete request is authorized. -
Authorization is modeled as four conjoined constraints.
R_CVA = BindPrincipal ∧ BindRequest ∧ BindContext ∧ SatisfyPolicy, whereBindPrincipalrequiresCommitID(sk_i, ρ_i) = id_i,BindRequestrequiresH_q(Encode(q_priv)) = h_q,BindContextrequiresH_c(Encode(c_priv)) = h_c, andSatisfyPolicyrequiresP_j(attrs_i, q_priv, c_priv) = 1. Each conjunct is argued to rule out a distinct transfer attack: omitting principal binding enables cross-principal reuse, omitting request binding lets a policy-satisfying proof authorize unintended actions, omitting context binding weakens context-dependent authorization, and omitting policy satisfaction decouples the proof from the decision. -
Evidence objects are not interchangeable. The paper distinguishes
Identity Evidence ≢ Authorization Evidence ≢ Execution Evidence, and adds thatRequest Commitment ≠ Internal Agent Intent— the proof establishes that a committed request satisfies a policy, not the agent's internal reasoning. -
Replay resistance is stateful and gateway-dependent. Acceptance is
Accept(x, π) = VerifyAuth(pp, x, π) ∧ Fresh(n, t, N), withFresh(n, t, N) = 1iffn ∉ Nandt_min ≤ t ≤ t_max. Because nonce-set and timestamp-window state live at the gateway, gateway compromise would void freshness — but principal, request and policy binding survive, since those depend on SNARK verification over the public statement rather than gateway-held state. -
Authorization binding is not execution binding. Equation 42 states
VerifyAuth(pp, x_q, π) = 1 ⇏ q_exec = q_auth. A ZK circuit is evaluated at proof-generation time and has no access to runtime state, so closing this gap requires an execution-time trust anchor such as remote attestation, a trusted execution environment, or verifiable execution receipts. -
Positioning against prior work. Table 1 compares DIAP, Huang et al., BAID ("Binding Agent ID"), Aegis, zk-MCP and AIP (Invocation-Bound Capability Tokens) across identity, delegation, policy compliance, audit, pre-execution authorization and ZKP. The authors conclude that no existing work explicitly models authorization as a request-bound cryptographically verifiable relation, while stressing that the novelty claim concerns this formalization, not the use of ZKPs for agentic systems in general.
-
Context binding is specified but not implemented.
h_cis part of the formal model and of the context-binding property, but its implementation is left open in the proof of concept and flagged as a priority. -
The identity commitment in the prototype is weaker than the model. Using
Poseidon(sk_i)provides principal binding under hash assumptions but does not realize the randomized hiding semantics ofCommitID(sk_i, ρ_i); the authors acknowledge this as a limitation. -
No quantitative evaluation is reported in the available text. The paper reports no benchmark results, dataset sizes, latency figures or accuracy measurements of its own; the only numeric performance claim cited is a sub-millisecond verification overhead attributed to Prakash's AIP reference implementations. The reduction arguments are explicitly informal, without explicit extractor or simulator constructions (Limitation 1, Section 7).
Methodology in Plain English
The authors work in three layers. First, they build a mathematical model: an agentic environment is a tuple S = (A, G, T, R, P) of agents, gateways/verifiers, tools, resources and policies, and an authorization request is a tuple q_i = (id_i, α, res, c, pid_j, n, t) where the action α = (tool, operation, args). Sensitive request fields are replaced by domain-separated hash commitments (h_q, h_c) and the policy by a versioned identifier pid_j = H_P(policy_code_j ‖ version_j), so the verifier sees only what it needs.
Second, they define what an attacker can do — intercept and replay proofs, substitute identifiers, swap request commitments, present proofs under a different policy, or run unauthorized agents — and turn five attack classes (proof forgery, cross-principal transfer, cross-request transfer, cross-policy transfer, replay) into five security games with negligible-advantage targets. They then sketch, informally, how an attacker who wins a game could be turned into an attacker against Groth16 knowledge-soundness, hash collision resistance, or the binding property of the commitment scheme.
Third, they take an existing zero-knowledge authorization prototype built on Groth16 and map it onto the abstraction as "evidence of constructive feasibility" — a demonstration that the pieces can be built, not a measured evaluation. Throughout, they separate the stateless cryptographic core (the proof) from stateful checks (nonce and timestamp freshness at the gateway), treating the latter as a distinct enforcement layer.
Why This Matters
Impact on research. The paper reframes a practical complaint about agent identity systems — ISACA's "looming authorization crisis," echoed by the OpenID Foundation — as a missing formal security property. That gives the field something testable: a named relation, candidate properties, and an explicit falsifiable agenda. The distinction between authorization-request binding and runtime execution binding is the sharpest contribution, because it says the ZKP layer alone cannot guarantee that what was authorized is what gets executed, linking agent security back to confused-deputy and TOCTOU problems.
Real-world applications:
- Enterprise identity and access management extended to autonomous agents operating under existing OAuth 2.0 / OIDC / SAML stacks.
- Regulated workflows (finance, healthcare) where an agent must prove a request satisfies a policy without disclosing the underlying private attributes or the raw request arguments.
- Tool-calling and multi-agent platforms where agents invoke external services and need per-request, pre-execution authorization evidence rather than a bearer credential.
- Privacy-preserving audit and compliance, where a verifier confirms policy compliance without learning the sensitive data behind it.
Industry relevance. The model is designed to sit as an orthogonal layer beneath existing identity and delegation infrastructure, which matters for vendors already shipping agent identity frameworks (DIAP, Aegis, BAID, AIP). The explicit warning that gateway compromise voids replay protection — while principal, request and policy binding survive — is a concrete design constraint for anyone deploying an authorization gateway.
Future Directions
- Complete the reductions. Turn the informal sketches into full proofs with explicit extractor and simulator constructions, reducing soundness and binding to Groth16 knowledge-soundness, hash collision resistance, and
CommitIDbinding (Limitation 1). - Implement context binding.
h_cis formalized but unimplemented; the authors call this a priority. Related is replacingPoseidon(sk_i)with the randomized hiding commitmentCommitID(sk_i, ρ_i). - Close the authorization-to-execution gap. Runtime consistency needs a trust anchor operating at execution time — remote attestation, a trusted execution environment, or verifiable execution receipts — together with a treatment of context drift between authorization and execution.
- Extend beyond a single agent-gateway interaction. The model currently covers one interaction; multi-hop delegation chains and a complete symbolic adversary model for multi-agent authorization chains are left as future work.
Target Audience
Cryptography and security researchers working on access control, zero-knowledge proof applications, and agentic system security; protocol and identity architects at organizations deploying autonomous agents; and graduate students or advanced practitioners who need a formal framing of why agent authentication and delegation are not the same thing as per-request authorization. Readers looking for empirical benchmarks, deployment measurements or a finished security proof will not find them here — the paper is a formal framing plus a feasibility demonstration.
Authors’ abstract
Autonomous AI agents increasingly execute actions, invoke tools, and operate on protected resources with limited human oversight. Existing authentication and authorization mechanisms establish identity and delegate authority but do not inherently provide cryptographic evidence that a concrete request issued by a specific agent satisfies the applicable policy in a specific execution context. This study hypothesizes that agent authorization can be formalized as a…
The full abstract on arXiv