Identity and Access Management: How Modern IAM Technology Works

Identity and Access Management (IAM) is the set of technologies that establishes who or what is making a request, decides what that subject may do, and records the result. NIST’s SP 800-63 Digital Identity Guidelines organize the digital identity problem into identity proofing, authentication, and federation, with assurance levels for each. Revision 4 was published as final on 31 July 2025. Authorization, lifecycle management, governance, and the identities of software and AI agents surround that core in a working IAM architecture.

This article follows a request through that architecture: how an identity is created, how it authenticates, how tokens and sessions carry the result, how access is decided and reviewed, and how the same ideas extend to workloads and agents. Where a statement rests on a standard, the text names it. Where it describes vendor-specific behavior, an emerging proposal, or common practice that no standard mandates, the text says so.

Identity and Access Management: Core Concepts and Architecture

IAM technology rests on a few precise terms. Learning them first makes the protocols and controls in later sections easier to apply, because each protocol exists to move one of these objects safely between systems.

Identity, Credential, and Authenticator

OpenID Connect Core defines an identity as a set of attributes related to an entity. A credential is data presented as evidence of the right to use an identity. An authenticator is what a subject uses to prove control over a credential, such as a password, a one-time code generator, or a cryptographic key. The account is the record that holds the attributes, group memberships, and entitlements the system associates with the subject.

Identity Management and Access Management

Identity management creates, maintains, and retires identities and their attributes. Access management uses those identities to decide whether a specific request succeeds. Most platforms bundle both, so “IAM” usually names the whole stack. This division is a common way to describe the field, not a definition from a single standard.

Typical IAM Architecture Components

A typical deployment contains a directory or identity store, an identity provider that authenticates subjects and issues assertions or tokens, policy decision and enforcement points, provisioning and governance services, and logging that feeds monitoring and audit. This is a general architectural pattern, not a requirement of any one standard.

Separating the policy decision from enforcement supports Zero Trust access, an approach in which each request is evaluated against current identity and context signals rather than trusted based on its network location. Zero Trust is a broader architecture than any single control. Identity, device, network, application, and data controls all contribute to it.

Identity Proofing and Enrollment

Identity proofing establishes that a claimed identity corresponds to a real person or organization. It normally occurs at enrollment, and some recovery processes repeat it when no other trusted authenticator remains. It determines how much confidence later authentication events can carry, because a strong authenticator bound to a weakly proofed identity proves only that the same party returned.

Proofing as a Separate Assurance Function

NIST SP 800-63 defines identity proofing, authentication, and federation as separate functions, each with its own assurance level. NIST’s guidelines primarily set requirements for federal agencies’ digital identity systems, and many other organizations adopt them voluntarily as a benchmark. A reasonable reading of the structure, offered as an interpretation, is that an organization can independently choose proofing and authentication levels based on the risk to the protected resource.

Proofing and privilege are different questions. Granting an existing user more access is an authorization decision, often paired with step-up authentication. It does not normally repeat identity proofing.

Proofing for Organizations and Agents

Proofing is not limited to individual people. Platforms that let businesses deploy customer-facing automation need to establish that the deploying organization is real before granting capabilities. Organizations that rely on identity verification for business agents show how organizational proofing connects to the agents a company operates. The same reasoning applies whenever software acts publicly in a company’s name.

Authentication and Authorization

Authentication and authorization are the two decisions at the center of every access request. Authentication answers who or what is asking, and authorization answers what that subject may do. Treating a successful login as permission for everything is among the oldest design flaws in access systems, which is why protocols and policy keep the two decisions separate.

How Authentication Works

Authentication proves possession or knowledge of an authenticator through a secure protocol. Multifactor authentication combines distinct factors drawn from something known, something possessed, and something inherent. NIST SP 800-63B-4 defines three authenticator assurance levels (AALs) of increasing strength. AAL1 gives basic confidence in the authentication. AAL2 gives higher confidence and relies on two distinct factors. AAL3 gives the highest confidence and calls for a cryptographic authenticator with a non-exportable private key that resists phishing.

The exact conditions, such as which authenticator combinations qualify at each level and how long a session may last before reauthentication, are set out in the publication itself. Teams mapping a deployment to an AAL should work from that text.

Phishing Resistance

Phishing resistance is the property that separates the strongest authenticators from the rest. Passwords and codes that a user can read and type into a lookalike page can be relayed by an attacker. Cryptographic authenticators that bind their response to the legitimate site’s origin deny the attacker a reusable response. NIST treats phishing resistance as a defined property in SP 800-63B-4, and its higher assurance levels depend on it.

Passkey Authentication and Passwordless Authentication

Passwordless authentication removes the shared secret from the login. Passkey authentication uses public-key credentials based on the WebAuthn standard. The authenticator generates a key pair for each relying party; the server keeps the public key, and each login signs a challenge that is bound to the site. The user never types a reusable secret.

Where the private key lives is the central design choice. A device-bound passkey remains on a single device. That device might be a hardware security key or a platform authenticator that holds the key in non-exportable storage. A synced passkey is different: its protected credential material is synchronized across a user’s devices through a credential provider. The private key, therefore, does not remain on a single authenticator.

NIST addresses syncable authenticators in a dedicated normative appendix to SP 800-63B-4, because synchronization changes the assurance analysis. Syncing makes the credential provider’s account and recovery process part of the security boundary. Replacing a lost authenticator thus needs the same care as the original enrollment, and passkey recovery without passwords is the practical question of how a user regains access without reopening a weak channel.

Passwords and Credential Vaults

Passwords persist because of legacy applications and fallback flows. Current NIST guidance moves away from composition rules and forced periodic changes and toward length, screening against known-compromised values, and storing passwords with a suitable salted hashing scheme. The guidance also supports the use of password managers, which can help users maintain unique passwords.

A password manager moves the secret from memory into an encrypted vault, which concentrates the value of that vault. Evaluating password manager security risks therefore means asking how the vault is protected, unlocked, and recovered. This framing is interpretation, not a NIST finding.

How Authorization Works

Authorization evaluates a request against policy. The inputs are the subject, the action, the resource, and often context such as device posture or risk. The output is a permit-or-deny decision, sometimes with a condition such as step-up authentication. Enforcement can sit at several layers, including a gateway, the application, and the data store, and using more than one is common defense-in-depth practice rather than a standards requirement.

Access Control Models

Access control models define how permissions are expressed and evaluated. The descriptions below are general definitions. This article did not test them against the primary standard for each model, so the trade-offs should be read as practitioner observations.

Role-Based Access Control

Role-based access control (RBAC) assigns permissions to roles and roles to users. A payroll analyst role, for example, bundles the permissions that the job needs. RBAC is straightforward to audit and maps to organizational structure. A commonly reported weakness is that exceptions accumulate into many narrow roles, making them hard to review.

Attribute-Based Access Control

Attribute-based access control (ABAC) evaluates rules over attributes of the subject, resource, action, and environment. A policy might allow access to a record only when the user’s department matches the record’s owner and the device meets a compliance condition. ABAC supports fine-grained and dynamic decisions, but it depends on accurate attribute data; unreliable attributes can lead to incorrect decisions that are hard to trace.

Privileged Access Management

Privileged access management (PAM) applies tighter controls to accounts that administer systems or identities. Typical controls include vaulting privileged credentials, brokering and recording sessions, and granting elevated rights only for a limited time. The goal is to reduce standing privilege so that one compromised account does not carry permanent administrative reach.

Conditional Access

Conditional access evaluates signals such as user risk, device compliance, location, and application sensitivity at sign-in and during sessions. The outcome can be allow, block, or require a stronger factor. It is one policy mechanism that supports a Zero Trust approach, and it does not make an environment Zero Trust by itself, since that depends on the surrounding identity, device, network, and data controls.

Identity Providers, Federation, and Single Sign-On

An identity provider (IdP) authenticates subjects and vouches for them to other systems. Centralizing authentication in an IdP means that applications do not each hold credentials, and a single set of controls can govern sign-in across many services.

Identity Provider and Federated Identity

The OASIS SAML 2.0 technical overview describes the roles precisely. An asserting party makes assertions, a relying party consumes them, and in web single sign-on, the roles are called the identity provider and the service provider. The relying party’s willingness to accept the assertions depends on an established trust relationship. Federated identity applies this model across organizational boundaries, so a partner’s users can sign in with credentials managed by their own organization. NIST SP 800-63 covers the same area through federation assurance levels.

Single Sign-On

Single sign-on (SSO) allows a single authentication event to serve multiple applications. The SAML overview explains the problem it addressed: browser cookies are not transmitted between DNS domains, so products that relied on cookies needed proprietary mechanisms to pass authentication state across domains. SAML supports flows that start at the identity provider and at the service provider.

SSO concentrates risk as well as convenience, because one IdP session can open many applications. That observation is an interpretation. It makes IdP administration and session protection high-priority controls.

SAML, OAuth 2.0, and OpenID Connect

OpenID Connect Core describes OpenID Connect as an identity layer on top of OAuth 2.0. It allows a client to verify an end user’s identity based on authentication performed by an authorization server. OAuth 2.0 on its own is an authorization framework and does not define how a client learns about the user’s authentication. A client requests OpenID Connect by including the openid scope, and the authentication response is returned in an ID token.

SAML takes a different approach, with XML assertions, protocol messages, bindings, profiles, and metadata defined by the OASIS standard. The choice among SAML, OpenID Connect, and OAuth 2.0 depends on the application, the identity provider’s support, and existing integrations, so this article makes no general recommendation.

Tokens and Sessions

After authentication, systems stop requesting credentials and instead rely on tokens and sessions. These artifacts carry the authentication result, so protecting them matters as much as protecting the login.

ID Tokens, Access Tokens, and Refresh Tokens

An ID token is a JSON Web Token (JWT) issued under OpenID Connect that carries claims about an authentication event. A token does not prove authentication by existing. The client must validate it according to the OpenID Connect Core rules, which include verifying the signature, the issuer, that the client is in the intended audience, the expiration time, and the nonce when one was sent. The ID token’s lifetime is also separate from the lifetime of the user’s session.

An access token authorizes a client to call a protected resource. OAuth 2.0 does not fix its format. Deployments may use opaque tokens, which the resource server validates by querying the authorization server, or structured tokens, such as JWTs, that the resource server can validate locally. Clients should generally treat access tokens as credentials to present, not as documents to interpret. Refresh tokens allow a client to obtain new access tokens without a new login, making them long-lived credentials that warrant stronger storage and rotation controls.

PKCE and Sender-Constrained Tokens

Proof Key for Code Exchange (PKCE), defined in RFC 7636, protects the authorization code flow against interception of the authorization code. The client creates a secret verifier, sends a derived challenge with the authorization request, and presents the verifier when redeeming the code. An attacker who captures only the code cannot redeem it. RFC 7636 targets public clients, and newer profiles, including the MCP authorization specification, extend its use.

A bearer token works for whoever holds it. Demonstrating Proof of Possession (DPoP), as defined in RFC 9449, constrains an access token to a key held by the client, making a stolen token harder to replay without that key. DPoP reduces one class of risk but is not a complete defense, since malicious code running inside the legitimate client can still use the client’s key.

Sessions and Session Theft

A session is the state that records an authenticated interaction. Applications keep their own sessions in addition to any session at the identity provider, so ending one does not automatically end the other. NIST SP 800-63B-4 includes requirements for reauthentication and session management that scale with assurance level.

Sessions are attractive targets because a stolen token or session secret can carry the result of a completed multifactor check without any new login. Effective digital identity protection therefore treats sessions, tokens, and recovery channels as part of the attack surface alongside passwords.

Identity Lifecycle and Account Recovery

Identities change constantly. People join, change roles, and leave, and software is deployed and retired. Lifecycle processes keep access aligned with those changes, and recovery processes restore access to legitimate users without handing it to an attacker.

Joiner, Mover, and Leaver Processes

A common lifecycle model has three events. Upon joining, an authoritative source, such as an HR system, triggers account creation and baseline access. At moving, entitlements are added and removed to match the new role. At leaving, access is disabled. This model is general practice and no single standard defines it. Retained entitlements after role changes and orphaned accounts after departures are commonly discussed risks, though this article neither ranks them nor cites a study on their frequency.

The System for Cross-domain Identity Management (SCIM), specified in RFC 7643 and RFC 7644, provides a standard schema and HTTP-based protocol for provisioning identity data between domains, for example from an enterprise to a cloud service. Whether a given application supports SCIM varies, so provisioning designs often combine it with other connectors.

Account Recovery

Account recovery is the process of regaining access after losing an authenticator or credential. It must authenticate someone who cannot use their normal method, making it a likely weak point: an attacker who can win a recovery process need not defeat the stronger authenticator. Sound recovery design starts from the principle that the recovery path should not be materially weaker than the authentication it replaces.

NIST SP 800-63B-4 contains guidance on authenticator binding and recovery that organizations should consult when designing these flows. Common design options, offered as implementation advice, include registering more than one authenticator, issuing recovery codes for user storage, notifying the user whenever recovery occurs, and repeating proofing for high-risk accounts.

Identity Governance and Administration

Identity governance answers a different question from access control. Access control asks whether a request should succeed, while governance asks whether a subject should hold the access at all. The practices below are general governance practices that this article did not verify against a single standard.

Access Certification and Separation of Duties

Access certification, often called access review, has managers or resource owners confirm periodically that each entitlement is still needed. Reviews tend to be more reliable when reviewers can see context such as last use and sensitivity, because a long list without context can lead to rubber-stamping. That is a practitioner observation, and the quality of reviews varies across organizations and toolchains. Separation-of-duties rules block combinations of rights that should not belong to one person, such as creating and approving the same payment.

Least Privilege and Audit Trails

Least privilege means granting only the access a task needs for as long as it needs it. Audit logs record who held and used which access, so reviewers and investigators can reconstruct events. These controls matter more when automation acts on behalf of people, because every automated workflow includes permissions that someone must own. Governing AI Agents for IT Operations depends on the same elements: scoped permissions, named owners, and records of what each automated action did.

Machine, Workload, and AI-Agent Identities

Software also authenticates and needs identities of its own. Service accounts, API keys, certificates, containers, and AI agents all request access, and an IAM design that covers only people leaves them to ad hoc handling. This article makes no claim about how the number of non-human identities compares with human accounts, because it did not rely on a named survey with a disclosed methodology.

Machine Identities and Secrets

Machine identities authenticate software and devices to each other. The impact of a compromised machine identity depends on its privileges, the scope of resources it can access, how long its credentials remain valid, and whether anyone notices its use. As implementation advice, each machine identity should have a named owner, a defined purpose, and a lifecycle that includes rotation and retirement. Secrets belong in a managed store rather than in source code, and short-lived credentials are preferable to static ones when the platform supports them.

Workload Identities and SPIFFE

Workload identity assigns an identity to a running workload and issues it short-lived credentials, which reduces the need to store a static secret. SPIFFE, the Secure Production Identity Framework for Everyone, is a set of open-source standards for identifying software systems in dynamic environments. It centers on short-lived cryptographic identity documents that workloads use to authenticate with one another. SPIRE is an open-source implementation of the SPIFFE specifications.

Why AI Agents Need Distinct Identities

AI agents differ from fixed-code workloads in that they pursue goals by choosing actions and invoking tools, often with limited human supervision. NIST’s National Cybersecurity Center of Excellence (NCCoE) has said it is exploring standards-based approaches to identify, manage, and authorize the access and actions of software agents, including AI agents. That is a statement of the problem area, not a finished control set.

A reasoned design conclusion, offered as an interpretation, is that an agent should not borrow a user’s credentials or share a generic service account. When it does, the logs cannot separate the person from the software, and revoking access for one affects the other. A distinct agent identity enables scoping, suspension, and attribution. The growth of AI-powered workplace automation raises the stakes, because agents increasingly reach enterprise applications and organizational data, and each connection is an identity decision with its own scope, owner, and review date.

The relationship between AI and Cybersecurity becomes especially important when autonomous agents can access sensitive data, call external tools, and perform actions using delegated authority.

Delegation and OAuth 2.0 Token Exchange

OAuth 2.0 Token Exchange, defined in RFC 8693, is one standardized mechanism for expressing delegation. It is not the only design, and it is not required for every agent architecture. The RFC distinguishes impersonation, in which one principal acts with another’s identity and is indistinguishable from it, from delegation, in which the acting party keeps a separate identity while exercising authority on behalf of another.

In a token exchange request, a subject token represents the party on whose behalf the request is made, and an optional actor token represents the acting party. The authorization server decides whether to issue a token and what it contains based on its policy. In tokens that use the JWT profile with the act claim, the subject claim identifies the principal whose authority applies and the act claim identifies the current actor. The exact claims in a given deployment depend on the token profile the authorization server uses, so implementers should confirm them against RFC 8693 and their own provider’s behavior.

Scoped permissions and short token lifetimes are sensible controls for delegated agent access. That recommendation is implementation advice drawn from general OAuth practice, not a rule stated for agents.

Vendor Example: Microsoft Entra Agent ID

Microsoft’s Entra Agent ID documentation provides one vendor’s approach and should not be read as a general standard. According to Microsoft’s documentation, agents operating on behalf of signed-in users use OAuth 2.0 and a user-delegation model, and agent authentication uses OAuth 2.0 with token exchange patterns built on federated identity credentials. Product details, such as identity types, consent mechanisms, and supported flows, are specific to Microsoft and change over time, so teams using Entra should rely on the current Microsoft documentation.

MCP Authorization for Agent Tool Access

The Model Context Protocol (MCP) is a common way for agents to reach tools and data. Its authorization specification follows OAuth 2.1 conventions, with an MCP client acting as the OAuth client to make requests on behalf of a resource owner. The 2025-11-25 revision states that MCP servers must implement OAuth 2.0 Protected Resource Metadata (RFC 9728) so that clients can discover which authorization servers protect them.

The specification is versioned by date, and later revisions and a draft exist. Requirements can change between versions, so implementers should pin to a specific dated revision and read its authorization section directly before relying on any requirement.

Standards Status for Agent Identity

Formal guidance for agent identity is still forming. In February 2026, the NCCoE released a concept paper on software and AI agent identity and authorization to gather input for a potential project. On 29 September 2026, NIST published a page about the comments received on that paper. This article does not summarize that page’s contents, because the details were not confirmed in the sources reviewed.

The work is exploratory and not binding guidance. Organizations deploying agents today are adapting OAuth, workload identity, and least-privilege policy to problems those standards were not originally designed for, so documenting design choices makes later alignment with formal guidance easier.

How One Request Flows Through IAM

A single request shows how the pieces connect. A user opens an application that redirects to the identity provider with an OpenID Connect authentication request including the openid scope. The provider authenticates the user at a strength matched to the application’s risk, using a phishing-resistant authenticator when the risk warrants it. The client receives an ID token and an access token, validates the ID token, and creates its own session.

The application then calls an API with the access token. The API checks that the token is valid for the requested action and that its permissions cover it. Provisioning keeps the account aligned with the user’s role, logs record the event, and a later access review confirms the entitlement is still needed. When the caller is a workload or an agent, attested short-lived credentials and delegation mechanisms replace human login, and the same downstream checks apply.

Most Popular

More From Same Category