Okta for AI Agents treats each AI agent as a managed identity in Universal Directory, so the security outcome depends on how carefully you register it, choose its credential, scope its resource connections and keep its owners and access reviews current. This guide walks through each configuration stage in the order Okta documents it: discover, register, connect and govern. For each stage it sets out the settings that matter, the decisions that are hard to reverse, and the controls an identity team should put in place before an agent reaches production.
The guide is written for identity engineers, Okta administrators and security architects who already run an Okta Identity Engine org and now need to bring custom and third-party AI agents under the same lifecycle discipline as workforce users and service apps. It assumes familiarity with OAuth 2.0 clients, custom authorisation servers and scopes.
This is an independent guide from NHI Mgmt Group, based on Okta's public documentation as of November 2026. It is not sponsored or reviewed by Okta. Product features change, so confirm settings against Okta's current documentation.
Key takeaways
- Okta describes a four-stage model for agents: discover and assess, add and register, connect to resources, and govern access. Configure each stage deliberately rather than registering agents ad hoc.
- Assign owners at registration. Okta recommends at least two owners, and supports up to five individual owners or one group owner with at least two members.
- Pick the credential method carefully. Okta supports Client ID Metadata Document, Client ID only, client secret and public/private key, but only one method can be active at a time, and a Client ID Metadata Document URL cannot be changed once set.
- Some choices are permanent. Linking an agent to a user sign-on app cannot be undone without deleting and recreating the agent, and the audience or resource URL for machine access cannot be edited later.
- Resource connections are where least privilege lives. Use "Only allow" scope lists rather than "Allow all", and remember that deactivating or removing a connection makes Okta deny all future requests from that agent to that resource.
- Use Okta Identity Governance access requests with a fixed duration and access certification campaigns so agent access is time bound and reviewed.
- Check licensing before you plan. The Okta for AI Agents Core SKU used for FedRAMP and US military customers excludes Okta Privileged Access and Identity Security Posture Management (ISPM).
How Okta models an AI agent
Okta positions Okta for AI Agents as the way to discover, manage and secure the AI agent lifecycle in an org, so that agents become a managed part of the digital workforce rather than an unmanaged risk. The overview page lists three stated benefits: least privilege and time-bound access restricted by policy, visibility into each agent's connections, scopes and risks, and central control through System Log events for AI agents in the Admin Console.
In practice an Okta AI agent is a first-class directory object listed under Directory > AI Agents. It carries five groups of configuration that this guide covers in turn:
- Profile: name, description and, for agents built on third-party builder platforms, the platform name and an external ID.
- Owners: the humans or group accountable for the agent.
- Client registration: the credential the agent uses to authenticate to Okta.
- User access and machine access: whether the agent acts on behalf of a signed-in user through a linked app, and which non-human callers may call the agent.
- Resource connections: the authorisation servers, applications, MCP servers, vaulted secrets, service accounts, gateways and other agents the agent may reach.
Okta also notes that all Okta orgs can use Cross App Access (XAA) to secure connections between AI agents and apps. Treat XAA and the agent directory object as complementary: the agent object holds ownership, credentials and connections, and the app-to-app flow governs how tokens move between applications the agent uses.
The key design principle is that an agent should never be a loose OAuth client created by a developer in isolation. Every agent should have an owner, a single active credential, an explicit list of resources and a governance path, all recorded on one object that the identity team can audit. For a broader view of the identity patterns behind this, see the Agent Identity and Access Guide.
Stage 1: discover and assess agents
Okta treats discovery as the first stage of the agent lifecycle. Its purpose is to show which agents operate in your environment so you can assess their ownership, permissions and the resources they can affect. Discovery capabilities are documented within Okta Identity Security Posture Management (ISPM), and each discovery source is powered by an ISPM integration.
| Discovery source (Okta documentation) | Agent category |
|---|---|
| Secure Access Monitor (SAM) plugin | Shadow AI (browser) |
| CrowdStrike Falcon integration | Locally running agents and MCP servers |
| Salesforce Agentforce integration | Builder platforms |
| Microsoft Copilot Studio integration | Builder platforms |
Once ISPM has surfaced an agent, the documented next step is to register it, or import it into Universal Directory, so that it comes under Okta governance. Okta's discovery page does not describe the risk scoring criteria, so build your own triage rules on top of what ISPM shows. NHI Mgmt Group suggests the following triage order for discovered agents:
- Agents with access to production data or write actions in business systems.
- Agents with no identifiable human owner.
- Locally running agents and MCP servers on developer endpoints, which often hold long-lived personal tokens.
- Browser-based shadow AI use that sends data to unmanaged services.
For each discovered agent, record a decision: register and govern, replace with a sanctioned alternative, or block. Leaving discovered agents in an "assessed but not decided" state is a common way for inventory work to stall. The Shadow AI Discovery Guide covers discovery methods in more depth.
If you run the Core SKU, note that ISPM is excluded, so discovery will need to rely on other inventory sources and manual registration.
Stage 2: register agents and assign owners
Okta offers two registration methods. Manual registration is for homegrown agents, including agents built with custom code on an agent builder platform. Import from an app is for agents built on third-party builder platforms whose provider app supports agent import; it syncs those agents with Okta for central visibility and control. Okta's guidance is to import when the provider supports it rather than registering manually.
Profile fields
The profile requires a name and description. For agents on third-party builder platforms you also enter the platform name and the agent's external ID. The external ID keeps each agent unique in the org and prevents duplicate profiles, so treat it as mandatory in your own standards even where the console lets you proceed without it. NHI Mgmt Group recommends a naming convention that encodes business owner, environment and purpose, for example a team prefix and an environment suffix, so that System Log events and certification campaigns are readable without opening each object.
Owners
Owners are optional in the console, but they should not be optional in your process. Okta recommends assigning at least two owners so the agent always has one. You can assign up to five individual owners, or one group owner, and the group must have at least two members.
Okta's page does not say what happens to an agent when an owner leaves or is removed. Close that gap yourself:
- Prefer a group owner tied to a team rather than named individuals, so joiner, mover and leaver changes flow through group membership.
- If you use individual owners, add a lifecycle hook or Okta Workflows check that flags agents whose owner count drops below two after a deprovisioning event.
- Make owner confirmation part of each certification campaign.
Viewing the agent inventory
Registered agents appear under Directory > AI Agents. The View button controls which columns display and the Filter button narrows the list by provider, sign-on app or managed status. Save a view that shows provider, status, owners and linked app, and review it weekly during roll-out.
Stage 2 continued: choose the agent's credential
Client registration sets how the agent authenticates to Okta. The documented methods are:
| Method | What Okta documents | NHI Mgmt Group guidance |
|---|---|---|
| Client ID Metadata Document (CIMD) | Uses a developer-hosted URL. Once configured, it cannot be changed. | Use only when the hosting URL is under change control and owned by the same team as the agent. |
| Client ID only | For public clients that cannot store a secret, such as local coding agents. | Restrict to user-delegated access through a linked app; avoid broad machine scopes. |
| Client secret | Okta generates the secret and you pass it to the builder or developer. | Deliver it through a secrets manager, never chat or tickets, and set a rotation date. |
| Public/private key | Supply a public key (JWK) or let Okta generate a key pair. A generated private key is shown in JSON or PEM at generation time and must be stored securely. | Preferred for confidential agents. Supply your own JWK where possible so the private key never leaves your key store. |
Several important mechanics follow from the documentation:
- You can stage several methods but only one can be active at a time. Switching disables the previous method's details, although they are kept on the tab. Clean up staged material you no longer need.
- After activating a method you must click Enable, and the agent cannot use the method until the builder implements the secret or key. Plan the cut-over with the agent's developers.
- Secrets and keys can be deactivated and then deleted through the ellipsis menu. Use this sequence for rotation: add the new key, move the agent to it, deactivate the old one, confirm no failures, then delete.
- Agent activation is separate from credential activation. Use Actions > Activate and Actions > Deactivate on the agent itself. Deactivating the agent is the fastest documented containment step if it misbehaves.
Rotation cadence, storage and revocation patterns are covered in the AI Agent Credential Lifecycle and Rotation Guide.
Configure user access and machine access
User access through a linked app
An agent can act on a user's behalf only while that user is signed in to the linked app. One app can be linked per agent, and the linked app's page shows a "Linked AI Agent" entry pointing back to the agent. You can create a new OIDC app linked to the agent, or select an existing app (a SAML app during creation, or an OIDC app from the User access tab).
Linking is permanent. To change it you must delete the agent and recreate it, which loses its history on the object and forces a credential change for developers. Before linking:
- Confirm which app the agent's users actually sign in to, and whether that will still be true after planned app consolidation.
- Prefer a dedicated OIDC app for the agent over reusing a broad, long-lived SAML app, so that assignment of the app is effectively assignment of the agent.
- Document the decision in the agent description.
Machine access by other callers
Non-human callers can access the agent with their own access token. This needs a one-time custom authorisation server set-up in which you select the server and enter an audience or resource URL; that value cannot be edited later, so agree a stable naming scheme before you start. Callers can be other AI agents, granted all scopes, selected scopes only, or with scopes denied, or ordinary apps and services. Adding another AI agent as a caller automatically creates a resource connection between them, while other callers need resource connections configured separately.
Agent-to-agent calls are where delegation chains form, so keep a diagram of which agents can call which. Every new caller relationship should be justified in a change record and appear in the next certification campaign.
Stage 3: connect agents to resources with least privilege
Resource connections are the core authorisation control. Okta's prerequisites are an admin role that can manage AI agents and their resources, the Okta Privileged Access security admin role if you are connecting secrets or service accounts, completed configuration for each resource, and a registered agent. Connections are added from the agent's Resource connections tab with Add resource connection.
| Resource type | Settings Okta documents |
|---|---|
| Agent Gateway | Select a gateway from a list. |
| Authorisation server | Select a server; scopes set to Allow all, Only allow or Disallow. |
| Secret (vaulted) | Select a secret; accept or modify the Resource Indicator the agent uses when requesting the secret from Okta. |
| Service account | Select an app and a service account; accept or modify the Resource Indicator. |
| Application | An app configured for AI agent access (enter its client ID; Allow all, Only allow or Disallow scopes) or a custom resource server (Resource Indicator populated automatically). |
| MCP server | Select from a list; Resource Indicator populated automatically. |
| Another AI agent | Select the agent; if a delegation link exists the authorisation server and audience populate automatically, otherwise set them; Allow all, Only allow or Disallow scopes. |
Configuration rules NHI Mgmt Group recommends:
- Default to "Only allow". "Allow all" grants every current and future scope on that server. Use "Disallow" only to carve exceptions out of a deliberately broad grant.
- One connection per purpose. Avoid a single connection that bundles read and write scopes for unrelated tasks; separate connections are easier to deactivate surgically.
- Vault rather than embed. Where an agent needs a downstream API key or service account password, connect it as a vaulted secret or service account so retrieval is brokered and logged, instead of placing the value in the agent's configuration.
- Treat MCP servers as resources. Connecting the agent to named MCP servers gives you a reviewable list of tools it can reach. The MCP Server Security Checklist covers hardening the servers themselves.
- Use deactivation for containment. Okta states that deactivating or removing a connection causes it to deny all future access requests from the agent to that resource. That makes per-connection deactivation a precise response when one integration is suspect.
The resource indicator and audience fields map to standard OAuth concepts in RFC 8707 Resource Indicators for OAuth 2.0; keep them consistent across environments so token audiences are predictable. Because connecting secrets and service accounts needs the Privileged Access security admin role, review who holds that role alongside your other Okta admin roles, using the Okta Admin Roles Security Guide.
Stage 4: govern agent access over time
Okta Identity Governance extends to AI agents and to the user sign-on apps they are linked to. Two governance features are documented for agents.
Access requests
Users request access to the linked app from their End-User Dashboard. App conditions decide who can request, admins define approval routing and the actions taken on approval or denial (including custom actions through delegated flows), and admins can set an access duration after which access is revoked automatically. Set a duration on every agent-linked app request. Because an agent acts on behalf of signed-in users of the linked app, expiring user access to that app also expires the agent's delegated reach for that user.
Access certifications
Resource or identity campaigns review users' app access and remediate automatically based on reviewer decisions, and campaigns can be extended through Okta Workflows. NHI Mgmt Group suggests a quarterly campaign per agent-linked app, with the agent owners as reviewers, plus an extended Workflows step that asks owners to confirm the agent's resource connections and scope lists are still needed. Okta's governance page does not describe certifying resource connections directly, so that confirmation step needs to be built in your process.
The Okta Identity Governance Guide covers campaign design in detail.
Licensing and public sector limits
Okta documents that the Okta for AI Agents Core SKU, the version available to Okta for Government Moderate, Okta for Government High and Okta for US Military customers, excludes Okta Privileged Access, ISPM, the Governance Analyzer feature and LLM-generated summaries in Security Access Reviews. It also states that Core is not available in Okta for US Military cells. Federal and defence teams should confirm the current exclusion list before designing discovery or vaulted secret connections.
Logging, monitoring and response
Okta states that System Log events for AI agents are visible in the Admin Console. Build monitoring around the configuration changes that alter an agent's reach:
- Agent created, activated or deactivated.
- Credential method staged, activated, enabled, deactivated or deleted.
- Owner added or removed.
- Resource connection added, edited, deactivated or removed, especially changes to "Allow all".
- New caller agents added for machine access.
Forward these events to your SIEM and alert on changes made outside approved change windows or by admins who are not on the agent platform team. The Okta System Log Detection Guide covers forwarding and query patterns.
A simple response ladder for a misbehaving agent, from narrowest to broadest:
- Deactivate the specific resource connection involved.
- Deactivate the active credential so new tokens cannot be obtained, then issue a fresh one once the cause is fixed.
- Deactivate the agent with Actions > Deactivate.
- Review caller agents that connect to it and deactivate those connections if a delegation chain is involved.
Rehearse this ladder in a non-production org so owners know who can act and how long each step takes.
Common failure patterns
- Single or no owner. Agents registered with one named owner become orphaned when that person leaves. Okta's own recommendation is at least two.
- "Allow all" as the default. Broad scope grants on an authorisation server silently extend to scopes added later.
- Generated private keys handled casually. The private key is shown once at generation; copying it into tickets or chat creates an untracked secret.
- Stale staged credentials. Old secrets and keys left on the tab after switching methods are easy to reactivate by mistake.
- Linking the wrong app. Because linking is permanent, an agent tied to a legacy app has to be deleted and rebuilt to move.
- Unplanned audience values. The machine access audience cannot be edited, so ad hoc values become permanent inconsistencies.
- Manual registration of importable agents. Registering builder platform agents by hand instead of importing them loses sync and invites duplicates.
- Discovery without decisions. Shadow agents listed in ISPM but never registered, replaced or blocked.
Practitioner checklist
- Inventory agents from ISPM or other sources and record a register, replace or block decision for each.
- Import builder platform agents where the provider supports it; register custom agents manually with an external ID where relevant.
- Assign at least two owners, preferably a team group owner with two or more members.
- Choose one credential method, prefer a supplied public key for confidential agents, and remove unused staged methods.
- Agree app linking and audience values before configuration, since both are effectively permanent.
- Create resource connections with "Only allow" scope lists and one connection per purpose.
- Broker downstream secrets and service accounts through vaulted connections and restrict the Privileged Access security admin role.
- Set access durations on access requests for agent-linked apps and run quarterly certifications with owner confirmation of connections.
- Forward AI agent System Log events to the SIEM and alert on credential, owner and connection changes.
- Document and rehearse the containment ladder: connection, credential, agent, callers.
- Check SKU exclusions if you operate in a FedRAMP or US military environment.
Standards and references
- Okta: Manage AI agents
- Okta: Add and register AI agents
- Okta: Add AI agents manually
- Okta: Connect AI agents to resources
- Okta: Govern access to AI agents
- Okta: Discover and assess AI agents
- IETF: RFC 8707 Resource Indicators for OAuth 2.0
- OWASP GenAI Security Project: Top 10 for Agentic Applications for 2026
Related NHI Mgmt Group resources: Okta Security Hardening Guide · Okta Identity Governance Guide · Okta System Log Detection Guide · AI Agent Authorisation Guide