All Things Open 2026 · ML/AI · Room 301A

Who
Authorized
That?

Fine-Grained Authorization for AI Agents

Michael Liendo headshot

Michael Liendo (Focus Otter)

Staff Developer Advocate, Auth0

Today

Fine-Grained
Authorization

OpenFGAOpen sourceCreated by Auth0CNCF project
Origin
Google · 2019 paperZanzibarGoogle’s global authorization system
→
Auth0 · open sourceOpenFGAZanzibar-inspired, now in the CNCF
Refresher

RBAC: role-based access

admineditorviewer

Great when roles are stable and singular.

Where it breaks

Same user. Same app.

Adminhere 📁
Read-onlythere 📁

Think Google Drive, YouTube, Vimeo.

Before FGA

Hand-rolled ReBAC

async function canViewDocument(user: string, id: string) {
  const doc = await db.documents.find(id);
  if (doc.ownerId === user) {
    if (!doc.blocked.includes(user)) return true;
  }
  if (doc.sharedWith.includes(user)) return true;
  const teams = await db.teams.forUser(user);
  for (const t of teams) {
    if (doc.teamIds.includes(t.id)) return true;
  }
  const org = await db.orgs.forUser(user);
  let folder = await db.folders.find(doc.folderId);
  while (folder) {
    if (folder.ownerId === user) return true;
    if (folder.orgId === org?.id) return true;
    folder = await db.folders.find(folder.parentId);
  }
  return false; // blocked? only checked for owners
}
  1. Nested ifs: owner, share list
  2. DB lookups every request
  3. Recursive folder walk
  4. blocked checked in one branch
const { allowed } =
  await fga.check({
    user,
    relation: 'can_view',
    object: `document:${id}`,
  });

Orgs, teams, folders and blocked live in the model, not in your code.

“There has to be
a better way.”

ReBAC

Relationships, not roles.

Core concepts
Typesuser, document
The kinds of things in your app.
Relationsowner, viewer
How a user can relate to an object.
Tuplesfacts:
user · relation · object
Stored data you write.
Checksquestions:
can X do Y to Z?
Answer: allowed true / false.
Put it all together
// model.fga: types + relations
type user
type document
  relations
    define owner: [user]
    define viewer: [user] or owner

// tuple: a fact
user:ana  owner  document:roadmap

// check: a question
can user:ana viewer document:roadmap?
→ allowed: true  (owners are viewers)
  1. Types the nouns
  2. Relations the rules
  3. Tuple the fact
  4. Check the answer
Wiring it up
// 1. Write a fact (a tuple)
await fga.write({ writes: [
  { user: 'user:1', relation: 'owner', object: 'document:x' }
]});

// 2. Ask a question (a check)
const { allowed } = await fga.check({
  user: 'user:1', relation: 'viewer', object: 'document:x'
});  // → true (owners are viewers)
Demo 1

Monster
Vault

  1. Upload a selfie → it becomes a monster
  2. Ask the agent: “How many vampires?”
  3. Then: “How many werewolves?”

The agent only sees what you can see.

QR code for monster-vault-fga.vercel.app monster-vault-fga.vercel.app
Snags

Modeling is the hard part.

Like database modeling. The API calls are the easy bit.

  1. Org + team membership
  2. Folders inherit from parents
  3. Docs: owner → editor → viewer
  4. …but not blocked
model
  schema 1.1
type user
type org
  relations
    define member: [user]
type team
  relations
    define member: [user]
type folder
  relations
    define parent: [folder]
    define owner: [user, team#member]
    define editor: [user, team#member] or owner or editor from parent
    define viewer: [user, org#member] or editor or viewer from parent
type document
  relations
    define parent: [folder]
    define owner: [user]
    define blocked: [user]
    define editor: [user, team#member] or owner or editor from parent
    define viewer: [user, org#member] or editor or viewer from parent
    define can_view: viewer but not blocked

ReBAC scales
where RBAC fails.

Best fit: documents, folders, shared things.

Now: agents

Agents act
on behalf of
users.

Without a check, they can over-fetch: read more than the user ever could.
Monster Vault Agent: chat on the left, FGA decisions panel on the right
Monster Vault Agent · every image is checked with can_view before the model sees it
Pattern 1

Filter before the agent sees it

// Check every retrieved image, in one call
const { result } = await fga.batchCheck({
  checks: images.map(img => ({
    user: 'user:focus', relation: 'can_view',
    object: `image:${img.id}`
  }))
});
const ok = new Set(result.filter(r => r.allowed)
  .map(r => r.request.object));
// Only these images ever reach the agent
const visible = images.filter(img => ok.has(`image:${img.id}`));
Pattern 2

Gate every tool call

// Before the tool runs
const { allowed } = await fga.check({
  user: 'user:focus', relation: 'can_view',
  object: 'image:bo-werewolf'
});
if (!allowed) return 'Not authorized.';

Or model the agent as its own type: agent:assistant, acting for a user.
Tokens & tool access: Auth0 for AI Agents · auth0.com/ai

Try it · play.fga.dev · Monster Vault model
model
  schema 1.1
type user
type creature
  relations
    define viewer: [user]
type image
  relations
    define owner: [user]
    define kind: [creature]
    define can_view: owner or viewer from kind

As user:focus, seeded with
user:focus viewer creature:vampire

  1. can_view image:ana-vampire✓
  2. can_view image:bo-werewolf✗
  3. write viewer creature:werewolf
    → re-check bo-werewolf
    ✓
Demo 2

Let’s play tag.

Every tag is an
authorization check.

  • Up to 30 players
  • Guest join · no login
  • Winner gets a Lego set 🏆
QR code for phaser-colyseus-tag-stage.vercel.app phaser-colyseus-tag-stage.vercel.app
The game’s real model
model
  schema 1.1
type user
type room
  relations
    define host: [user]
    define it: [user]
    define tagging_on: [user:*]
    define no_tagbacks: [user:*]
    define tagger: it and tagging_on
    define can_change_rules: host
type player
  relations
    define owner: [user]
    define room: [room]
    define last_tagged: [user]
    define shielded: [user:*]
    define tagback_blocked: last_tagged and no_tagbacks from room
    define can_tag: tagger from room but not (shielded or tagback_blocked)
One check

Can Ana tag Bo?

await fga.check({ user: 'user:ana',
  relation: 'can_tag', object: 'player:bo' })

Ana is it · tagging on · Bo not shielded → allowed

Write user:* shielded player:bo → denied

Rules change live = writing tuples. No redeploy.
Takeaways
  1. RBAC for stable roles. ReBAC when access depends on relationships.
  2. Model it. Write tuples. Ask checks.
  3. Agents get only what the user can see: filter before, check every tool call.
Resources

Thank you.

@focusotter

Michael Liendo headshot

Michael Liendo (Focus Otter)

Staff Developer Advocate, Auth0