# How to Let AI Agents Sign Up for Your App Safely — Isabelle Williams, WorkOS

Isabelle Williams, WorkOS

[Talk page](https://ai.engineer/talks/uTrY8slys0w-let-ai-agents-sign-up-your-app) · [Video](https://www.youtube.com/watch?v=uTrY8slys0w)

## How to Let AI Agents Sign Up for Your App Safely

Isabelle Williams uses Waypoint, a travel-planning app, to explain agent-accessible registration, user identity assertions and scoped agent tokens—and demonstrates why permission limits matter when an agent starts moving company money.

![Recording frame at 18:04: How to Let AI Agents Sign Up for Your App Safely](https://ai.engineer/api/talk-essay-media/5ba1dabe742ffabb71441d0ce5a080cf7e6046a7fdf3064c44b9bf4e744cae55)

How to Let AI Agents Sign Up for Your App Safely — recording at 18:04

### When the agent does the product discovery

[0:12](https://www.youtube.com/watch?v=uTrY8slys0w&t=12s)

A travel-planning app normally asks a person to discover it, create an account and get far enough to see why it is useful. What happens when that person delegates the whole search to an agent? Isabelle Williams, a product manager at WorkOS, explores that question through Waypoint, an app she built with Cursor for personal and company travel. The working task is to plan a trip to AIE in New York City.

![Recording frame at 0:39: When the agent does the product discovery](https://ai.engineer/api/talk-essay-media/dc2130b29114f1d5ca5d53d8a3aeadc7260f47ffad9d7d5291c7153e95047f02)

When the agent does the product discovery — recording at 0:39

An agent doing product discovery also needs a way to get started. If registration requires the person to leave the conversation, navigate a browser and collect credentials, the delegated workflow stops before the app can demonstrate its value. Waypoint therefore needs an entrance an agent can use—and a way to connect the resulting work to a real customer.

Company travel adds a harder requirement. An agent that can spend or move corporate funds needs limits, attribution and revocation. These concerns produce three distinct design questions: how an agent gets access, whose behalf it acts on, and which actions it may take once inside.

### auth.md describes the entrance; the API enforces access

[2:12](https://www.youtube.com/watch?v=uTrY8slys0w&t=132s)

[auth.md](https://workos.com/auth-md) is the agent-facing starting point. Williams presents it as an open registration protocol expressed through a Markdown file hosted with the application. The file explains how to obtain access, create an account and begin calling the API. A person can read it, but its intended reader is the agent trying to use the product.

![Recording frame at 3:03: auth.md describes the entrance; the API enforces access](https://ai.engineer/api/talk-essay-media/cfe377cbe14167519d468c636e55f2151b77e5484e74690074ecae50693d3e96)

auth.md describes the entrance; the API enforces access — recording at 3:03

The important division is between description and enforcement. Writing down allowed operations does not enforce them. Waypoint's API remains responsible for checking authorization. The file helps an agent discover the supported route; the application decides whether a request is permitted.

Waypoint uses two access conditions:

- **Anonymous exploration:** An agent can take limited actions without first creating a user account, giving it a chance to establish that the app is useful.
- **User-connected access:** Once Waypoint can tie the agent to a real user, it can expand the available actions.

That distinction lets registration happen after some useful work, rather than making it a prerequisite for every interaction.

### Try anonymously, then let the user claim the work

[3:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=218s)

The first route separates permission to do limited work from ownership of that work. During anonymous access, the agent receives an access token for API calls and a separate claim token. The claim token supports a later transfer: a user can take ownership of what the agent has already done and bring it under their account.

![Recording frame at 4:53: Try anonymously, then let the user claim the work](https://ai.engineer/api/talk-essay-media/e32029f0c973303bb81cc918473cc27a67dcf176e71cfde91dacc3cd57be2a87)

Try anonymously, then let the user claim the work — recording at 4:53

When the user wants to claim the work, the agent provides a link and a one-time code. The user visits Waypoint, signs up or signs in, and enters the code. After the claim, Waypoint's OAuth authorization server can issue the agent an access token on behalf of that user. Subsequent API calls then operate in the user's context.

This solves the ownership problem, but it retains a conversion problem: the person still follows a link, completes authentication, enters a code and may need to verify an email address. Williams's objection is practical: “this is where you lose your user.” If the agent's provider already has a signed-in user and a verified email, why require the application to collect that identity again through another manual signup?

### Use an identity assertion without surrendering the app's decisions

[5:46](https://www.youtube.com/watch?v=uTrY8slys0w&t=346s)

The second route lets the agent provider assert the user's identity to Waypoint. It begins with discovery: the agent finds the protected API or MCP server and its OAuth authorization server. It then asks the user for consent to share identity information and an email address with Waypoint. With consent, the agent requests an **ID-JAG** from its provider and sends that assertion to Waypoint's authorization server.

Waypoint verifies the assertion and decides what to do with it. It may create a new account, link the identity to an existing account, and choose the scopes to place in the access token returned to the agent. The assertion supplies identity information; it does not make those application decisions. Only after the exchange does the agent receive the access token it uses to call Waypoint on the user's behalf.

ID-JAG expands to **Identity Assertion JWT Authorization Grant**, shown in the talk as an IETF Internet-Draft. Williams connects it to enterprise managed authorizations in the MCP ecosystem and Okta's Cross App Access. In the Waypoint flow, the agent provider is the issuer and Waypoint's authorization server is the intended audience. The provider signs an assertion about a particular user for a particular recipient.

What information lets Waypoint distinguish who is making the assertion from whom it concerns and where it may be used? The illustrated assertion separates those roles:

- **Header:** Identifies the ID-JAG type, signing algorithm and signing key.
- **Issuer and user information:** Identifies the agent provider and carries the user's email address and whether that email was verified.
- **Recipient and client:** Names Waypoint as the audience and identifies a client known to Waypoint.
- **Validity and signature:** States how long the assertion is valid and provides the issuer's signature for verification.

These fields make the identity handoff inspectable. Waypoint still chooses which issuer claims to trust and what access to grant; a valid signature does not itself settle account linking or permission policy.

![Recording frame at 8:39: Use an identity assertion without surrendering the app's decisions](https://ai.engineer/api/talk-essay-media/adf51557783f790c68e766f4a1de01ec35954b247b21307ff9440b211360caa9)

Use an identity assertion without surrendering the app's decisions — recording at 8:39

### Sam gets an itinerary without completing a signup form

[9:09](https://www.youtube.com/watch?v=uTrY8slys0w&t=549s)

The demonstration starts in a custom agent harness that can issue ID-JAGs. Its signed-in user is Sam Rivera, a fresh identity that Waypoint has never seen. Sam asks for an AIE New York City itinerary that can be shared with coworkers, and asks the agent to find a suitable planning tool. During the search, one alternative requires browser signup and another requires an API key. Waypoint offers a registration path the agent can use.

The agent asks permission to share Sam's name and verified email with Waypoint. There is also a separate consent request for elevated access: booking dinner reservations. Williams approves both. This is an important qualification to the hands-off signup: the demo removes manual account creation, while retaining human approval for identity sharing and the more consequential booking capability.

What does that access produce? The harness reports that it verified Sam's identity and created the Waypoint account. It then returns an itinerary, a dinner reservation at Quality Bistro and a link Sam can share with colleagues. The useful change is from a user unknown to Waypoint to a user with an account and shareable work, without a separate signup form. This demonstrates the flow in Williams's ID-JAG-capable harness; it does not establish that an arbitrary agent provider can already perform the same exchange.

![Recording frame at 11:25: Sam gets an itinerary without completing a signup form](https://ai.engineer/api/talk-essay-media/03150710326d534fb21d093bfeb9ec58281a8bcea00f3cb280b53c5b20fed912)

Sam gets an itinerary without completing a signup form — recording at 11:25

The interoperability requirement follows directly from that example. A registration route only helps discovery if agents and applications can understand the same exchange. Williams's closing judgment on this part is that safe, trusted agent access will require open standards for talking to services, signing up, acting and paying. The custom harness demonstrates a working path; standardization is how she expects that path to extend across providers and applications.

### Give the agent a permission ceiling, not the user's token

[12:08](https://www.youtube.com/watch?v=uTrY8slys0w&t=728s)

The company-travel example changes the stakes from creating an itinerary to moving corporate money. Jordan is responsible for company funds and is the only person allowed to approve the budget and approval rules. Waypoint provides two in-app agents:

- **Read-only agent:** Can answer questions about the budget but cannot change it or move money.
- **Funding agent:** Can move funds between users within the approved budget and rules, but cannot change either constraint.

For example, someone flying from San Francisco may need more funding than someone arriving by train from Boston. Jordan wants an agent to handle that redistribution without gaining the power to rewrite the budget to make its task easier.

When Jordan invokes an agent, Waypoint's backend issues a separate agent token instead of handing over Jordan's user token. That separation serves three different purposes:

- **Attribution:** Actions can be attributed to the agent that performed them.
- **Independent revocation:** Jordan or Waypoint can revoke the agent without ending Jordan's session or removing Jordan's own access.
- **Limited permissions:** The token can carry fewer scopes than Jordan possesses.

How does Waypoint prevent either the user or the agent configuration from granting too much access? Each agent has a blueprint defining its maximum scopes. The issued token receives the intersection of that ceiling and the invoking user's permissions:

\[
\text{agent token scopes} = \text{user permissions} \cap \text{agent blueprint scopes}
\]

The two inputs converge on the token; they are not successive permission grants. A capability must be allowed by both. Jordan's broader budget-management permissions therefore do not automatically pass to the funding agent, and a blueprint cannot give an invoking user permissions they lack.

Two permission limits feed one agent token
Both the user's permissions and the agent blueprint constrain the issued token. The agent then uses that scoped token for API calls.
- Jordan's permissions — The permissions held by the user invoking the agent.
- Agent blueprint — The maximum scopes allowed for this kind of agent.
- Issued agent token — Contains only permissions shared by the user and the blueprint.
- Waypoint API — Receives the agent's calls using the scoped agent token.
- Jordan's permissions → Issued agent token (Constrains token to the user's permissions)
- Agent blueprint → Issued agent token (Constrains token to the blueprint's ceiling)
- Issued agent token → Waypoint API (Used by the agent to authorize API calls)

### Keep the acting agent distinct from the represented user

[14:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=878s)

The live session details make the intersection concrete. Jordan's user token has several permissions; the read-only blueprint has only one. The resulting agent token carries their intersection. Its subject is the agent ID, while separate information records that it acts on behalf of Jordan. What should the comparison reveal? The credential identifies both the actor performing the work and the user represented by that actor, without treating them as the same identity.

The read-only agent's behavior is skipped in the interest of time. The demonstration moves to the funding agent, where the permission distinction can produce an observable result: the agent will try to fix Alex's budget while the team has only about $70 available.

### A $250 shortfall meets $70 of permitted action

[16:09](https://www.youtube.com/watch?v=uTrY8slys0w&t=969s)

Alex has a $250 shortfall. The funding agent asks whether it should rebalance funds, and Williams confirms. It moves $70 to Alex—the amount available—but cannot resolve the full shortfall. The remaining problem is not a lack of instructions: there is no more budget available, and the funding agent is not allowed to increase it.

What does a permission ceiling look like in the result? Here it is partial completion: $70 moves, but the rest of the request remains unresolved. The agent can redistribute existing funds without gaining permission to enlarge the pool. This is the consequential distinction between Jordan's authority and the authority delegated to the funding agent.

![Waypoint funding screen showing a $2,000 approved budget, $320 available, and Alex marked Covered after a $180 transfer.](https://ai.engineer/api/talk-essay-media/bf4b6a4a93d46894da82eca618aec9cbd8a3ee82978014bb0eb46f6020c42aca)

After Jordan increases the approved team budget to $2,000, the funding agent transfers the remaining $180 to Alex, who is marked Covered. The screen shows $320 still available.

Jordan still has the missing permission. Using the user session, Williams changes the team budget to $2,000 and tells the agent that the budget has increased. The agent can then fix Alex's budget. The correction changes the available funds through a separately authorized human action; it does not require expanding the agent's permission ceiling.

That ending ties the registration and authorization mechanisms together. `auth.md` tells an arriving agent how to get access. A claim flow or ID-JAG connects its work to a customer. Once the agent acts inside the app, an agent-specific token limits what it can do and supports attribution and revocation. Williams identifies WorkOS Agent Auth as the product used for the scoped in-app agents. The funding example shows the permission limit in action; independent revocation is an architectural capability described here, rather than an operation performed in the demo.

## Key takeaways

- `auth.md` makes registration and access mechanisms discoverable to agents. The application must still enforce authorization at its API.
- Anonymous access lets an agent demonstrate value before signup. A claim token, link and one-time code let a user later take ownership of that work and authorize continued access.
- An ID-JAG lets an agent provider assert a consenting user's identity. Waypoint still decides whether to trust the claims, create or link an account, and issue particular scopes.
- Issue a separate agent token whose scopes are the intersection of the user's permissions and the agent blueprint's ceiling. Keep the agent's identity and revocation separate from the user's session.
- The agent moves $70 from the team reserve toward Alex’s $250 shortfall, reaching the approved spending limit. After Jordan raises the limit to $2,000, the agent transfers the remaining $180.

## Resources

- [auth.md: user registration for agents](https://workos.com/auth-md) — WorkOS's entry point for the agent-registration approach used in Waypoint, useful for following up on agent-accessible signup.

## Related talks

- [Auth for Agents: Let AI Sign Up for Your Product with auth.md — Michael Grinich, WorkOS](https://ai.engineer/talks/nSkmXakJ6eo-auth-agents-let-ai-sign-up) — Grinich’s talk also covers agent signup with auth.md.
- [How AI Agents Pay: Checkout in ChatGPT and Google AI Mode — Sam Parsons, PayPal](https://ai.engineer/talks/c5U-XbbEN-g-ai-agents-pay-checkout-in-chatgpt-google) — Williams briefly mentions agent payments. Parsons’s talk focuses on checkout in ChatGPT and Google AI Mode.

## Slides

### Authentication infrastructure

[0:20](https://www.youtube.com/watch?v=uTrY8slys0w&t=20s) [A grid of products illustrates the range of apps, agents and APIs served by authentication infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/fd47481fa98cc71558d8370eb968d0a6d01d4719ae7dc2794567fd507b67a028.webp)

WorkOS
Infra for auth - build apps, agents, APIs
OpenAI
SIERRA
ANTHROPIC
THINKING
MACHINES
O fal
• parallel
7 CURSOR
n clay
Ill Wispr Flow
Sz Fireworks AI
3 baseten
S Scribe
Laravel
i perplexity
HEX
GANANA
incident.io
> Replit
sis snowflake
* FACTORY
6 granola
turbopuffer
Decagon
A PostHog
+ Temporal
PlanetScale
• Profound
bolt
88 PLAID
xexa

### Three questions for Waypoint

[1:53](https://www.youtube.com/watch?v=uTrY8slys0w&t=113s) [The slide asks how agents get in, how they connect to customers and how to limit their actions.](https://assets.ai.engineer/sites/aiecode2025/sha256/09aa5c8eb7deb51e985e22d57d0401868985594ed62e17495e73536249a80319.webp)

My questions for Waypoint
01 How do we let agents in?
02 How do we connect agents to customers?
03 How do we limit what they can do?

### Letting an agent try the app

[3:18](https://www.youtube.com/watch?v=uTrY8slys0w&t=198s) [The slide pairs an anonymous entry point with a way to claim the activity later.](https://assets.ai.engineer/sites/aiecode2025/sha256/ee2f569e01507134ec0f022c4e50dcbd3a68783b4287ca856d32fd1794f4d8cf.webp)

01 Let agents in
02 Connect to a customer
03 Limit actions
How to let agents in
waypoint-aie.workos.cloud/auth.md
# Waypoint agent access
## Discover
Read the resource and authorization server metadata.
## User claim
Start anonymously, then have the user claim the work.
## Agent verified
Register with a trusted provider's ID-JAG.
## Get an access token
Exchange an assertion or claim token at /oauth2/token.
## Call the API
Call Waypoint's API with an access token.
Try it anonymously
Limited actions for anonymous agents to test your
product.
On behalf of a user
Expand available actions, tied to a user.
auth.md explains access and operations. Waypoint enforces auth at the API.
Workos

### From anonymous to user-claimed

[3:45](https://www.youtube.com/watch?v=uTrY8slys0w&t=225s) [A sequence diagram follows an agent session as it is attached to a user.](https://assets.ai.engineer/sites/aiecode2025/sha256/55540de6ba80ea4e0fbab59e530e09f6fdf9cac570c241191427dc5ee5f31138.webp)

01 Let agents in
02 Connect to a customer
03 Limit actions
Anon → User claimed
Limited anonymous access
User
Agent
Your app / API
POST /agent/identity {type: anonymous }
Create registration + pre-claim assertion
200 OK identity assertion + claim token
POST /oauth2/token • jwt-bearer assertion
200 OK access_token + pre-claim scope
Agent operates with pre-claim scopes
Let agents show value, then connect their work to a customer with approved access.
WorkoS

### Verifying an agent

[6:48](https://www.youtube.com/watch?v=uTrY8slys0w&t=408s) [The sequence diagram shows how an agent can present evidence about the user it represents.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb548a7259617bbf09acd53cf617bf0c11e4ca8d9cf80a432a29346584cc0548.webp)

Agent verified
Discover authentication → Get provider identity → Verify and grant access
User • Agent • Agent Provider • Your app / API
Consent to share identity?
Consent granted
Request audience-specific ID-JAG
Verify signature + claims, match user

### Delegating an allowed action

[14:04](https://www.youtube.com/watch?v=uTrY8slys0w&t=844s) [The bottom row traces a request from Jordan through the app backend to the agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/65303ff0636649e80b85b9dc83f2bf17005b5f4c0f6997c347c831ddcff1e9b3.webp)

Limit and revoke what an agent can do
Jordan: Responsible for company funds. Only Jordan can change approved budgets and approval rules.
Read-only agent: Answers questions about users and funds. Cannot move funds or edit budgets and approval rules.
Fund agent: Moves funds between users. Cannot edit budgets or approval rules.
How an agent gets access: Jordan → App backend → Agent

### Three things to build

[17:46](https://www.youtube.com/watch?v=uTrY8slys0w&t=1066s) [The closing checklist covers letting an agent in, connecting it to a customer and limiting its actions.](https://assets.ai.engineer/sites/aiecode2025/sha256/f062483a20de494156485b4f11656f0e5c0667c1e39ff848ad2dd3bddab22e91.webp)

Three things
to build
01
02
03
Let agents in
auth.md and your API
Connect to a customer
User claim or identity assertion
Limit actions
Enforce permissions and revocation
Workos

## Full transcript

[0:12](https://www.youtube.com/watch?v=uTrY8slys0w&t=12s) Hi, everyone. My name is Isabelle. Um, I'm a product manager at WorkOS. Today, I'm gonna be talking about how your next user is an agent. Briefly on WorkOS, um, we do infra for auth. We help you build apps, agents, APIs. Um, we're trusted by over three thousand customers, including OpenAI, Anthropic, and Cursor. Okay. Um, for my presentation today, I'm gonna be using an app that I vibe coded with Cursor. It's called Waypoint. Um, it is a travel planning app both

[0:43](https://www.youtube.com/watch?v=uTrY8slys0w&t=43s) for individual use and for company travel. And we're gonna use Waypoint today to help plan our trip to AIE in New York City. All righty, so over the past year, but especially in the past few weeks with Muse and Instinct and the rise of personal agents, I've been thinking a lot about what this means for Waypoint. The first thing that I've been thinking about is: how do I let agents into my app? So when I think about the personal travel tier of Waypoint, um, before agents, it's, you know,

[1:13](https://www.youtube.com/watch?v=uTrY8slys0w&t=73s) really important from, like, a product-led growth perspective to think about how human users discover my application, get signed up, and get to that aha moment really quickly. But when I think about how I'm using personal agents, and how I think others are gonna be using personal agents, if they're not already, is that they're gonna be turning over a lot of that research, product discovery, and getting started with the product and getting to that aha moment totally over to their agents. So I'm thinking about how it's gonna be really important that I let agents do this with Waypoint. Now, as I got a little

[1:43](https://www.youtube.com/watch?v=uTrY8slys0w&t=103s) further into that thinking, the next question that I have is: how do I connect those agents that are getting started with my product in this mode, um, to real customers? And then finally, as I think more about how Waypoint works for company travel for corporate teams, there are compliance and financial risk elements to that. So it's really important to me to make sure that I can limit what an agent can do, um, I can revoke it when I need to. So with those three questions in mind, let's talk through how I did them with

[2:12](https://www.youtube.com/watch?v=uTrY8slys0w&t=132s) Waypoint. So the first thing that I'm thinking about, how to let agents in. Um, if you go to this link here, um, it ends in auth.md. So this is a real link. You can actually go to this, but it's not meant for us. It's meant for agents. auth.md is an open protocol, um, that, um, talks about how agents can register for accounts with applications.

[2:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=158s) auth.md is a Markdown file that you host with your application. And again, you can go to it and read it, but it's not meant for us. It's meant for your agent. It's where an agent can discover how to get started with your application. It describes the mechanisms for getting access, for creating an account, um, and being able to call and use your API. One thing that's important to remember with auth.md is that it describes access and operations, but your application, so in this case, Waypoint, is the one that's

[3:08](https://www.youtube.com/watch?v=uTrY8slys0w&t=188s) enforcing auth at your API. So in this auth.md file that I'm gonna talk about for Waypoint, and I'm gonna demo, um, there's two modes to it. The first mode is allowing agents to, um, try my application in anonymous mode. So I want agents to be able to take limited actions to prove that my application has value without having to sign up and create an account. But to the second question I posed earlier, I really want these agents to be acting on behalf of users. So I want

[3:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=218s) to be able to expand the available actions, um, that I give to these agents when I can tie them back to a real user. So let's jump into the first mechanism of the AuthM-auth.md protocol for how that can happen. So this flow goes from letting an agent try things out in an anonymous mode, and then a user coming in and claiming what that agent did and transferring the actions over to the agent account.

[4:04](https://www.youtube.com/watch?v=uTrY8slys0w&t=244s) So the first part of this protocol is an agent being able to take anonymous actions at my API. So in the end of this, the agent gets an access token, and then they get something that, a claim token, that eventually is gonna let a user claim what the agent did and move it under that user's account. So the flow to this one, at some point when the user wants to take ownership of what their agent is doing, the agent can give them a link and a one-time code. The user comes

[4:34](https://www.youtube.com/watch?v=uTrY8slys0w&t=274s) over to my application, Waypoint. They sign up, they sign in, they enter the code. They've claimed what the agent has done. They've brought it under their account. And finally, using OAuth, um, my authorization server can issue an access token on behalf of that user to the agent, and the agent's gonna use that to call my API.

[4:55](https://www.youtube.com/watch?v=uTrY8slys0w&t=295s) So this lets the agent do things, but you might have noticed there is a link and a sign-up flow and entering a code and verifying my email. And if you know anything about product-led growth, you know this is where you lose your user. But doesn't my agent already know who I am? Like, when you guys use Claude Code today, when you use Muse, you're signed in, and that service has done something to verify that you are who you say they are-- who you

[5:24](https://www.youtube.com/watch?v=uTrY8slys0w&t=324s) say you are, because they care about ensuring that you are probably a real person. So they verified your email or something to that extent. So if the agent knows who I am, why can't the agent provider just tell my application who I am and let me in without me having to take manual actions?

[5:46](https://www.youtube.com/watch?v=uTrY8slys0w&t=346s) Well, that's also possible with auth.md. So I'm gonna break down this protocol and the standard called ID-JAG that it's built on, and I'll show you a little demo of how this works. So to break this down, this starts with your agent discovering how to authenticate with your API. This is like standard OAuth parlance, so finding out about your protected resource, your API, your MCP server, um, and your OAuth authorization server. And then things get a little fun. So your agent is gonna come to you as the user

[6:16](https://www.youtube.com/watch?v=uTrY8slys0w&t=376s) and ask for consent to share your identity and your email with the application Waypoint. If you consent, the agent goes to the agent provider. So your, you know, Claude agent goes to Claude and says, "Hey, give me an ID-JAG." Put a pin in that. I'll come back to what that is in a second. So the agent gets the ID-JAG, sends the ID-JAG over to your API's authorization server. Your application, your authorization server, is going to verify that that

[6:46](https://www.youtube.com/watch?v=uTrY8slys0w&t=406s) ID-JAG is the real deal. It's gonna see some information on you inside of it, and then your app is in control of deciding, am I gonna create an account for this user? Am I gonna link it to an existing account? What sort of access am I gonna give back in the access token to this agent? Your app is completely in control of that. And so finally, with that access token, the agent can call your API on behalf of the user.

[7:11](https://www.youtube.com/watch?v=uTrY8slys0w&t=431s) So I said something, to use a Claude term, a little bit load-bearing, um, in this, ID-JAG. Has anyone here heard of ID-JAG?

[7:20](https://www.youtube.com/watch?v=uTrY8slys0w&t=440s) I see one person, and he works with me, so that's funny. Um, so if you've been following what Claude is doing, what Anthropic is doing with enterprise managed authorizations and the MCP spec, what Okta is doing with Cross App Access, that's using the same spec, the same protocol called ID-JAG. Let me break down what that is. So ID-JAG, Identity Assertion JWT Authorization Grant. This is a spec in the IETF. Um, effectively, what an ID-JAG is, is an assertion of a user's identity. It's signed by an

[7:50](https://www.youtube.com/watch?v=uTrY8slys0w&t=470s) issuer. So in this flow, the agent provider is the issuer, and it's sent for a specific audience. So again, in this flow, the specific audience is my application. And let's break down what's in this. Um, in the header, it tells you that this is of type ID-JAG, the algorithm used for signing and the signing key. In the payload, this is where things get interesting. It tells you who issued it, which in this case is the agent provider. It gives you

[8:20](https://www.youtube.com/watch?v=uTrY8slys0w&t=500s) information from the agent provider on the user, so the user's name, their email, whether the email was verified.

[8:30](https://www.youtube.com/watch?v=uTrY8slys0w&t=510s) And then it tells you who it's for. So the audience is my application Waypoint, and the client ID is a client that's known to Waypoint. And then finally, it tells you how long it's valid. And most importantly, it's signed by the issuer, the agent provider's public key. So Waypoint, their authorization server, gets this ID-JAG. They are going to verify, um, the signature, and it's up to Waypoint what they wanna trust in this. It's completely up to Waypoint if they want to create an account for

[9:00](https://www.youtube.com/watch?v=uTrY8slys0w&t=540s) this user, what sort of access they wanna-- what sort of scopes they wanna give in the access token that they hand back to the agent on behalf of this user.

[9:09](https://www.youtube.com/watch?v=uTrY8slys0w&t=549s) So let's see what that actually looks like in action.

[9:14](https://www.youtube.com/watch?v=uTrY8slys0w&t=554s) To give you a demo, um, so I am in an agent harness that I built here. This agent harness is able to issue ID-JAGs. I am logged into this agent harness as Sam Rivera. I have an email, and this is a fresh user. It-- Waypoint doesn't know anything about this user. It's never seen this user before. And I am going to say to my agent harness, um, let's see here. Plan. I need to put down my mic.

[9:54](https://www.youtube.com/watch?v=uTrY8slys0w&t=594s) Okay, so I'm telling my agent harness, "I want you to plan my itinerary for AIE New York City, and I wanna be able to share it with my coworkers, and I want you to find a tool that's going to do the planning and make it easy to share, all that good stuff." So my agent harness is going and looking at tools. It's finding some other travel itinerary planning tools like Maple Itinerary, um, and it can't get through to there because it needs a browser sign up. TripLedger needs an API key, but Waypoint allows for agents to sign up.

[10:24](https://www.youtube.com/watch?v=uTrY8slys0w&t=624s) And so it asks me for consent. "Can I share your name and verified email with Waypoint?" I'm gonna say yes. And then Waypoint in Waypoint's auth.md file also asks for some other consent for some more elevated permissions. In this example, it's allowing Waypoint to book dinner reservations with the agent.

[10:43](https://www.youtube.com/watch?v=uTrY8slys0w&t=643s) So I give it my consent, and my agent harness is going to talk to Waypoint about this. Let's see what it does.

[10:56](https://www.youtube.com/watch?v=uTrY8slys0w&t=656s) Okay, it's verified my identity. It created my Waypoint account. I didn't have to do anything. Totally hands-off on my point.

[11:08](https://www.youtube.com/watch?v=uTrY8slys0w&t=668s) Oh, it booked a trip, dinner reservation, and my itinerary is ready to share. Okay, look at that. Um, there's my itinerary. It booked me dinner at Quality Bistro, which is quite good. If anyone has been there before, I would, I would recommend it. Um, it's given me a link that I can share with my colleagues. And all that was done without any interaction on my point. So that was pretty cool. Um, what I'll-- final thing I'll say on the ID-JAG part is that, um, what I feel really confident in,

[11:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=698s) in, um, kind of this era of agents accessing other things is that for us to be able to do this safely and securely and in a trusted manner, it's gonna all need to be built on open standards. Um, we are all going to need open standards for agents to talk to services, to do things, to pay, to sign up for accounts. Um, so I'm really excited about a lot of the standardi-standardization work that's being-- happening right now, a lot of the things that were announced, like just over the past week. All right. Moving on to the last part of this presentation,

[12:08](https://www.youtube.com/watch?v=uTrY8slys0w&t=728s) how can I limit and revoke what an agent can do? So for me, this is really important in Waypoint because I allow for corporate travel booking, and I want to let corporate employees responsible for travel booking, um, use agents. I want to build agents for them. But with this, there's real corporate money on the line. I need to be able to audit. I need to be able to make sure that money is not thrown around in ways that it shouldn't be. So introducing a persona

[12:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=758s) here, Jordan. Jordan's responsible for company funds at Jordan's company. Um, Jordan's the only one that can approve budget and approval rules. Now, I've built a couple of agents into Waypoint for Jordan to use. The first one's read-only. It's your classic chatbot that Jordan can ask, "Hey, what's wrong with the budget?" Or whatever. Um, and it'll tell it, but it can't actually do anything. But then I built Jordan a fund agent. This fund agent is gonna actually be able to move funds around between users. Let's say that one

[13:08](https://www.youtube.com/watch?v=uTrY8slys0w&t=788s) user is flying from San Francisco, and flights are really expensive compared to the user coming in via train from Boston. And so Jordan wants to be able to move funds around, but as long as it's happening within the budget and the approved rules, Jordan doesn't need to manually do it himself. He can use the agent. But it's really important to Jordan that the funding agent can't go rogue. It can't change the budget. It can't change the approval rules to make things work. So how do I make this happen within my application? So Jordan invokes an

[13:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=818s) agent, and on the back end of my app, my app issues agent tokens. So it's really important to me that I don't just hand an agent Jordan's user token. There's a few reasons for this. One is auditing and attribution. Two is revocation. I want Jordan to be able to revoke the agent. I wanna be able-- I want my application to be able to revoke the agent without impacting Jordan's session and Jordan's access. And then finally, I wanna be able to limit what

[14:08](https://www.youtube.com/watch?v=uTrY8slys0w&t=848s) the agent can do. I wanna limit the scopes in the token. So the way that I've set these agents up is I've created a blueprint, like a ceiling of access for the read-only agent and for the fund agent. And when Jordan invokes them, um, the agent token that's issued for the agent, the scopes in it, is the intersection of Jordan's user permissions and the scopes in the ceiling of the agent blueprint. And so then finally, the agent can call my API with a scoped access. Uh, sorry, a scoped agent token.

[14:38](https://www.youtube.com/watch?v=uTrY8slys0w&t=878s) So I'll just briefly show you what that is, and then I'll end with some QR codes here so you guys can check out, um, all of the stuff. So I am in Waypoint as Jordan. I am looking at my team travel here. I have a team budget. There's looks like seventy dollars available. Start up my read-only agent.

[14:58](https://www.youtube.com/watch?v=uTrY8slys0w&t=898s) All right, so my read-only agent is started. If I take a look here at the session details, what we were talking about earlier with Jordan's user token, it's here on the left. I can see Jordan has a bunch of permissions. The agent blueprint for the read-only agent's in the middle. It only has one permission. Um, it has some sess-session information, and then the agent token, it's issued by my application. The subject of the, um, agent token is the agent ID, so it's attributable

[15:28](https://www.youtube.com/watch?v=uTrY8slys0w&t=928s) to the actual agent. It's acting on behalf of Jordan, the user. So I have that information in there as well. And the permissions are the intersection between Jordan's user token and the agent blueprint. Um, so, um, in the interest of time, I'm gonna skip the read-only agent and just move over to the fund agent 'cause it's a little more interesting. So starting up this fund agent, I'm gonna ask it to fix Alex's budget.

[16:09](https://www.youtube.com/watch?v=uTrY8slys0w&t=969s) Okay, so Alex has a two hundred and fifty dollar shortfall. Um, do you want me to rebalance funds? Yes. Rebalance. It's hard to do while holding a mic.

[16:26](https://www.youtube.com/watch?v=uTrY8slys0w&t=986s) All righty, so the funding agent was able to move seventy dollars over to Alex, but they can't fix all of it because there's no more budget available left, and the funding agent doesn't have the ability to change the budget. But I, as Jordan, do. So my user is still able, with their user token, to change the budget. Let's change it to two thousand.

[16:53](https://www.youtube.com/watch?v=uTrY8slys0w&t=1013s) So as the user, I was able to do that. The agent couldn't. Um, and then so I'm gonna tell it, "I increased the, oop,

[17:04](https://www.youtube.com/watch?v=uTrY8slys0w&t=1024s) budget."

[17:16](https://www.youtube.com/watch?v=uTrY8slys0w&t=1036s) Okay, there we go. And so the agent was able to fix Alex's budget. So really what we showed here is that how you can build agents into your application, um, putting a ceiling on their permissions, and they operate using an agent token with that scoped access instead of taking your user's token or an API key. So you can audit it. It's, um, yeah, you can audit it, you can revoke it, and you can make sure that you limit the permissions of that agent.

[17:44](https://www.youtube.com/watch?v=uTrY8slys0w&t=1064s) All righty. Coming back in here, I just showed that demo. Um, so three takeaways here. Um, how you can let agents into your application with an auth.md file. How you can connect them to a customer using the user claim flow in auth.md or the ID-JAG identity assertion. And then finally, how you can limit actions by enforcing permissions and revocation. I'll end with some QR codes. Um, the one on the left for auth.md, like I said, it's an open standard. Um, and the one on the right is WorkOS Agent Auth, which is how I was

[18:13](https://www.youtube.com/watch?v=uTrY8slys0w&t=1093s) able to, um, build agents into my application with limited permissions using an agent token. And I will end my talk there. Thank you all so much. And if anyone has any questions, I'm happy to talk about it after.
