Skip to content

Iris

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?” The answer reshapes everything from the data model up.

This section is the operational reference for Iris — what it can do today, the canonical query patterns, how it stays accurate at scale, the security model. If you want the conceptual framing of WHY natural-language IAM is different from “chatbot bolted onto an admin UI,” start with Concepts → Iris explained — that’s the WHY. This section is the WHAT and HOW.

Why Iris matters

Traditional IAM tooling forces every question through the admin UI’s filter-and-search mental model. “How many users have access to Salesforce” requires: navigate to App Registry → click Salesforce → click Users → squint at the count or export to CSV and wc -l. “Show me access requests pending approval older than 14 days” requires: navigate to Approvals → set filter Status=Pending → set filter Created<14d-ago → read the count.

Iris collapses both into one question: “How many users have Salesforce access?” or “Show me approvals stuck more than 14 days.” You ask, Iris answers, with citations to the underlying data. The cognitive overhead of “where does this query live in the UI” disappears.

The cumulative time saving from “ask in English” vs “navigate-then-filter-then-export” compounds. An identity admin running 30+ queries per day saves ~45 min/day. Across a 50-person identity team, that’s 37 hours/day reclaimed for actual governance work instead of UI-navigation work.

Pages in this section

The pages in this section:

Getting started with Iris

Your first 5 minutes with Iris. Walks through the 3 most common query shapes (counts, lists, breakdowns), the response format with citations, and how to verify Iris is interpreting your question correctly before trusting the answer. Both operator (Sarah Chen) and developer (Dev Torres) perspectives.

How Iris stays accurate

The honest answer to “how do I know Iris isn’t making things up?” Named tools instead of generated queries, routing that narrows the choice, a check on the tool Iris picked, and the hard bound that keeps any mistake inside your own tenant.

More in this section

What Iris is NOT

Reading this list once will save you a lot of confusion later:

  • Iris is not a chatbot wrapper around an admin UI. It doesn’t navigate menus on your behalf. It answers data questions directly from the underlying tables.
  • Iris is not free-form SQL. Each query routes to a specific tool from the catalog, or to iris_sql, a structured query over one read-only, tenant-scoped view — never raw tables. Iris does not run SQL text you paste in; it can translate a simple single-view query into that structure.
  • Iris is not an autonomous agent. Every mutation requires explicit human-in-the-loop confirmation via a banner that names the action + impact. There’s no “Iris just deactivated 47 users for me” flow; every deactivation is a separately-confirmed click.
  • Iris is not cross-tenant. Iris running in tenant A’s session can ONLY see tenant A’s data. Every tool runs inside your tenant context, which the database enforces; iris_sql additionally runs on a read-only login that can see only tenant-filtered views, and its results are checked once more before they are returned. See Architecture → Multi-tenancy isolation.
  • Iris is not unaudited. Every answered question writes a CHAT_QUERY row to the audit log with the tools used and the data provenance (source tables, row count, time window) — deliberately not the raw question text. Each iris_sql query also writes its own IRIS_SQL_EXECUTED (or IRIS_SQL_REJECTED) row with the exact query, and confirmed actions are audited by the action itself.

Audience map

Iris serves multiple personas; each gets a different shape of value:

  • Sarah Chen (identity admin) — daily operational queries: “how many access requests are pending?”, “which apps have stale entitlements?”, “what’s my SoD violation count today?” Iris collapses 5-click navigation patterns into single questions.
  • Priya Singh (CISO) — strategic posture queries: “what’s our agent identity footprint vs last quarter?”, “show me the trend of denied access requests over 30 days.” Iris produces the numbers a CISO previously had to ask their team to compile.
  • Marcus Brooks (external auditor) — forensic queries: “verify audit chain integrity for date range X”, “show me every config change in the last 90 days with before/after state.” Iris is the auditor’s SQL terminal with safety rails.
  • Dev Torres (developer) — programmatic queries: ad-hoc lookups during integration debugging, exploring the data model before writing SDK calls, pre-checking what an API call would return.
  • End users — every signed-in role can open Iris, but the tools offered depend on the role. An end_user gets help, their own access requests and request status, access bundles, and aggregate counts; the identity, compliance and infrastructure tools are reserved for the roles that hold those permissions.

Where this fits in the docs

Iris content lives in two places by design:

  • Concepts → Iris explained — the why content. What makes natural-language IAM different from traditional admin UIs, how Iris picks a tool instead of writing a query, and how it checks its own answers. Read this first if you’ve never used a natural-language data interface before.
  • /iris/ (this section) — the what + how content. Operational walkthroughs, accuracy architecture, query patterns, building on top. Read this when you’re ready to actually use Iris.

© AtmanID · Privacy