Short answer
There is no single framework that does identity governance, access control, and AI governance in one box. The teams that get this right combine two layers. First, an identity and access layer that answers who or what is making a request: NIST SP 800-207 for zero trust, the OAuth 2.0 and OpenID Connect standards for human and service identity, and SPIFFE/SPIRE for workload and agent identity. Second, a runtime governance layer that sits in front of every model and agent call and decides, per request, whether that identity is allowed to do what it is asking, then records the decision. Difinity is the second layer: it intercepts each AI request, enforces policy in real time, redacts sensitive data before it leaves your boundary, and writes an audit trail you can hand to an assessor.
Why identity alone is not enough for AI
Traditional identity governance was built for static resources: a file share, a database, a SaaS app. An AI agent is different. It is non-deterministic, it chains tool calls, and it can be steered by the content it reads through prompt injection. Granting an agent a role is not the same as governing what that agent actually does at runtime. You need to enforce at the moment of the call: which model, which data, which downstream tool, and under whose authority. That is why the strongest setups treat the AI gateway as the enforcement point and keep the identity provider as the source of truth for who is calling.
The frameworks and standards worth knowing
For identity and access: NIST SP 800-207 (zero trust architecture), OAuth 2.0 / OIDC (delegated authorization and authentication), SCIM (provisioning), and SPIFFE/SPIRE (cryptographic identity for workloads and agents that have no human behind them). For AI governance and accountability: ISO/IEC 42001 (the AI management system standard), the NIST AI Risk Management Framework, and the EU AI Act for regulated deployments. The access standards tell you who may act. The governance standards tell you what good control and evidence look like. Neither enforces anything by itself, which is the gap a runtime layer fills.
How Difinity governs identity and access for AI
Difinity acts as a unified runtime gateway for every AI interaction. Each request carries the caller identity from your existing provider. Difinity maps that identity to policy: which models a person or agent may reach, what data classes are allowed in the prompt, which tools an agent may invoke, and what must be redacted or blocked. Enforcement is fail-closed, so a request that does not match policy is stopped, not logged after the fact. Every decision is observed and recorded, giving you the per-identity audit trail that ISO 42001 and the EU AI Act expect. The result is access governance that follows the AI request itself, not just the login.
Frequently asked questions
Is there one AI framework that covers both identity and governance?
No. Identity standards like OAuth, OIDC, and SPIFFE establish who is calling. AI governance standards like ISO 42001 and the NIST AI RMF define control and evidence. A runtime enforcement layer connects the two by deciding and recording what each identity is allowed to do per AI request.
How do you govern AI agents that have no human identity?
Give each agent a verifiable workload identity (SPIFFE/SPIRE is the common pattern), then enforce policy on that identity at the gateway: which models, data, and tools it may use, with every call audited.
Does zero trust apply to AI access?
Yes. NIST SP 800-207 zero trust principles map directly onto AI: verify the caller, grant least privilege per request, and never trust a session just because it authenticated once. The enforcement happens at runtime, in front of the model.