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

Isabelle Williams, WorkOS | AI Engineer NYC 2026 | 18:33

Source: https://www.youtube.com/watch?v=uTrY8slys0w
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/how-to-let-ai-agents-sign-up-for-your-app-safely
Published: 2026-10-23
Tags: agents, security

## TL;DR
- Apps can publish an auth.md file that tells agents how to create accounts and access APIs.
- ID-JAG identity assertions let an agent provider vouch for a user, so the app can create or link an account without a manual signup flow.
- In-app agents should receive scoped agent tokens whose permissions are the intersection of the user's permissions and the agent's defined permission ceiling.

## Summary
Isabelle Williams uses Waypoint, a travel app she built, to explain how applications can support agents as users. She starts with auth.md, an open file that describes how an agent can access an app. Waypoint allows an agent to try limited actions anonymously, then lets a person claim that work, or it can use an ID-JAG identity assertion from the agent provider to create or link the user's account without a form. In the demo, an agent signs up as a new user, plans a New York trip, books dinner, and prepares a shareable itinerary. Williams then addresses agents that operate inside an application. Instead of giving an agent the user's token, the app issues a separate token tied to the agent, with permissions limited by an agent blueprint. This supports auditing, revocation, and permission checks without changing the user's access.

## Key ideas
### Agents need a path into an app that does not assume a person will browse the signup flow
[00:57](https://www.youtube.com/watch?v=uTrY8slys0w&t=57s)
Williams says personal agents will take over product discovery, research, and the first steps toward using an app. Waypoint therefore needs to let an agent find the product and reach its useful features. She also needs to connect that agent to a real customer, especially when the agent will act on behalf of someone. For company travel, the app must control financial and compliance risks. That means the design has to answer three questions: how agents get in, how their work becomes associated with a user, and how their actions can later be limited or revoked.

### An auth.md file gives agents a documented front door to the application
[02:09](https://www.youtube.com/watch?v=uTrY8slys0w&t=129s)
Waypoint hosts an auth.md file for agents. Williams describes it as an open protocol in Markdown that explains how an agent can register for an account, get access, and call a user API. The file describes the available access and operations, while the application remains responsible for enforcing authorization. In Waypoint's version, the file supports anonymous access so an agent can try limited actions before signup. It also supports stronger access after the agent is connected to a real user. The point is to give agents a predictable way to discover how the application works.

### Anonymous work can be claimed by a person and moved under their account
[03:12](https://www.youtube.com/watch?v=uTrY8slys0w&t=192s)
The first auth.md flow lets an agent act anonymously through the API. The agent receives an access token for those actions and a claim token. When the user wants to take ownership, the agent gives the user a link and a one-time code. The user signs up or signs in to Waypoint and enters the code. Waypoint then moves the agent's work under that user's account. OAuth lets the authorization server issue an access token for the agent to continue calling the API on the user's behalf. Williams points out that this introduces several manual steps, including signup and email verification.

### ID-JAG lets the agent provider assert a user's identity to the application
[04:57](https://www.youtube.com/watch?v=uTrY8slys0w&t=297s)
Williams presents ID-JAG as an alternative to a manual signup flow. The agent first asks the user for consent to share their identity and email with Waypoint. It then asks the agent provider for an ID-JAG and sends that assertion to Waypoint's authorization server. Waypoint verifies it and decides whether to create a new account, link an existing account, and choose the scopes in the access token. The application retains control over those decisions. In this model, the agent provider supplies identity information, but Waypoint decides what that identity is allowed to do.

### An ID-JAG is a signed, audience-specific identity assertion
[07:22](https://www.youtube.com/watch?v=uTrY8slys0w&t=442s)
Williams expands the name as Identity Assertion Joined Authorization Grant and describes it as an IETF specification. The assertion is issued and signed by the agent provider for a specific audience, such as Waypoint. Its header identifies the type, signing algorithm, and signing key. Its payload contains the issuer, the user's name and email, whether the email was verified, the intended audience, a client ID known to Waypoint, and an expiration time. Waypoint verifies the signature using the provider's public key. After verification, Waypoint decides what to trust and what permissions to grant.

### The demo shows an agent creating an account and completing a trip without user interaction
[09:09](https://www.youtube.com/watch?v=uTrY8slys0w&t=549s)
Williams logs into her agent harness as Sam Rivera, using a fresh identity that Waypoint has never seen. She asks the agent to plan a New York City itinerary that can be shared with co-workers. The harness checks travel tools and finds that some require browser signup or an API key, while Waypoint allows agents to register. After Williams consents to share Sam's name and verified email, and to allow dinner bookings, Waypoint verifies the identity and creates the account. The agent books a trip and dinner at Quality Bistro, then produces an itinerary link for colleagues.

### In-app agents should receive their own token instead of the user's token
[12:12](https://www.youtube.com/watch?v=uTrY8slys0w&t=732s)
For corporate travel, Williams introduces Jordan, who manages company funds and approval rules. Waypoint has a read-only agent and a funding agent that can move money within approved limits. Williams says the app should not give either agent Jordan's user token. A separate agent token provides attribution for auditing, allows the application to revoke the agent without ending Jordan's session, and limits the agent's scopes. Each agent has a permission ceiling defined in a blueprint. When Jordan invokes one, the issued token contains the intersection of Jordan's permissions and that blueprint's permissions.

### Scoped agent tokens prevent an agent from changing the rules that constrain it
[14:48](https://www.youtube.com/watch?v=uTrY8slys0w&t=888s)
In the funding demo, the agent can move $70 to cover part of Alex's budget shortfall, but it cannot change the budget because that permission is outside its blueprint. Jordan, using the user token, raises the budget to $2,000. The funding agent can then complete the rebalance. The separation matters because the agent can perform its assigned financial action while remaining unable to alter the budget or approval rules. The token identifies the agent as its subject and records that it is acting on behalf of Jordan. Williams presents this as the basis for auditing, revocation, and limited access.

## Notable quotes
- "The first thing that I've been thinking about is how do I let agents into my app?" (00:57)
- "Off.md is a markdown file that you host with your application." (02:28)
- "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?" (05:19)
- "I don't just hand an agent Jordan's user token." (13:29)
- "The scopes in it is the intersection of Jordan's user permissions and the scopes in the ceiling of the agent blueprint." (14:11)

## Tools & references mentioned
- WorkOS
- OpenAI
- Propel
- Cursor
- Waypoint
- Claude Code
- Muse
- Claude
- Anthropic
- Okta
- ID-JAG
- IETF
- OAuth
- MCP
- auth.md
- WorkOS agent auth
- Maple itinerary
- TripIt
- Waygo
- Quality Bistro

## Who should watch
- You are building an application that agents may discover, sign up for, or use on a person's behalf, and you need a defined access path for them.
- Your product has a signup flow that an agent could complete more easily if its provider could assert the user's verified identity.
- You are adding agents to an application with financial, administrative, or other sensitive actions and need separate permissions, auditing, and revocation.

## Related talks

- [Auth for Agents: Let AI Sign Up for Your Product with auth.md](https://aietalks.com/talks/auth-for-agents-let-ai-sign-up-for-your-product-with-auth-md) (Michael Grinich, WorkOS, 21:13)
- [Identity for AI Agents](https://aietalks.com/talks/identity-for-ai-agents) (Patrick Riley & Carlos Galan, Auth0, 1:22:12)
- [Securing Agents with Open Standards](https://aietalks.com/talks/securing-agents-with-open-standards) (Bobby Tiernay & Kam Sween, Auth0, 18:41)
- [Real AI Agent Attacks and What Would Have Stopped Them](https://aietalks.com/talks/real-ai-agent-attacks-and-what-would-have-stopped-them) (Andrey Rybka, Bloomberg, 15:44)
- [Your Agent Just Authorized What?!](https://aietalks.com/talks/your-agent-just-authorized-what) (Jay Mok & Ben Coumes, PayPal, 16:07)
