AI Engineer World's Fair 2026

Full Workshop: Agent Auth Protocol — Paola Estefanía de Campos, Better Auth

Loading slides…

Read the talk

Full Workshop: Agent Auth Protocol

A Gmail workflow makes agent authentication concrete: discover capabilities, approve access, attribute actions, and revoke an identity without confusing it with the host that created it.

From a talk by Paola Estefanía de Campos

Before you start: Familiarity with API tokens, OAuth permissions, and MCP tool connections will help you follow the authorization flows.

Hire your agent

Ask an agent to check tomorrow’s calendar or read your Gmail, and a security question appears before the first useful result: whose identity does the service see? Connecting an MCP server or putting a personal token in .env can give an agent access under your credentials. In Paola Estefanía de Campos’s opening audience poll, many people use agents daily, but fewer connect them to personal accounts. The concern is concrete: an agent acting with your identity can do something you never intended.

The workshop introduces Agent Auth Protocol through a hiring analogy. Enthusiasm for AI, like enthusiasm for the early internet, can precede serious attention to security. But a company already has a familiar pattern for giving someone access: a new employee receives their own email address and credentials. You do not hand them the CEO’s login so they can read company email. An agent likewise needs its own authority to work for you.

Slide titled “Hire your agent.” with the subtitle “Agents should work for you without pretending to be you” and a QR code.Open full source frame
Agents should work for you without pretending to be you.
1:091:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:09 · section reference included

From available tools to accountable actions

Start with the request to read your emails. How does the agent know how to do that? Audience answers point to tool descriptions and the context window: somewhere, someone has connected a service and supplied information about its actions. A directory could make that discovery more automatic. De Campos compares it to a phone book: it tells the agent what it can call and how to call it. This is discovery, the first problem.

The next problem is authorization. Restricting Gmail access to reading prevents sending or deleting, but it still exposes potentially sensitive information. The proposed boundary is more specific: enumerate the available tools, then decide which actions this agent may perform. A newly hired assistant should not inherit everything the person who hired them can do.

Finally, useful audit logs need more than a user account and a successful request. They need to answer which agent did what, when, and on behalf of which user. That requires agent identity. Once an agent is identifiable, it can also be individually revoked—fired, in the hiring analogy—rather than forcing the user to disconnect an entire integration. Discovery identifies available actions; authorization bounds them; identity makes their execution attributable and their access revocable.

Black slide titled “Right now, we’re faking all three.” with text discussing capabilities, authorization, identity, and shared employee access.Open full source frame
Capabilities, authorization, and identity are three questions agents must answer.
4:214:40
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:21 · section reference included

Turn intent into capabilities

A broad read scope says relatively little about the action an agent is about to take. The workshop uses capabilities to describe more narrowly defined actions. A request for emails from the last week expresses an intent; satisfying it may require one tool or several. Discovery must map that intent onto the capabilities a service actually exposes.

For native discovery, the proposed specification introduces a public, well-known agent configuration endpoint. The analogy is OpenID Connect discovery: a client knows where to look for information about interacting with a service. Here, that public information would describe interaction requirements, supported cryptographic information, and where to find capabilities.

Existing services still need a bridge. In the workshop, OAuth services are the immediate integration target, and an OpenAPI document supplies a machine-readable description of their endpoints. The live attempt to locate an OpenAI openapi.json does not succeed, so de Campos switches to Notion. Even then, she shows example output rather than completing a fresh import on screen: endpoints such as GET and DELETE become separate capabilities. This is an interim adapter for services that have not adopted Agent Auth natively.

The same translation populates the directory. De Campos points to a Gmail directory entry with 20 capabilities. Entries can come from an OpenAPI description or be declared manually, including for a custom workflow. The directory is therefore a catalog of callable actions, not just a list of service names.

An audience comparison with fine-grained authorization sharpens the design: narrow permissions are only part of the proposal. The token principal becomes the agent. The intended distinction is between merely narrowing a user’s delegated access and identifying the particular agent exercising it. Separating GET, DELETE, and POST actions gives the user specific authorization choices; when an API description is insufficient, de Campos offers manual capability declarations as the bridge until native support exists.

9:219:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:21 · section reference included

Identify the agent, its user, and its host

The identity mechanism begins with a private key assigned to each agent. The agent can sign tokens with that key, allowing its activity to be distinguished from the associated user’s activity. Signing is distinct from encryption: a signed token establishes authenticity and integrity, but does not by itself conceal its payload, as the JWT standard makes clear. The resulting audit trail can identify an agent operating from Cursor or Claude, rather than showing only the human account behind the request.

An audience member asks about an agent deleting an entire database. De Campos’s response is to revoke that agent, then address any remaining access token. She suggests invalidation using its jti, or JWT ID. That identifier can name a token for server-side rejection; it does not itself delete or invalidate the token. The workshop does not demonstrate the particular invalidation mechanism.

Revocation also needs a responsible party and a wider administrative boundary. In the workshop’s delegated model, an agent remains associated with a user. The currently published working draft also permits autonomous agents, so that user association should not be read as a universal requirement of every Agent Auth configuration. De Campos then introduces the host: the environment from which agents are created. An audit record can expose the host, agent ID, and user, and authorization can be withdrawn from a host as well as from one agent.

Slide titled “Who is it?” with Host, Agent, and User boxes above contrasting audit-log examples.Open full source frame
Separate the host, agent identity, and delegated owner.
17:2317:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:23 · section reference included

Connect the three implementation layers

The comparison with AWS IAM brings longer-lived organizational identities into the discussion. De Campos dates the initial work to February, then describes requirements that had become more prominent: persistent agents, multiple agents, and company policies. A forthcoming V2 draft is intended to address those needs. She invites open-source contributions while emphasizing that the intended audience extends beyond enterprises.

The experimental Agent Auth implementation divides responsibilities across three layers:

LayerResponsibility
Better Auth server pluginVerify agents, issue grants, enforce constraints
SDK with MCP connectivityConnect agent clients such as Claude or Cursor
DirectoryMatch intent to service capabilities

The server is where authorization decisions become enforceable; the directory helps the agent find the actions for which it needs authorization.

To follow the workshop’s Gmail exercise:

  1. Open the protocol website and enter the Directory.
  2. Log in, choose Connect, and obtain the MCP connection information.
  3. Add Agent Auth in Claude’s connector configuration.
  4. Review the connector’s tool approval and denial settings.
  5. Use only the Agent Auth MCP for the exercise, so other connected tools do not provide an alternative route to the same service.

De Campos uses demo emails to avoid exposing personal information. The sequence to watch is identity creation, a capability request, execution, and the resulting logs.

20:4120:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

20:41 · section reference included

Approve a read, then inspect its identity

The first request is simple: bring back the last email. Claude uses the directory to find matching capabilities and asks for approval. De Campos describes the approval as a device authorization flow: the agent is treated like another device the user is connecting. The agent appears with the default, changeable name Email Reader, requesting permission to read and list emails. She approves it.

Agent management page showing an Agents tab, status filters, and rows including Email Reader.Open full source frame
The demo opens an agent management list.

The email is retrieved. The useful result for this workshop is what becomes visible afterward: an active Email Reader agent, its agent ID, its local-device association, the corresponding user ID, and the results of its activity. Email retrieval demonstrates the tool; the management view demonstrates that the tool’s caller is an identifiable agent.

24:3924:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

24:39 · section reference included

Sending requires another grant

The next request crosses a permission boundary. The demonstration’s host policy supplies reading capabilities by default, and the current agent has read and list access. De Campos asks it to send an email to herself saying hello world. That request should require an additional grant: the ability to read the inbox does not include the ability to send from it.

A browser extension makes the authorization request visible. This time, de Campos identifies the flow as Client-Initiated Backchannel Authentication, or CIBA. It supports asynchronous approval rather than requiring the same device-style redirect interaction shown earlier. She approves the request, the agent gains the send capability, and the demonstration shows the email being sent and then the resulting email itself.

26:4627:01
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

26:46 · section reference included

Revoking one identity does not revoke its host

Now suppose something goes wrong with the agent. De Campos revokes it in the management interface and asks it to read the last email it just sent. The connection reports that it was revoked—but the read still succeeds. Her explanation is that the system created another agent with a new identity, and the host’s default get/list permissions let that replacement read the email.

Revoking an agent and preventing replacement agents are different policy decisions. In this demonstration, the host remains authorized to create an identity with reading permissions. De Campos treats that reading access as safe under the demo policy; it is not a claim that every inbox can safely be exposed. When she asks the replacement to send another email to herself, it must request permission again. For the state comparison below, agent-a and agent-b are teaching labels for the original and replacement identities, not IDs displayed in the recording.

One agent is revoked; the host can still create another

Constructed example: agent-a and agent-b are teaching identifiers, not recorded agent IDs. Permission summaries use readable action names rather than asserted protocol field names.

Request after revocation — unchanged
Read that last email you just sent.

Operation: Revoke the original agent, then handle the read request under the unchanged host policy.

Host policy

Before: Before revoking the original agent
New identities receive read/list access by default.
After: After replacement and successful read · Unchanged
New identities receive read/list access by default.

Original identity: agent-a

Before: Before revoking the original agent
Active; read/list access plus approved send permission.
After: After replacement and successful read · Changed
Revoked; its connection reports revocation.

Replacement identity: agent-b

Before: Before revoking the original agent
Not present
After: After replacement and successful read · Added
Active; host-default read/list access. Sending requires a new approval.

Result of the read request

Before: Before revoking the original agent
Not present
After: After replacement and successful read · Added
The read succeeds using the replacement identity.
Agent revocation leaves host policy intact; preventing replacement access requires a broader policy change.
29:0729:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

29:30 · section reference included

Put approval policy at the enforcement boundary

Capabilities can also carry constraints. In response to a question about a vault and limiting how long an agent can run, de Campos says maximum execution time can be specified. The workshop describes that policy option without showing how a runtime limit is enforced.

Where should human approval live: in the agent harness, or in the server that mediates tool access? De Campos says both can participate. User policies and host policies can avoid making someone approve every read while still reserving sensitive operations for explicit consent. Her organizational example is a CEO with broad permissions versus a newly joined employee with limited access. The server verifies the agent’s association with the user, checks policy, and determines whether access is allowed.

A small TypeScript policy function makes that distinction explicit for the email example. Here, read, list, and send are illustrative action labels: a grant check determines whether execution is allowed or another approval is needed.

typescript

type EmailAction = "read" | "list" | "send";
type Decision = "allow" | "request-approval" | "deny";

type Agent = {
  status: "active" | "revoked";
  capabilities: ReadonlySet<EmailAction>;
};

function authorize(agent: Agent, action: EmailAction): Decision {
  if (agent.status === "revoked") return "deny";
  return agent.capabilities.has(action)
    ? "allow"
    : "request-approval";
}

const replacement: Agent = {
  status: "active",
  capabilities: new Set<EmailAction>(["read", "list"]),
};

const readDecision = authorize(replacement, "read"); // allow
const sendDecision = authorize(replacement, "send"); // request-approval

An approval request is not permission to execute. The caller must wait for the authorization outcome before invoking the protected action.

Chat response explaining that send permission is pending approval, with a proposed recipient, subject, and body.Open full source frame
The email-send request remains pending approval.

The replacement agent’s send request has remained pending during the discussion. De Campos returns to it and denies it; the interface shows a red status. She then asks for the agent’s status, illustrating that the same workflow can expose whether an agent is active or revoked. The pending send does not become an approved operation.

31:2531:39
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

31:25 · section reference included

Account for alternate access paths

An audience question exposes a boundary the successful MCP demonstration alone cannot settle: what happens if a skill tells the agent to call an API directly? De Campos says the demo plugin restricts the agent to MCP tools, while stronger restrictions that make Agent Auth the only route to services are work for the next protocol version. This is an integration requirement, not an automatic property of attaching an MCP server. The current Better Auth plugin documentation likewise places grant and constraint enforcement on application handlers for custom routes.

The other interface shown during the demo is available through the logged-in directory. It lets users connect services and inspect their capabilities, agents, and logs, with logs grouped by provider. Although the conversation calls it a proxy, de Campos explicitly describes the demonstrated component as a directory rather than a data-carrying proxy. Its stated job is matching intent to capabilities; she objects to routing service data through a proxy on scalability grounds. Current plugin support for proxy execution handlers does not establish the data path used by this workshop directory.

34:0834:25
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

34:08 · section reference included

Bounded authority, then the adoption questions

The implementation responsibilities come back into focus at the close of the prepared workshop: the SDK/MCP side creates keys and assigns them to agents; the server verifies agents and issues grants authorized by the user. The practical goal is to stop handing agents the user’s credentials and instead say, “Act for me within these limits.” De Campos invites participants to try the plugin and SDK and help develop the project through Discord, messages, or email.

Slide titled “Credentials vs authority.” contrasting “Pretend to be me” with “Act for me, within these limits,” followed by text about discovery, capabilities, and identity.Open full source frame
Give agents authority to act within limits.

The final questions reveal an implementation-maturity wrinkle. An attendee reports that the website describes a Python REST API with SDKs still in development, and de Campos agrees, despite having described an SDK with MCP earlier. She welcomes GitHub contributions. Current SDK availability documentation lists TypeScript packages and a CLI/MCP server, with Python still forthcoming; it does not resolve what each workshop reference meant at the time.

Adoption is intended to be identity-provider agnostic: de Campos says users do not have to adopt the Better Auth stack to use the protocol. An enterprise attendee then asks for IAM-like roles, so organizations can reuse policy groupings instead of defining every claim individually. She identifies that as a primary focus of V2, which remains prospective rather than a demonstrated feature in this workshop.

36:1136:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

36:11 · section reference included

Evaluate the agent’s whole lifecycle

An attendee asks about another protocol on the IETF track. De Campos says the efforts are different, acknowledges inspiration from other work, and identifies agents as principals with their own identities as the distinguishing feature she cares about. Asked whether the team intends to contribute to that IETF effort, she says she does not know. The exchange does not identify the other protocol precisely enough for a technical feature comparison.

The last comparison is with an AI Gateway. De Campos sees overlap in discovery, but says the gateway being discussed does not provide the per-agent identity and lifecycle tracking she wants. Because the exchange does not name a specific gateway implementation or version, the useful evaluation question is broader: can the system identify each agent, attribute its activity, and manage its lifecycle? The workshop ends with an invitation to help develop that model through the displayed email, LinkedIn, and Agent Auth Protocol Discord.

38:5639:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

38:56 · section reference included

Resources

From the talk

  • Defines JWT claims, token identifiers, and the distinction between signed and encrypted tokens.

Updates since the talk

Transcript download
Full transcript

Loading transcript…