Who
Authorized
That?
Fine-Grained Authorization for AI Agents
Michael Liendo (Focus Otter)
Staff Developer Advocate, Auth0
Fine-Grained
Authorization
RBAC: role-based access
Great when roles are stable and singular.
Same user. Same app.
Think Google Drive, YouTube, Vimeo.
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 }
- Nested ifs: owner, share list
- DB lookups every request
- Recursive folder walk
- 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.
The kinds of things in your app.
How a user can relate to an object.
user · relation · objectStored data you write.
can X do Y to Z?
Answer: allowed true / false.
// 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)
- Types the nouns
- Relations the rules
- Tuple the fact
- Check the answer
// 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)
Monster
Vault
- Upload a selfie → it becomes a monster
- Ask the agent: “How many vampires?”
- Then: “How many werewolves?”
The agent only sees what you can see.
Modeling is the hard part.
Like database modeling. The API calls are the easy bit.
- Org + team membership
- Folders inherit from parents
- Docs: owner → editor → viewer
- …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.
Agents act
on behalf of
users.
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}`));
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
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 withuser:focus viewer creature:vampire
can_view image:ana-vampire✓can_view image:bo-werewolf✗write viewer creature:werewolf✓
→ re-check bo-werewolf
Let’s play tag.
Every tag is an
authorization check.
- Up to 30 players
- Guest join · no login
- Winner gets a Lego set 🏆
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)
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
- RBAC for stable roles. ReBAC when access depends on relationships.
- Model it. Write tuples. Ask checks.
- Agents get only what the user can see: filter before, check every tool call.
- OpenFGA Playgroundplay.fga.dev
- OpenFGA docsopenfga.dev/docs
- Auth0 FGA (hosted)docs.fga.dev
- Auth0 for AI Agentsauth0.com/ai
Thank you.
@focusotter
Michael Liendo (Focus Otter)
Staff Developer Advocate, Auth0