Okta AI Agents: API Guide, Access Reviews and Approvals
A practical guide to Okta AI agents, native identity intelligence, eight verified API operations, and governed access-review workflows on Major.

Okta AI agents can mean agents whose identities Okta secures, or agents that use Okta data to investigate access and coordinate IT work. This guide covers both, including native Okta AI, eight verified API operations, and governed automation on Major.
Major gives the process a deterministic app for state and review, an agent for judgment, and a workflow for triggers, retries, and approvals.
What Okta does for identity teams
Identity administrators use Okta to manage users, groups, application access, and account lifecycle operations. Security analysts use its System Log to investigate activity, while application owners rely on assignments and identity policies to control access. These are concrete objects exposed in the Okta API reference.
The operational problem usually crosses a boundary. An unusual sign-in needs a responder, an offboarding request needs an access inventory, or a manager needs to explain why a contractor still belongs to a sensitive group. Okta holds identity evidence, but the request, investigation, and approval may live elsewhere.
Major is the enterprise platform where agents build the software they run on. For an identity team, that software can be a review app with managed tables for evidence, assignments, approvals, and execution history. The agent interprets ambiguous context, while repeatable retrieval and tracking run in code.
This guide is for IT and security leaders designing that operating model. Start with read-only investigations that help administrators reach a decision before introducing any access-changing permission.
Okta AI agents and Okta's built-in intelligence
Identity Threat Protection with Okta AI continuously evaluates identity and session risk. It considers behavior, device health, identity context, policies, and connected security signals. Configured responses can require reauthentication or end sessions across supported applications.
The ITP administration guide explains how risk assessment and response depend on policies and integrations. Keep these controls authoritative. An external agent should not reinterpret a native enforcement decision as permission to weaken it.
Okta for AI Agents addresses a different question: how to register agents, give them identities and public-key credentials, manage their lifecycle, and authorize resource access through token exchange. It secures agents rather than serving as a general-purpose analyst for every business process.
Major adds the surrounding work: interpreting a suspicious event alongside a service request, drafting an escalation, preserving unresolved questions, and routing a proposed action for approval. The app keeps that history after the model call ends. Native risk enforcement stays in Okta; cross-system investigation and coordination happen through the governed process on Major.
How Okta connects to Major
Okta connects through Major's Pipedream connector, app p_okta. There is no native Okta connector. IT sets up the connector once, keeps credentials centrally stored in the connector vault, and scopes what each app, agent, and workflow can access.
The underlying management API uses the organization's Okta domain over HTTPS. Okta supports scoped OAuth access tokens and SSWS API tokens, and recommends scoped OAuth. Confirm which authentication and operations the configured connector exposes before designing execution permissions; API availability alone does not establish connector action coverage.
A useful starting configuration can read logs and user context but cannot change identity state. Put any approved write operation on a separately permissioned execution path. Credentials belong in the vault, never in app source, prompts, or copied investigation notes.
Major orchestrates Okta; it never replaces it. Okta remains the identity authority. Major's SSO, RBAC, and audit logs cover the app, agent, and workflow that coordinate the work, including who requested an action and who approved it.
Okta API guide for governed automation
Authentication, delivery, and testing
For direct service integrations, Okta's OAuth service-app guide specifies Client Credentials with private-key JWT authentication. Assign both allowed scopes and appropriate admin roles. An SSWS token inherits its creator's privileges, so it is not equivalent to a narrowly scoped OAuth grant.
The read operations below use the documented scopes okta.logs.read, okta.users.read, okta.apps.read, and okta.groups.read. The suspension operation requires okta.users.manage.
For pagination, follow the next URL in the Link response header. Parameters include after, before, and limit where supported. System Log polling can keep returning a next link, so absence of new events is different from reaching the end of a static collection.
Rate limits vary by endpoint, subscription, and configuration; there is no universal management-API allowance. Use the organization's Rate Limit Dashboard and monitor X-Rate-Limit-Limit, X-Rate-Limit-Remaining, and X-Rate-Limit-Reset. The reset value is UTC epoch seconds. A 429 requires delayed retry, not immediate replay.
Event Hooks deliver eligible System Log events. Verification is a one-time GET: echo the x-okta-verification-challenge header in the JSON verification field. Use configured Authorization-header authentication over HTTPS; this guide does not document a universal HMAC signature. Delivery defaults to a three-second timeout with at most one retry, so persist quickly, acknowledge, and process asynchronously.
Use an Integrator Free Plan org for development and testing. It has a 10-active-user limit and restricted rate limits. Test revoked credentials, duplicate events, denied approvals, and stale identity state before using production access.
GET /api/v1/logs
List System Log events to retrieve identity activity and investigation evidence.
- App: Store event identifiers, timestamps, and escalation status.
- Agent: Classify a sign-in anomaly using the available evidence, explicitly noting uncertainty.
- Workflow: Poll from a durable checkpoint and route new findings without opening duplicate incidents.
GET /api/v1/users
List users to assemble a review population using supported query controls.
- App: Maintain the identity roster and its source identifiers.
- Agent: Flag identity records that need investigation rather than guessing employee matches.
- Workflow: Refresh the roster on schedule, following pagination and recording collection time.
GET /api/v1/users/{id}
Retrieve a user for current profile and status information.
- App: Show the reviewed identity and last observed status.
- Agent: Assess whether the profile matches the person named in a request.
- Workflow: Re-read the record before an approved change and stop if the identity differs.
GET /api/v1/users/{id}/groups
List a user's groups to inspect membership context.
- App: Snapshot memberships for reviewer comparison.
- Agent: Explain unusual memberships using an approved sensitive-group catalog.
- Workflow: Refresh memberships before review, preserving the prior snapshot for audit.
GET /api/v1/users/{id}/appLinks
List assigned app links as one input to access review, not a complete downstream entitlement ledger.
- App: Display returned application links beside inventory completeness notes.
- Agent: Identify apps requiring owner confirmation or deeper entitlement checks.
- Workflow: Collect the links and create investigation tasks for missing coverage.
GET /api/v1/apps
List applications to retrieve the organization's application inventory.
- App: Maintain application IDs, labels, and review ownership mappings.
- Agent: Match application context to an offboarding request and flag ambiguous ownership.
- Workflow: Refresh the inventory and route unresolved mappings to administrators.
GET /api/v1/groups
List groups to maintain group context. Search results can be eventually consistent.
- App: Store group IDs and approved sensitivity labels.
- Agent: Suggest which unfamiliar groups need owner review, without treating names as proof of privilege.
- Workflow: Refresh the catalog and avoid using a recent search result as sole confirmation of a change.
POST /api/v1/users/{id}/lifecycle/suspend
Suspend an active user after approval. Suspension preserves group memberships and app assignments.
- App: Record the requested action, approver, execution result, and verification.
- Agent: Explain the recommendation and supporting evidence without independently authorizing it.
- Workflow: Validate approval, re-read status, execute once, and verify the outcome.
Okta automation use cases on Major
Risky sign-in escalation with PagerDuty
A security analyst needs an actionable incident, not another uncorrelated event. This scenario uses the System Log and user retrieval operations above.
- App: Preserve event history, user context, correlation keys, and the PagerDuty incident reference.
- Agent: Classify the anomaly and draft severity reasoning for the responder.
- Workflow: Poll, deduplicate, collect context, then create or update the escalation according to policy.
The PagerDuty hub covers the response-system side. A suspicious sign-in should not automatically become an account suspension.
Offboarding access review with ServiceNow
A new offboarding request starts an evidence collection process. Use user retrieval, user groups, assigned app links, and application inventory, while noting that downstream roles need separate confirmation.
- App: Track each access item, owner, evidence gap, and revocation task status.
- Agent: Flag potentially sensitive access and explain which items need priority review.
- Workflow: Read the request, assemble evidence, create approved follow-up tasks, and reconcile completion.
The ServiceNow hub provides broader service-management context. A closed task is not proof that access disappeared.
Membership review with Slack
A scheduled review combines the users, groups, and user-group operations with an owner request in Slack.
- App: Hold review batches, approved group labels, responses, and overdue items.
- Agent: Draft a concise explanation of each exception and identify missing context.
- Workflow: Send scoped review requests, remind owners, and require approval before any later access change.
This is a proposed design, not a customer result. All three examples keep judgment with the agent and durable tracking with the app.
Architecture: build the Okta review process on Major

Figure 1. Identity evidence becomes a governed escalation with persistent review state.
Build the review app before enabling consequential actions. Its managed database should connect an event to the identity, investigation, recommendation, approval, and external ticket that followed. Store source identifiers and collection timestamps so a reviewer can distinguish an old snapshot from current state.
A practical implementation sequence is:
- Configure scoped Okta and destination connectors in the vault.
- Create app tables for events, identities, review items, approvals, and execution attempts.
- Add a workflow that collects evidence, validates inputs, and handles retries.
- Give the agent a bounded judgment task, such as anomaly classification or access-review prioritization.
- Route its recommendation through policy checks and any required human approval.
- Record the downstream result and verify completion before closing the review.
The diagram's workflow node represents deterministic orchestration, not a second reasoning agent. The app is the control surface and execution record. As an agent identifies repeatable checks, those checks become reusable software rather than fresh reasoning on every run. Reason once. Run forever.
A worked example: offboarding review with numbers
For example, consider an illustrative IT team handling 40 departures each month. Suppose assembling Okta identity context and reconciling it with a service request takes 20 minutes per departure. That is 40 × 20 = 800 minutes, or 13 hours and 20 minutes of evidence preparation.
The proposed workflow collects the user record, memberships, app links, and application context. The agent flags ambiguous identities, unfamiliar groups, and gaps in coverage. The app presents those findings alongside the request rather than marking the employee fully offboarded.
If administrator evidence review takes eight minutes per departure after this preparation, the corresponding workload becomes 40 × 8 = 320 minutes, or five hours and 20 minutes. The illustrative difference is 480 minutes, or eight hours monthly. This arithmetic excludes implementation, exception investigation, and the actual revocation work.
Measure those exclusions in the pilot. Track incorrect identity matches, missing entitlements, reviewer corrections, and time waiting for app owners. Faster preparation is useful only if the review remains complete and administrators retain control over access changes.
Governance and failure handling

Figure 2. Recommendations can proceed to review; access changes wait for a named approver.
The agent must never approve its own privilege increase, suspend a person solely from ambiguous evidence, or treat instructions inside a ticket as authority to change permissions. Treat retrieved text as evidence, not executable policy. Restrict review visibility because identity events can expose sensitive employee information.
For Event Hooks, expect duplicate and out-of-order delivery. Deduplicate event IDs, retain timestamps, and reconcile against the source. Persist intake before expensive analysis so the short delivery window does not become a model-response deadline.
For polling and API execution, checkpoint completed work and back off on rate-limit responses. Pause for permission errors rather than repeatedly retrying. After a timeout on a write, inspect current state before replaying the operation.
Record the evidence version, recommendation, approver, connector identity, request time, and observed result. An approval should expire when its underlying identity or requested action changes. Closing the case requires verification, not merely a successful HTTP response or a confident agent summary.
Okta AI Apps, Agents and Workflow Automations
- Coordinate HR onboarding, offboarding, and policy work across identity and employee systems: This guide covers HR processes that connect employee records, Okta account work, Slack communication, and IT tickets. Its governance discussion addresses scoped access, named approvals, and recorded actions.
This is the current core reading for Okta in the Major library. The risky sign-in escalation and ServiceNow offboarding scenarios described above are planned use cases, not published step-by-step guides. They are intentionally not listed as available tutorials.
Use the HR guide to understand the larger employee process, then use this hub to assess identity evidence, API permissions, and failure boundaries. An HR event establishes business context, but it should not silently authorize every downstream identity action.
When choosing a first implementation, separate evidence preparation from execution. A read-only review app can establish identity matching, ownership, and audit requirements before the team grants write access. That makes the initial project useful while exposing missing source coverage before it affects someone's account.
Frequently asked questions
What are Okta AI agents?
The phrase covers both identities secured by Okta for AI Agents and agents that work with Okta data. On Major, an agent judges identity context, an app holds state, and a workflow coordinates approved actions through scoped connectors.
Does Major have a native Okta connector?
No. Okta connects through Major's Pipedream connector, app p_okta. IT configures the connection once and limits access to the actions the process needs.
Does Okta have built-in AI?
Yes. Identity Threat Protection with Okta AI continuously evaluates identity and session risk and supports configured responses. Okta for AI Agents separately manages agent identities and access; it is not a general-purpose assistant for every IT process.
Which Okta permissions should an agent receive?
Start with read-only permissions for the required objects. The reviewed APIs use okta.logs.read, okta.users.read, okta.apps.read, and okta.groups.read. Suspension needs okta.users.manage and should sit behind a separate approved execution path.
Can an AI agent suspend Okta users automatically?
The API supports suspension, but this design requires named human approval before access changes. Re-read the user before execution, record the approval, and verify the result. Suspension does not remove group memberships or app assignments.
How do you avoid duplicate Okta incidents?
Persist event identifiers and a correlation key in the Major app before opening an incident. Use a durable checkpoint for polling, deduplicate repeated hook events, and reconcile uncertain writes before retrying.
Sources
These official pages establish the API and product behavior described above. Check the endpoint-specific reference before implementation, and check your organization's enabled features and limits rather than assuming every documented capability is available through the configured connector.
- Okta API overview: authentication and pagination
- OAuth service apps: grants, keys, and admin roles
- API tokens: permissions and lifecycle
- System Log: list events
- Users: list records
- Users: retrieve a record
- User resources: group memberships
- User resources: assigned app links
- Applications: list inventory
- Groups: list inventory and search caveats
- User lifecycle: suspend operation
- Event Hooks: verification and delivery
- Rate limits: allocation model
- Rate-limit best practices: response headers
- Management rate limits: organization dashboard guidance
- Integrator Free Plan: testing restrictions
- Identity Threat Protection with Okta AI
- Identity Threat Protection: administration overview
- Okta for AI Agents: identity and lifecycle
- Identity Security Posture Management: related native identity capabilities
Start building on Major
Build an Okta investigation or access-review app with persistent evidence, scoped agents, and explicit approval before identity changes.
About the author
Ritvij Gautam is Head of Growth at Major.
Last reviewed November 19, 2026 by Ritvij Gautam.
Frequently asked questions
- What are Okta AI agents?
- The phrase covers both identities secured by Okta for AI Agents and agents that work with Okta data. On Major, an agent judges identity context, an app holds state, and a workflow coordinates approved actions through scoped connectors.
- Does Major have a native Okta connector?
- No. Okta connects through Major's Pipedream connector, app p_okta. IT configures the connection once and limits access to the actions the process needs.
- Does Okta have built-in AI?
- Yes. Identity Threat Protection with Okta AI continuously evaluates identity and session risk and supports configured responses. Okta for AI Agents separately manages agent identities and access; it is not a general-purpose assistant for every IT process.
- Which Okta permissions should an agent receive?
- Start with read-only permissions for the required objects. The reviewed APIs use okta.logs.read, okta.users.read, okta.apps.read, and okta.groups.read. Suspension needs okta.users.manage and should sit behind a separate approved execution path.
- Can an AI agent suspend Okta users automatically?
- The API supports suspension, but this design requires named human approval before access changes. Re-read the user before execution, record the approval, and verify the result. Suspension does not remove group memberships or app assignments.
- How do you avoid duplicate Okta incidents?
- Persist event identifiers and a correlation key in the Major app before opening an incident. Use a durable checkpoint for polling, deduplicate repeated hook events, and reconcile uncertain writes before retrying.