Skip to content

Iris explained

Iris is the differentiator. Every other IAM platform was designed before generative AI existed and bolted chat onto an existing UI. AtmanID was designed around the question “what does Identity & Access Management look like when an AI assistant is the primary interface?”

This page explains what that means in practice, why naive “chatbot on top of an admin UI” approaches fall short, and how Iris stays accurate as the product surface grows.

What Iris is and isn’t

Iris IS:

  • The natural-language interface to your tenant’s IAM data — counts, breakdowns, lookups, multi-table questions, and actions you confirm
  • A chooser, not a query writer: it picks a pre-built, tested tool for your question
  • A structured fallback (iris_sql) for cross-table questions the catalog doesn’t cover — it never runs SQL the model wrote
  • Bounded by your permissions and your tenant, with an audit row for every question and every action
  • Self-checking: when an answer has the wrong shape for the question, it corrects itself before replying

Iris is NOT:

  • A general-purpose chatbot — it answers IAM questions about YOUR tenant’s data, not “what is access governance”
  • A replacement for the admin UI — the UI exists for visual workflows where chat doesn’t fit (e.g., dragging a workflow stage diagram)
  • A search box that returns docs — though “how do I…” questions are answered from this documentation, with citations to the pages used, while questions about your data go to the data tools
  • An always-correct oracle — Iris uses a language model (see Building on Iris for which) and can be wrong. The design limits how far a mistake can reach rather than promising there are none.

Why chatbot-on-top-of-admin-UI doesn’t work

If you’ve ever used a SaaS product that retrofitted a chatbot, you’ve probably noticed the same failure modes:

  • The chatbot only knows about a small subset of features (the ones the chatbot team built integrations for); the actual product has 10× more functionality
  • Asking anything specific routes you to a help-center article, not an answer
  • Mutations require leaving the chat and going to the UI anyway
  • The chatbot can’t see your data, so questions like “how many users are inactive” return generic guidance, not numbers

The root cause: those chatbots were built as add-ons to a product designed for visual UI navigation. The data model wasn’t structured for tool-calling. The auth surface wasn’t structured for chat-mediated mutations. The audit trail wasn’t structured for tracking chat-initiated actions.

AtmanID inverts this. The data model, the tool catalog, the auth surface, and the audit trail were all designed assuming Iris would be the primary mutation surface. When Iris invokes a tool, the tool returns structured data ready for synthesis. When Iris proposes a mutation, the HITL confirmation flows through the same audit-emitting code path as a UI-initiated mutation. Iris isn’t a layer on top; Iris is one of two equally-first-class interfaces (chat + UI) that share the same backend.

How Iris picks a tool

Before the model sees your question, Iris narrows the catalogue to the tools that fit: by the wording of the question, by the page you’re on, and — when neither points anywhere — by meaning. The model then chooses among those few, and only among tools your role is allowed to use. Fewer, better-matched choices mean fewer ways to go wrong; it is also why asking “show me the high-priority ones” on the Pending Approvals page returns approvals.

The tool catalog

Iris’s job is to choose a tool, not to write one. Each tool is built and tested in advance — “count active users”, “list pending access requests”, “group audit events by action over a period” — and runs a known query against your tenant. Breakdowns combine a metric with a dimension that makes sense for it (active users by department, access requests by status); a combination that doesn’t make sense is refused rather than guessed. The catalogue grows as customers ask questions it can’t answer yet. The full list is in the tool catalog.

When no tool fits, Iris falls back to iris_sql, a read-only tool over curated views. It does not accept SQL: Iris describes the question in a fixed structure, and the server checks every name against the view and builds the query itself.

Checking its own answers

Language models sometimes choose a similar-but-wrong tool — answering “top 5 users by entitlements” with a plain listing instead of a ranking. Iris checks whether a result has the shape the question asked for, and when it doesn’t, it makes one corrected call with the right kind of tool before answering. This is a structural check on the answer, not a better-worded prompt.

Mutations — HITL confirmation as the default

Iris CAN mutate state — submit access requests, approve workflows, certify reviews, revoke access, configure policies, register agents, etc. Every mutation routes through a confirmation gate by default:

  1. User asks Iris to do something mutation-shaped: “approve REQ-1234”
  2. Iris prepares the action (e.g., approving the request) with its parameters
  3. The platform doesn’t execute immediately — instead it returns a “proposed action” card to the user
  4. User reviews the proposed action: who/what/why, signs off explicitly
  5. Platform executes the mutation, audit-logs the user as the actor (NOT the agent), returns confirmation

The exception: standing authorization. For specific tool/user combinations, the user can pre-authorize Iris to auto-execute (e.g., “always let Iris cancel my own draft requests without confirmation”). This is per-tool, per-user, time-bounded, and audit-logged on every grant + revoke.

The principle: humans are accountable for mutations. Iris is the tool that lets humans act faster; it’s never the actor of record.

What Iris can and can’t see — the security model

  • Every tool runs in the tenant taken from the signed-in session — never from anything the model or the browser supplies — and the database itself enforces the tenant.
  • Iris can do only what the person asking can do: the tools it is offered, and the rows those tools return, follow that person’s role.
  • iris_sql never runs SQL the model wrote, so there is no raw query to smuggle across tenants; results are checked for rows from any other tenant before they are shown, and an attempt is recorded for security review.
  • These guarantees are tested on every change by a library of cross-tenant attack patterns. How tenants stay apart in general is in Multi-tenancy isolation.

Where to go next

  • For the actual Iris reference (tool catalog, query patterns, security model): Iris section
  • For the architectural foundation: Architecture overview
  • For “how do I use Iris for X” recipes: Guides (specifically the Iris query pattern guides)
  • For the API surface that lets you build on Iris: Reference

© AtmanID · Privacy