The Scope Creep Automated reviews of new AI-related working group submissions

Review · October 26, 2026

Domain-Specific Authorization Schemas for OAuth 2.0

draft-liu-oauth-authorization-schemas -00View on Datatracker →

Scopes don't work well for agent tasks. Take "help me find and buy a laptop." A broad scope like purchase gives the agent unchecked spending power. Narrow scopes mean the agent keeps hitting authorization failures partway through the task.

This draft proposes structured, domain-specific constraint objects instead. The client asks for something like "search, add to cart and purchase, at most 1000 USD in total, only from shop.example, before Friday." The AS approves it, and the resource server checks every request against it.

This looks like the next version of draft-liu-oauth-rego-policy. That draft had clients submit Rego policy code. This one uses declarative JSON instead, and repeats "no executable content" in several places. Reverse-guided authorization carries over from the Rego draft.

How it fits in the working group

It's a profile of Rich Authorization Requests. Schema instances are just authorization_details objects with some extra rules. That's well within the charter.

It isn't a small profile, though. On top of RAR it defines:

  • Framework requirements that every "schema" type has to meet: deterministic evaluation, allowlist semantics, deny-by-default and subset rules
  • Framework fields: work_id, work_ref and evidence_ref
  • "Bounded work" and "task" requests, so tasks can be checked against a parent approval
  • Guardrail instances, which are upper bounds on other instances, both admin-configured and client-proposed
  • A schema_ref JWT claim, used when the instance is too large to inline
  • An instance lifecycle (active and ended, with four ending reasons)
  • Narrowing-only Token Exchange
  • Reverse-guided authorization: a schema_profile_uri parameter in WWW-Authenticate and a schema_profiles entry in Protected Resource Metadata
  • A new IANA registry for schema types, which starts empty

It depends on about ten OAuth RFCs: 6749, 6750, 7009, 7591, 7662, 8414, 8693, 9068, 9396 and 9728. It also normatively depends on the adopted RAR Metadata and Error Remediation draft, whose insufficient_authorization error code it reuses.

The biggest change in roles is for the resource server. The RS becomes a stateful policy enforcement point. It tracks cumulative usage, like money spent so far, across all tasks under a piece of work. The AS approves the limits but never sees how much has been used.

What the mechanism actually does

  1. The client sends an authorization_details object, such as the example transaction_authority type with a boundary of amount limit, operations, merchants and time window.
  2. The AS validates it against the schema it knows. It rejects unknown fields, checks every guardrail in effect, and applies its own policy and user consent.
  3. The AS issues a token that carries the approved instance inline, or a schema_ref the RS can resolve through introspection.
  4. On each call, the RS checks the request against every constraint present. Anything not explicitly allowed is denied.
  5. If the agent's next step falls outside what was approved, the RS returns insufficient_authorization with a schema_profile_uri. The client fetches that profile, builds a new instance from it, and goes back to the AS.

Refresh tokens re-bind the same instance. Token Exchange can only narrow an instance. Anything wider needs a new authorization.

This is a framework with nothing in it yet

The draft doesn't define a single real schema. transaction_authority is a non-normative example, and the registry starts empty. Two implementations of this spec alone have nothing in common to interoperate on.

Most of the "framework requirements" are design guidance for future schema authors, like "MUST define deterministic verification semantics." You can't test them on the wire. They'd be better as a short section of advice, or as review criteria for the designated expert.

The draft would be far easier to evaluate with one concrete schema defined normatively, such as payments. Then the WG could see whether the work, guardrail and lifecycle machinery is actually needed.

Significant interoperability concerns

Cumulative limits break with more than one RS. The RS tracks cumulative usage, like "1000 USD total," from its own business state. Say the work covers a search API and two merchant checkout APIs. Each checkout RS lets the agent spend 1000 USD, so the user's limit has turned into 2000 USD. The draft needs to restrict cumulative constraints to a single RS, or bring the AS into usage tracking.

Guardrails have no wire format. Clients can submit "proposed guardrails." Nothing on the wire tells the AS whether an authorization_details object is a guardrail or a normal request. Two implementations will invent two different signals.

Subset semantics are a SHOULD, but Token Exchange makes them a MUST. Section 3.2 says types SHOULD define subset rules. Section 9 says the AS MUST check the subset relation on every exchange. For any type that skips subset rules, Token Exchange simply can't work.

Wrong error codes. Nearly every AS failure in Table 1 maps to invalid_request. RFC 9396 already defines invalid_authorization_details for exactly these cases, and the draft never mentions it.

Inconsistent status codes. Figure 3 returns 401 with insufficient_authorization. Section 7.3 says to deny with 403. RFC 6750 uses 403 for insufficient_scope, which is the closest analog.

Unknown fields. The AS MUST reject unknown fields. The RS "MUST ignore or reject" them. Those two choices behave very differently once a schema adds a field, and the strict rejection conflicts with the extensibility RAR normally expects.

Too many identifiers. There's work_id, work_ref, schema_ref, evidence_ref, and transaction_id in the example. The difference between work_id and work_ref is unclear. So is how a task request reaches the RS with a link to its parent work. And why is the RS doing "task-in-work evaluation" at all when the AS could check that a task fits inside its work when it issues the task token?

Overlap with RAR Metadata and Error Remediation

The adopted remediation draft already serves JSON Schema per type and returns authorization_remediation with ready-to-use authorization_details. This draft adds a second approach: schema_profile_uri pointing to a new "schema profile" document format.

The profile format invents its own descriptor vocabulary, with dotted paths like boundary.total_amount_limit and a per-path required boolean. It's JSON Schema-flavored, but it isn't JSON Schema. An agent would need to understand two description formats for the same thing.

If an RS really needs reusable profiles, it should be an extension to the remediation draft, not a parallel mechanism.

The profile also has the RS send confirmation_required: true to make the client start a consent flow. Whether the user has to consent is the AS's decision. The RS shouldn't be telling the client what the AS will require.

Mechanisms that could be removed

  • Administrative guardrails. They're AS-side configuration. "The AS may enforce its own upper limits" covers it. You don't need two pages of rules.
  • The four ending reasons. Completed, withdrawn, terminated and expired never show up on the wire. Every one becomes token revocation or expiry. The RS can't tell them apart, and the draft admits the class 1 vs class 2 denial distinction is "deployment policy."
  • evidence_ref. It's carried here only to point at a different draft. That draft can define its own field.
  • The new IANA registry. RAR deliberately didn't create a type registry. Types are AS-defined, and URI types already avoid collisions. Wait until there's a real schema to register.
  • schema_ref. Inline content plus RFC 7662 introspection already covers large and opaque tokens. A second reference claim adds another path to implement with no new capability.

Writing quality

The grammar is fine and the BCP 14 usage is mostly correct. The register is the problem. Phrases like "behavioral boundaries," "behavioral drift," "binding-layer state machine" and "the conjunction of schema conformance, the AS's approval basis, and the guardrail subset check" make simple ideas hard to follow.

There's a lot of repetition. "Deterministic constraint evaluation" shows up more than a dozen times. The guardrail section says its core rule "is one sentence," then spends two pages on qualifications. "No executable content" is argued in three different sections, which reads like a rebuttal of the earlier Rego draft rather than a requirement of this one.

At 41 pages for a framework with no normative schema, it's too long. The core idea fits in a few pages: RAR types that the RS checks deterministically, narrowing-only exchange, and a remediation pointer.

Background of the Authors

This section uses Datatracker data from our August 2026 reviews of this author's earlier drafts.

Dapeng Liu (Alibaba) has published 3 RFCs, mostly in distributed mobility management in 2014–2015. Liu has around 10 active Internet-Drafts and a long IETF history (80+ expired drafts) across mobility, IoT, SDN, and now OAuth, WIMSE and agent authorization. This is an experienced IETF author who is writing a lot right now.

This draft belongs to a set of related Liu proposals: authorization evidence, chain delegation, Rego policy and cross-domain transaction tokens. Reviewers should read this one as the replacement for the Rego draft.

For more on the error remediation side, see RAR Metadata and Error Remediation.