OpenAI’s 1.2 Billion Users Put Identity Infrastructure in the Critical Path

OpenAI’s reported 1.2 billion weekly active ChatGPT users put identity checks in the same conversation as inference capacity. Every request needs a trusted identity, valid credentials and permissions; for agent systems, that work can multiply as one user prompt triggers many service calls.
The figure, announced at DevDay and described as roughly 15% of the world’s population, raises a practical architecture question: can authentication keep pace when the caller is software making rapid, chained requests? OpenAI uses Ory’s authentication and OAuth2/OIDC infrastructure, according to the source report. The arrangement points to identity as a distributed systems concern, not merely a login feature.
Agent workflows multiply authorization traffic
A person may make one request through an interface. An agent responding to that request can run dozens of subtasks, query databases and call external tools. Each operation needs authorization, so token checks can grow much faster than the number of human interactions.
That pattern puts pressure on identity providers that validate tokens through centralized network calls or database lookups. At high request rates, each round trip adds latency and can compete for database capacity. Authorization then risks slowing the workload it is meant to protect.
One response is to verify signed tokens close to the workload. With cached JSON Web Key Sets (JWKS), services can perform cryptographic checks locally instead of contacting a central provider for every request. This stateless approach can reduce network dependencies on the request path, while session and permission decisions still need careful design.
Where composable identity changes the trade-offs
Traditional identity SaaS products, including Auth0, Okta and Ping Identity, are often compared with self-hosted, composable systems such as Ory. The difference is less about a single feature than about who controls the runtime, data and scaling model.
| Architectural dimension | Legacy monolithic identity SaaS | Self-hosted composable IAM (e.g., Ory) |
| Token validation mechanism | Centralized IdP round-trips or heavy server-side SDKs | Edge-native stateless JWT validation & local session caching |
| Data residency & ownership | User store hosted in vendor-managed SaaS clouds | Complete data sovereignty (runs directly in your VPC / multi-cloud k8s) |
| Database persistence strategy | Proprietary SaaS database clusters subject to vendor rate limits | Highly available distributed SQL layers (e.g., CockroachDB, Spanner, Postgres) |
| Cost scaling model | Per Monthly Active User (MAU) or per-API request execution fees | Infrastructure-based scaling; cost correlates with compute/memory footprint |
| Customizability & velocity | Restricted to vendor webhooks, rules, or custom code sandboxes | Go-native microservices with clean API boundaries and headless UI integration |
Self-hosting can give teams direct control over identity data and let infrastructure costs track compute and memory use. It also places operating and scaling responsibilities with the engineering team. Ory’s services can be split by function and run in a team’s own cloud environment, while vendor-hosted platforms keep more of the identity stack under provider management.
“OpenAI wanted a partner that could help enable our vision for owning our identity processes, data, and success. We have a lot of partners, and Ory is one of our best.”
- Benjamin Billings, Engineering Manager, OpenAI (Case study)
Designing identity for distributed workloads
High-throughput systems benefit from separating identity functions that monolithic applications often combine. Ory’s product set illustrates the pattern: Kratos handles identity and credentials, Hydra provides OAuth2 and OIDC flows, and Keto evaluates fine-grained access relationships using a model based on Google Zanzibar.
Storage is another part of the design. Globally routed services need local reads and reliable writes across regions. Pairing self-hosted identity services with distributed SQL systems such as CockroachDB, Spanner or multi-region cloud databases can support replication across locations. The source report presents this as a way to limit cross-region latency and avoid conflicting state.
Agent permissions add a separate challenge. Applying restrictive policies before teams understand what agents actually do can interrupt valid workflows. An observe-first rollout gives operators a chance to map machine credentials, trace tool calls and review database access before enforcing tighter controls.
- Identify agents: Inventory machine-to-machine credentials and service accounts used by agent runtimes.
- Trace activity: Record the tools, APIs and databases agents access.
- Constrain delegation: Use OAuth2 Token Exchange (RFC 8693) to give an agent scoped permissions linked to the human who delegated the task.
For a limited time, Ory offers a complimentary account with an observe mode for reviewing agent activity.
Identity becomes part of capacity planning
OpenAI’s reported user count makes the scale visible, but agent execution changes the underlying workload: a single human action can create many machine requests, each with its own authorization needs. Teams should measure that request amplification and account for identity checks when planning latency and capacity.
Decoupled services, local token verification and distributed persistence can help keep authorization out of the bottleneck position. The practical test is whether an identity architecture can support fast, traceable decisions as software shifts from people clicking through interfaces to agents acting on their behalf.
The post From human clicks to agentic velocity: What OpenAI’s 1.2 billion scale means for your auth appeared first on The New Stack.