Skip to content

How AtmanID thinks about IAM

This page is the mental model that makes the rest of AtmanID’s documentation make sense. If you’ve worked in IAM before, much of this will be familiar — read it anyway, because some of the vocabulary is used precisely (entitlement vs role vs permission vs grant — these are NOT synonyms in this product) and the precision matters when you’re configuring or operating.

If you’re new to IAM, this is a 10-minute crash course in how identity governance professionals think about access.

The three pillars

IAM is one term covering three different problem domains that sometimes get muddled. AtmanID treats them as distinct because the workflows, the audiences, and the data models are different.

Identity Management (IDM) answers “who exists in our systems?” — provisioning new users, deprovisioning departed users, syncing identity attributes from authoritative sources (HRIS like Workday, IdP like Okta, Active Directory). The Joiner-Mover-Leaver (JML) lifecycle lives here. Most operational pain in IAM comes from JML — you’d be surprised how many organizations have ex-employees with active access months after departure.

Identity Governance (IG) answers “is the access people have appropriate?” — access certifications (periodic reviews of who has what), Segregation of Duties (SoD) policy enforcement, access requests with approval workflows, role design, entitlement minimization. Governance is where compliance auditors look first; it’s also where the most political organizational dynamics show up (managers who don’t want to do quarterly reviews, business owners who don’t want their power-user access flagged, etc.).

Access Management (AM) answers “who can sign in and what can they do once authenticated?” — Single Sign-On (SSO), Multi-Factor Authentication (MFA), session management, runtime access enforcement. For people, AtmanID intentionally does NOT compete with Okta/Auth0/Azure AD on the authentication layer — that surface is well-served by incumbents and standards (SAML, OIDC, SCIM). AtmanID lives downstream: once authentication has decided WHO the user is, AtmanID governs WHAT they can do.

For AI agents, AtmanID does enforce at runtime. Agents receive tokens scoped to specific MCP servers and tools (optionally DPoP-bound, so a stolen token is useless without the agent’s key), and every agent → MCP tool call passes through the AtmanID gateway, which checks the token, the tool scope, intent policy and rate limits, and can hold a call for human approval. New enforcement starts in shadow mode (log what would be denied) and is promoted to enforce once an operator is satisfied. Humans and agents share one identity model and one tamper-evident audit trail.

A way to remember the split: IDM is provisioning, IG is policy, AM is enforcement. AtmanID owns IG end-to-end, covers IDM for cloud-first identity providers and SaaS targets (with on-prem AD/Exchange and the long tail of legacy systems on the roadmap, not in v1), integrates with (rather than replaces) human SSO/MFA, and is itself the runtime enforcement point for AI agents.

The data model — getting the vocabulary right

Sloppy vocabulary causes real bugs in IAM. AtmanID uses these terms precisely:

Identity — a person, service account, or AI agent that the platform tracks. An identity is the thing, not the credentials it uses to sign in. Sarah Chen is one identity, regardless of whether she has 20 different application accounts or 1.

Account — a credentialed login record in a specific application. Sarah Chen the identity might have an account in Salesforce, an account in Snowflake, an account in GitHub, and an account in the AtmanID platform itself. Each account is tracked separately (one row per application account, correlated back to the identity that owns it). Accounts are the unit of provisioning: connectors create, disable and sync them.

Entitlement — a specific privilege within an application. “Salesforce admin” is an entitlement. “Snowflake read access to the marketing schema” is an entitlement. “GitHub write access to the payments-api repo” is an entitlement. Entitlements are defined per application in entitlements and are granted to the identity (the person, service account or agent), not to one of its application accounts.

Role — a named bundle of entitlements. “Marketing Analyst” might be a role that grants 8 specific entitlements across 4 apps. Roles exist so you can assign coherent jobs-to-be-done instead of hand-picking 8 entitlements every time someone joins the marketing team. AtmanID supports both built-in platform roles (identity_admin, compliance_officer, etc.) and custom application roles.

Permission — what a role/entitlement allows once assigned. “Read”, “write”, “delete”, “execute”-shaped capabilities. This is the lowest level — what the actual code checks.

Grant — the record that an identity holds an entitlement, with metadata: who granted it and when, where it came from, the access request that carries the business justification, an optional expiry, revocation details, and when it was last used. Grants can be time-bounded; “Sarah has Salesforce admin access” is shorthand for “there is an active, non-expired, non-revoked grant of the Salesforce admin entitlement to Sarah.”

The key disambiguation: identity ≠ account, role ≠ entitlement, grant ≠ permission. Grants hang off the identity; accounts are the separate per-application login records that provisioning acts on. If you treat these as synonyms, you’ll write SQL queries that return wrong counts — counting accounts is not counting people, and counting grants is not counting accounts.

The JML lifecycle is the backbone

Most of identity management is one of three events:

Joiner — new identity arrives. Workday signals “new employee starting Monday.” AtmanID resolves the birthright access profiles that match the person’s department, identity type and job title, grants those entitlements, generates login IDs, and provisions an account in each target application — through the connector where there is one, or as a provisioning ticket where there isn’t. A joiner can optionally wait for manager approval before the application accounts are created, and a returning employee is recognised as a rehire.

Mover — existing identity changes role/manager/department. The trickiest case. The naive approach is “grant the new role’s access” — but you also have to revoke access from the old role that the new role doesn’t include. Most legacy IAM tools handle joiner well and mover badly; access accumulates over time as people change jobs and the old grants never get cleaned up. On a department transfer AtmanID works out which grants the person held only because of the department they left, raises revocation for those, and re-runs the Segregation of Duties scan.

Leaver — identity departs. AtmanID disables the person’s accounts in connected applications (or opens a revocation ticket, which can be pushed to Jira or ServiceNow, where there is no connector), marks the identity deprovisioned, kills their outstanding email approval links, re-evaluates their live sessions, and deactivates the AI agents they own. For Microsoft 365 it can also remove mailbox forwarding rules and distribution-group memberships, set an out-of-office reply, delegate the calendar, and convert the mailbox to a shared mailbox. An immediate termination also revokes every grant in the same transaction as the status change. The 24-hour window between “HR marks user as terminated” and “all credentials revoked” is the highest-risk window in IAM — disgruntled ex-employees, social-engineering attacks against now-orphaned accounts, etc.

JML is invisible when it works and catastrophic when it doesn’t. Most security incidents at the IAM layer trace back to a JML gap (access that should have been revoked at termination but wasn’t).

The audit chain — compliance as a query, not a project

Every action AtmanID takes writes to an audit record. Each row has:

  • actor_id (who or what initiated the action — identity ID, agent ID, or system)
  • action_type (USER_PROVISIONED, ENTITLEMENT_GRANTED, CERT_CAMPAIGN_CREATED, CERTIFICATION_REVOKED, IRIS_SQL_EXECUTED, etc.)
  • target_resource_type + target_resource_id (what the action affected)
  • previous_state + new_state (JSONB snapshots — the before-and-after diff)
  • created_at (timestamp)
  • tenant_id (multi-tenant isolation)
  • sequence_num (monotonic per tenant — gap = tampering)
  • previous_hash (hash of the previous row’s integrity_hash)
  • integrity_hash (SHA-256 over the row’s content including previous_hash)
  • hash_version (which hashing format the row uses, so older rows keep verifying as the format improves)

Because each record’s hash covers the previous record’s, the chain means any tampering with a historical row breaks the chain at that point AND at every row after it. Iris’s audit-chain check re-checks the most recent entries on request and reports any break, and the chain is re-verified automatically: the most recent entries every night (02:30 UTC), the whole history every week (Sunday 03:30 UTC).

Personal data in the chain is erasable without breaking it. In current rows the fields that can identify a person (actor and target ids, IP address, user agent, the before/after snapshots) enter the hash as salted commitments. Erasing a person’s data replaces the values and deletes the salts: the chain still verifies, and the erased values can no longer be confirmed by guessing. SOC2 auditors love this; it converts evidence collection from “we have audit logs, here’s a screenshot” to “we have a tamper-evident chain, and here is the check that proves it’s intact.”

Beyond integrity: the structured event taxonomy means compliance evidence is a query. Need to prove you ran access certifications every quarter last year? Filter campaigns by date. Need to prove every critical grant has a documented business justification? Search grants of critical entitlements for an empty justification — the expected answer is none.

The five operating principles

These principles are baked into every product decision:

  1. “You can’t govern access you can’t see.” Entitlement data must flow from target systems into AtmanID before any governance is possible. Provisioning without capturing entitlements is incomplete.

  2. “Access only grows unless something deliberately takes it away.” Every grant has a corresponding revocation path. There are no one-way doors.

  3. “Audit-readiness should fall out of daily operations — never be a separate project.” Every workflow writes to the audit log. No exceptions.

  4. “A review without context is a rubber stamp.” Reviews must show the certifier: original business justification, last-used date, peer-group comparison. Without context, certification is compliance theatre.

  5. “Access governance is a business process, not an IT ticket queue.” Workflows touching business stakeholders (managers, app owners) must be completable without IAM expertise. The UI explains why, not just what.

These principles distinguish AtmanID from tools that “have the feature” without thinking through whether the feature is usable in practice.

Where to go next

  • For who exercises which surface: Personas
  • For the technical foundation that makes audit-chain integrity provable: Architecture overview
  • For why natural-language interfaces change the operator experience for IAM specifically: Iris explained
  • For the practical “how do I do X” recipes: Guides

© AtmanID · Privacy