Review · November 10, 2026
Grant Catalog, an Authenticated Feed That Tells the IdP What to Put in an ID-JAG
The problem it's solving
ID-JAG lets an enterprise IdP issue a grant that a SaaS application's authorization server redeems for an access token. The IdP has to know what that application will accept: the tenant identifier, the resource, the scope values, which claims, whether DPoP binding is required.
Today an IdP admin reads the application's docs and types those values in. A typo shows up only when the application rejects the grant, after the client has already seen its claims. Nothing tells the IdP when the application changes its requirements.
Public metadata can't carry this. It is unauthenticated, it isn't per tenant, and ID-JAG prohibits using it to disclose which issuers a server trusts.
This draft has the application's AS publish that configuration as an authenticated JSON document, one per IdP relationship. The IdP admin approves entries instead of typing them.
How it fits in the working group
It is a companion to ID-JAG, which is an adopted document. It sits in the configuration plane, not the token flow. Nothing changes for the client or the resource server.
It adds one endpoint, one AS metadata member, two media types, one scope value, and a new JWT type. The normative references include 12 OAuth RFCs, five JOSE and JWT RFCs, ID-JAG, rfc7523bis, the unadopted JWT DPoP grant draft, and the OpenID Connect Enterprise Extensions draft for the tenant claim.
It creates one new relationship. The IdP becomes a client of the application's AS. In ID-JAG the trust runs one way: the application's AS trusts the IdP's signing keys. Here the IdP calls the application's token endpoint and a protected API on it.
It also tightens ID-JAG when a catalog is in use. The resource claim becomes required and single-valued. Optional claims like email and acr can only appear if an entry lists them. A multi-tenant application must name the tenant explicitly.
What the mechanism actually does
The application's AS publishes a Relationship View. It is one JSON document for one IdP, or one tenant of a multi-tenant IdP. It lists the application tenants that IdP may target. Each tenant points to a Grant Catalog.
A Grant Catalog is a list of entries. Each entry covers one grant profile and one resource. It lists permitted scope values, RAR types, claims, subject identifier formats, and binding methods (dpop or mtls). Each can be marked required or optional.
Entries have no rule language. There are no alternatives, exclusions, or conditions. An application that accepts scope A or scope B but not both publishes two entries.
The IdP fetches the view with a two-step OAuth exchange. It signs a "catalog access assertion" with the same keys that sign its grants. It presents that at the application's token endpoint as a JWT bearer grant and gets a short-lived access token. It uses the token on a GET to the catalog endpoint. The whole view comes back in one response, with no paging.
The IdP checks the view against public metadata. An entry that names a grant profile or RAR type missing from the application's AS metadata or Protected Resource Metadata is unusable.
An IdP admin approves a subset of each entry, per tenant. The IdP then issues each ID-JAG from exactly one approved entry.
Each entry has a revision. When it changes, the IdP stops issuing under the old approval until an admin approves the new revision. When a tenant or entry disappears, issuance for it stops.
The catalog is not an authorization decision. The application's AS still validates every grant at redemption and can reject one that matches the catalog.
So what does the admin still do by hand?
Quite a lot. The draft lists it in the introduction: setting up the relationship, exchanging keys, registering the client at the application, mapping the client ID, mapping subjects, and learning any per-client restrictions.
The ID-JAG client_id claim is required, and the catalog doesn't supply it. The catalog removes the resource, scope, claim, and binding fields from the admin's form. The rest of the form stays.
Significant interoperability concerns
Any entry change stops issuance. A new revision suspends every approval made for the old one, even when the change only adds an optional scope. If Slack adds a scope to its standard catalog, every customer's agents stop getting ID-JAGs for that entry until each customer's IdP admin clicks approve. Applications will learn to never edit an entry, or to skip the revision bump. The draft tracks this as an open issue.
The authentication choices are set out of band. The "Onboarding Arrangement" decides whether client authentication is required, whether the assertion must be DPoP-bound, which keys are used, and whether the IdP is multi-tenant. No metadata signals any of it. The IdP learns the combination from documentation, which is the problem the draft set out to remove.
The approval rules can't be observed. Most of the normative text governs what the IdP stores and when an admin must re-approve. The application's AS can't see or test any of that. Two IdPs can differ here and still interoperate on the wire.
Staleness has no bound the application controls. The maximum age is a SHOULD with no value. After a relationship ends, the IdP keeps issuing from its last copy for as long as it has configured. Also an open issue.
Entries can't describe values. An entry can require acr but not a particular acr value. It can require a RAR type but says nothing about the object's contents. Grants built correctly from the catalog will still fail at redemption for these reasons.
There is no must-understand mechanism. Extensions that restrict an entry are forbidden until one exists. The draft says it has to be added "before the format stabilizes."
Two normative dependencies are not adopted work. DPoP-bound assertions rely on the individual JWT DPoP grant draft. Tenant identification relies on an OpenID draft.
The whole view is one response. The draft targets "several thousand" tenants per view and puts paging and deltas out of scope.
Mechanisms that could be removed
- The catalog access assertion. The IdP may already be a registered client of the application's AS. A client credentials request with
private_key_jwtand a tenant parameter would get the same token without a new JWT type, atypregistration, and the cross-JWT confusion rules. As written there are four combinations of assertion, client authentication, and DPoP. - The Grant Profile Definition framework. It is a nine-item template with one instance. Write the draft for ID-JAG and generalize when a second profile shows up.
- Pluggable retrieval protocols. Only one is defined.
- The approval and reconciliation state machine. Table 16 and the "approved subset" rules are IdP product behavior. They could be guidance.
- The tenant-to-catalog indirection. Sharing catalogs across tenants saves bytes. It also adds a second trigger for re-approval when a tenant's
grant_catalogpointer changes. - Two levels of required and optional. Presence requirements plus item requirements, with a rule for how they interact.
description,documentation_uri, anddefinition_uri. Admin UI text with its own SSRF and untrusted-content rules.displayis probably enough.mtlsbinding andsub_idformats. Start with scopes, claims, and DPoP.- Appendices C and D. A worked lifecycle and two pages of design rationale.
What's left is a metadata member, an authenticated GET, and a JSON document listing tenants, resources, scopes, claims, and binding. That would be a short spec.
Writing quality
The writing is clean and in proper IETF style. Terms are defined once and used consistently. The examples are complete. The open issues and design rationale are stated honestly, and -01 was an editorial restructuring with no normative changes.
It is 76 pages for one JSON document and one GET. The same rules show up in the overview principles, the data model, the processing sections, and the security considerations. Most paragraphs point to three or four other sections.
Many requirements are written as plain statements without BCP 14 keywords: "A Grant Issuer does not infer a rule," "The Grant Issuer does not resolve a conflict by preferring catalog values." It isn't clear which of these an implementation is held to.
The mechanisms are well justified. The scope is the issue. A lot of the text defends against edge cases a first version doesn't need, such as a revision value reused with different content.
Background of the author
Sole author, Karl McGuinness, listed as Independent, formerly at Okta.
Datatracker could not be reached for this review. The figures below are from the profile as checked for the October reviews.
- 0 published RFCs
- 16 active Internet-Drafts and 2 expired, as of mid-October 2026
- Co-author of ID-JAG, the adopted document this draft builds on
Not a new author, and writing at a very high rate. The count is higher now.
Questions worth raising
- Is the hand-typed configuration painful enough to standardize this? Client registration, client ID mapping, and key exchange stay manual. The catalog automates the fields that are easiest to copy.
- Should this be part of ID-JAG's own discovery story? ID-JAG Section 9.7 leaves room for a protected discovery mechanism for clients. This draft defines a different one for IdPs and leaves the client one open.
- Can re-approval be limited to changes that widen an entry? Without that, applications have a strong reason to avoid ever updating one.
- Why a new assertion type instead of client credentials? The rationale says a tenant selector would be defined differently by each application. A single defined parameter would solve that.
- Should the IdP's approval workflow be normative at all? The wire format and the retrieval protocol are the interoperable parts.
- Does the working group want the general framework or the ID-JAG feature? The second is much smaller.
For the grant this catalog describes, read ID-JAG.