# Shared Signals, CAEP and RISC: cutting off an AI agent before its token expires

> How the OpenID Shared Signals Framework, CAEP and RISC carry session and account changes between systems, and what they mean for AI agents holding tokens.

- URL: https://iamops.dev/shared-signals-caep-risc-agent-access/
- Language: en
- Author: Argo
- Published: 2026-11-22
- Category: Knowledge
- Depth: Deep dive
- Time: 8 min
- Topics: Shared Signals, CAEP, RISC, Revocation, AI agents

## TL;DR

- An access token stays valid until it expires, even after the account behind it is disabled. [Shared Signals](https://iamops.dev/shared-signals-caep-risc-agent-access/#three-specifications-one-pipe) lets the identity provider tell the API right away.
- SSF 1.0, CAEP 1.0 and RISC 1.0 became OpenID [Final Specifications](https://iamops.dev/shared-signals-caep-risc-agent-access/#three-specifications-one-pipe) on 2 September 2025. CAEP covers sessions and devices, RISC covers accounts.
- Each event is a [Security Event Token](https://iamops.dev/shared-signals-caep-risc-agent-access/#what-travels-a-security-event-token): a signed JWT with typ secevent+jwt, a sub_id instead of sub, and no exp.
- Wire the receiver where the agent's calls land and start with [session-revoked and credential-change](https://iamops.dev/shared-signals-caep-risc-agent-access/#the-events-to-wire-first). Short-lived, [key-bound tokens](https://iamops.dev/dpop-par-rar-explained/#dpop-binds-the-token-to-a-key) still matter.
- Microsoft CAE is [based on CAEP](https://iamops.dev/shared-signals-caep-risc-agent-access/#who-implements-it) and allows up to 15 minutes of latency. Okta receives SSF events and Google's Cross-Account Protection is based on RISC.

An AI agent signs in through a user, gets an access token and starts working. An hour later the user's account is disabled because a laptop was stolen. The identity provider knows. The API the agent calls does not, and it keeps accepting the token until `exp`. Agents make that gap worse: they run unattended, they cache tokens and they call many APIs with them.

Shared Signals is the OpenID answer to that gap. It does not shorten tokens. It gives the identity provider a standard way to tell everyone who relies on it that something changed, so they can end the session now.

## Three specifications, one pipe

On 2 September 2025 the OpenID Foundation membership approved three Final Specifications from the Shared Signals Working Group (85 approve, 1 object, 25 abstain):

| Specification | What it defines |
| --- | --- |
| Shared Signals Framework (SSF) 1.0 | The pipe: roles, streams, delivery, subjects and the event format |
| Continuous Access Evaluation Profile (CAEP) 1.0 | Events about sessions, credentials, devices and risk |
| Risk Incident Sharing and Coordination (RISC) 1.0 | Events about accounts: disabled, purged, compromised, recovered |

A Final Specification is not subject to further revision, so this is a stable base to build on. The two roles are the **transmitter**, which sends events (typically the identity provider), and the **receiver**, which acts on them (an application, a gateway, an MCP server). The CAEP abstract describes its purpose as letting receivers "attenuate access to shared human or robotic users, devices, sessions and applications". Robotic users include agents.

![Four boxes in a row: the identity provider disables the account, its transmitter sends a signed security event, the receiver ends the session and drops tokens, the next agent call is refused. Below: access ends when the event arrives, not when the token expires.](https://iamops.dev/img/shared-signals-caep-risc-agent-access.svg)

*The point of the pipe. The receiver acts on the event, so the agent loses access before its token would have expired.*

## What travels: a Security Event Token

Every event is a Security Event Token (SET, RFC 8417), which is a signed JWT with an `events` claim. SSF adds rules that keep a SET from being mistaken for an ID token or an access token:

- The header carries `typ: secevent+jwt`.
- The JWT `sub` claim must not be present. The subject goes in `sub_id`, using the subject identifier formats of RFC 9493.
- There is no `exp` claim.
- The `iss` must match the stream configuration, and the receiver must check it.
- A `txn` claim can tie several events to the same underlying change.

A trimmed CAEP session-revoked event, in the shape of the examples in the specification:

```json
{
  "iss": "https://idp.example.com/",
  "aud": "https://api.example.com/caep",
  "jti": "evt-6f1c",
  "iat": 1795000000,
  "txn": "8675309",
  "sub_id": { "format": "opaque", "id": "user-4821" },
  "events": {
    "https://schemas.openid.net/secevent/caep/event-type/session-revoked": {
      "initiating_entity": "policy",
      "reason_admin": { "en": "Device reported stolen" },
      "event_timestamp": 1794999990
    }
  }
}
```

## Transmitters, receivers and streams

A receiver finds out what a transmitter supports from its configuration at `/.well-known/ssf-configuration`. That document lists the signing keys (`jwks_uri`), the supported delivery methods and the management endpoints. The receiver then creates a **stream**: which events it wants, how they are delivered and for which subjects.

- **Delivery.** Push over HTTP (RFC 8935), where the transmitter posts SETs to the receiver, or poll (RFC 8936), where the receiver fetches them. Push suits an API that is always up; poll suits a receiver behind a firewall.
- **Subjects.** Add Subject and Remove Subject endpoints let the receiver say which users or sessions it cares about, so it does not receive events for the whole tenant.
- **Verification.** The receiver can ask for a verification event to prove the stream works end to end. Do this in monitoring, not only at setup.
- **Stream status.** A stream can be enabled, paused or disabled. A paused stream that nobody notices is a silent failure.

SSF also leaves the reaction to each deployment. The specification calls this out as prescriptive SETs: an event can be purely informational or can demand enforcement, depending on what the two parties agree.

## The events to wire first

CAEP 1.0 defines eight event types. These are the ones I would connect first for agents:

| Event | Required fields | What a receiver should do |
| --- | --- | --- |
| `session-revoked` | none | End the session and drop every token derived from it |
| `credential-change` | `credential_type`, `change_type` | Re-evaluate, for example after a passkey is deleted or a password reset |
| `token-claims-change` | `claims` | Stop trusting cached claims such as roles or groups |
| `assurance-level-change` | `namespace`, `current_level` | Step down what the session may do |
| `device-compliance-change` | `previous_status`, `current_status` | Block calls from a device that left compliance |
| `risk-level-change` | `principal`, `current_level` | Feed the policy decision point |

The other two, `session-established` and `session-presented`, describe normal activity. RISC adds account events such as `account-disabled`, `account-purged`, `credential-compromise` and `identifier-changed`. RISC's own `sessions-revoked` is deprecated: new implementations must use CAEP's `session-revoked` instead.

## What it means for AI agents

The receiver has to sit where the agent's calls land. For a remote MCP server that is the MCP server, or the gateway in front of it. When `session-revoked` arrives it must drop the user's session and any token it obtained by [token exchange](https://iamops.dev/oauth-token-exchange-delegation-impersonation/#where-token-exchange-shows-up-now) for downstream APIs, otherwise the agent keeps working through a token minted before the revoke.

A policy engine can use the same signals. If the agent's tool calls go through an [AuthZEN](https://iamops.dev/authzen-opa-cedar-explained/#what-authzen-standardises) decision point, a `risk-level-change` can become part of the context it evaluates.

Signals do not replace the basics. A short lifetime limits the window when a signal is lost or late, and a token bound to the agent's key with [DPoP](https://iamops.dev/dpop-par-rar-explained/#dpop-binds-the-token-to-a-key) cannot be replayed from somewhere else. The agent should also have its own subject, so a receiver can revoke the agent without logging the user out of everything. My [managed identity lab](https://iamops.dev/secretless-agent-managed-identity-container-app/#what-this-lab-shows) shows that part.

## Who implements it

- **Microsoft Entra.** Continuous access evaluation is described by Microsoft as "an industry standard based on" CAEP. It covers events such as a deleted or disabled account, a password change, an administrator revoking refresh tokens and high user risk. Microsoft says the goal is near real time, "but latency of up to 15 minutes might be observed". With CAE-capable clients, token lifetime can grow to 28 hours, because revocation is driven by events instead of expiry.
- **Okta.** With Identity Threat Protection enabled, Okta receives SSF events from third-party transmitters through its SSF Receiver API.
- **Google.** Cross-Account Protection "is based on the RISC standard" and sends account events to apps that use Sign in with Google.

That is what each vendor's own documentation says. I have not tested interoperability between them.

## What I would do

1. Ask your identity provider whether it can transmit CAEP `session-revoked` and RISC `account-disabled`, and to which receivers.
2. Put a receiver in front of every API or MCP server that agents call, and map `sub_id` to the sessions and exchanged tokens you hold.
3. Treat an unverified or paused stream as an outage. Alert on it.
4. Keep agent tokens short-lived and key-bound, so a late signal costs minutes, not hours.

## What I did not check

I read the three Final Specifications, RFC 8417 and the vendor pages listed below. I did not run a transmitter or receiver for this article, did not measure Microsoft's latency and did not test Okta or Google. A plain-language explainer on Shared Signals is on the backlog, and a lab with an open-source transmitter is a candidate for the lab plan.

## Sources

- [OpenID Foundation, 2 Sep 2025: Three Shared Signals Final Specifications Approved](https://openid.net/three-shared-signals-final-specifications-approved/)
- [OpenID Shared Signals Framework Specification 1.0 (Final)](https://openid.net/specs/openid-sharedsignals-framework-1_0-final.html)
- [OpenID Continuous Access Evaluation Profile 1.0 (Final)](https://openid.net/specs/openid-caep-1_0-final.html)
- [OpenID RISC Profile Specification 1.0 (Final)](https://openid.net/specs/openid-risc-1_0-final.html)
- [RFC 8417: Security Event Token (SET)](https://www.rfc-editor.org/rfc/rfc8417)
- [Microsoft Learn: Continuous access evaluation](https://learn.microsoft.com/en-us/entra/identity/conditional-access/concept-continuous-access-evaluation)
- [Okta Developer: Configure an SSF receiver](https://developer.okta.com/docs/guides/configure-ssf-receiver/main/)
- [Google for Developers: Cross-Account Protection (RISC)](https://developers.google.com/identity/protocols/risc)

Discuss: [X](https://x.com/iamopsdev) | [LinkedIn](https://www.linkedin.com/company/iamops-dev/)
