The platform
One architecture,
layer by layer.
ID Check Globe is a tenant-aware identity platform: a record of every principal you need to authenticate, a standards-based authentication layer in front of it, connections out to the directories and identity providers you already run, a lifecycle for the keys and credentials involved, and a signed trail of everything that happened. This page walks that architecture from the outside in — including the three places it deliberately stops.
Layer one
Tenancy is the outermost boundary.
Before anything authenticates, something has to own it. Every identity record, application, connection and key in the platform sits inside exactly one tenant and one environment, and inherits that boundary rather than carrying its own.
Tenant
The outermost boundary. A tenant owns its identity records, applications, connections, signing keys and event history. Nothing crosses a tenant edge unless you configure a connection that makes it cross, and that configuration is itself a recorded change.
Environment
Development, staging and production are separate inside a tenant. Clients, secrets, signing keys, connections and webhook endpoints all belong to one environment, so a test integration cannot mint a token your production API will accept.
Brand login domain
A brand gets its own login domain, theme, localization and legal text without getting its own authentication stack. One engine, one key lifecycle, one event stream, several front doors.
Regional configuration and retention settings are tenant-level choices, as are administrator roles and configuration export. A group running several products shares one authentication engine across them without flattening the boundaries between them — which is the difference between shared infrastructure and a shared customer list.
Layer two
Six kinds of principal, one record shape.
Everything the platform authenticates is a principal: an identifier, a set of credentials, a lifecycle state and an accountable owner. The kinds below differ in the evidence that establishes them, not in how they are stored or how they prove themselves later.
People
Customers, employees, contractors and partners. Established by registration and, where the risk warrants it, by identity proofing.
The serviceOrganizations
Customer companies, departments and business partners. Established by domain verification or business verification, and connected to the people who are members of them.
The serviceApplications
Web, mobile, server-side and desktop clients. Each carries a client type, registered redirect URIs, an issuance profile and its own credentials per environment.
The serviceMachines and workloads
Services, background jobs, containers and connected devices. These hold keys rather than passwords, and are bound to an environment and a deployment.
The serviceAI agents
Autonomous software with its own identifier and keys, bound to the organization that operates it and to the person accountable for it.
The serviceCredentials
Not a principal, but a first-class record all the same: a signed statement about one of the above, with an issuer identity, a schema, a status and an expiry.
The serviceRelationships are records too.
Most identity questions worth asking are about a relationship rather than a single account. Each of the three below is stored as a claim with its own evidence, its own status and its own history, so a verifier can check the relationship instead of inferring it from a name.
- member of
- A person belongs to one or more organizations, with the attributes and group claims that membership carries.
- operated by
- An application, workload or agent is run by a named organization, which is who a verifier is really asking about.
- represents
- A principal acts for another, under signed delegation evidence that is scoped and time-limited.
Layer three
Flows, factors, sessions, tokens.
The authentication layer turns a request into a verified principal. Four things make it up, and keeping them separate is what lets a passkey, a client assertion and an agent key signature end at the same place: a signed statement about who or what just proved itself.
Flows
OpenID Connect authorization code with PKCE for interactive sign-in. Client credentials and signed client assertions for non-interactive callers. Challenge-response against a registered public key for machines and agents. Use hosted screens, embeddable components or the APIs directly — the flow underneath is the same one, and so is the record it writes.
Hosted authentication and UIFactors
A factor is a discrete piece of evidence registered against a principal, enrolled and revoked independently: a passkey, an authenticator-app code, a device-bound key. Enrolment and recovery are designed as one journey, because recovery is where identity systems quietly fail and where an attacker will look first.
Passwordless and passkeysSessions
A session is an explicit record you can list and end — for one device, one application or the whole tenant. Reauthentication policy decides when an existing session is no longer sufficient evidence for what is now being attempted, which is an authentication question rather than a permission one.
Session and token lifecycleTokens
ID tokens describe the principal that authenticated; access tokens are what your APIs receive. Both are signed with keys published at a discovery endpoint, so any service can verify one without calling back to us. Refresh handling, rotation and revocation are set per issuance profile rather than per application by hand.
APIs, SDKs and webhooksRisk signals — a new device, an unusual login pattern — feed one decision only: whether to ask for more evidence before accepting that this is the principal it claims to be. See multifactor and adaptive authentication for how that is configured, and customer identity or application authentication for the two journeys this layer is asked for most.
Layer four
Connections out to the identity you do not own.
Your enterprise customers already have an identity provider, and your organization already has a directory. The federation layer exists so that each application does not have to integrate with all of them separately.
Federation
Route the sign-in, keep the record.
- Inbound OpenID Connect and SAML 2.0 connections, per tenant and per customer organization
- Organization-aware provider discovery, so a sign-in lands on the right enterprise connection
- Claims mapping and deliberate identity linking, rather than silent account merging
- Federation metadata, certificate publication and key rollover
- Login route diagnostics for the connection that worked yesterday and not today
Directories and provisioning
Keep the records aligned over time.
- SCIM 2.0 provisioning interfaces for inbound and outbound synchronization
- Directory import, reconciliation and reporting on what did not match
- Joiner, mover and leaver events published as they happen
- Attribute transformation and mapping between systems that disagree about names
- Deprovisioning that propagates, with a record of where it reached
An honest note on protocol translation
Translation between protocols happens where the semantics genuinely map. A SAML assertion and an OpenID Connect ID token are not interchangeable in every detail, and some claims have no faithful equivalent on the other side. Where that is the case the platform surfaces the gap at configuration time rather than quietly inventing a value — which is also why workforce identity is a solution page and not a checkbox.
Layer five
Every credential has a beginning and an end.
Passkeys, client secrets, signing keys, device certificates and agent keys all follow one lifecycle. Static credentials that nobody can rotate are the most common failure in machine authentication, so the sequence below treats rotation and retirement as ordinary operations rather than incidents.
01
Enrol
A key, certificate, passkey or client secret is registered against a principal. Proof of possession at enrolment is what makes the record worth anything afterwards.
02
Bind
The credential is tied to a tenant, an environment and, where it applies, a deployment or a device. A credential that works everywhere is a credential nobody can reason about.
03
Present
Public key material is published for verifiers; private material stays where it was generated. Verification checks the signature, the issuer, the key state and the status.
04
Rotate
Overlapping validity windows let a new key start being accepted before the old one stops, so rotation is a scheduled operation rather than a coordinated release across every application.
05
Revoke or expire
Expiry is scheduled and monitored ahead of time. Revocation is immediate, recorded, and checkable by whoever was relying on the credential.
06
Retire
The record outlives the credential. Answering what a retired key was used for matters more, later, than knowing that it is gone.
What this is not
This is the lifecycle of credentials that establish identity, tied to the person, application, workload or agent that controls them. General-purpose secrets storage for everything else your systems hold — database passwords, third-party API keys, encryption material — belongs to a secrets management and infrastructure platform.
Layer six
Everything above emits an event.
Each layer writes a signed record of what it did. Those records are the operational picture while something is happening and the evidence trail afterwards, and they are the same records either way — an audit log assembled after the fact is not evidence of anything.
- Authentication attempts, factor challenges, session creation and termination
- Credential enrolment, rotation, revocation and expiry
- Verification outcomes, with the evidence held separately from the result
- Directory and organization lifecycle changes
- Configuration changes to tenants, applications and connections
Events reach your systems as webhooks with signature verification, and leave the platform as exports when a review or an investigation needs them. Retention and privacy controls are configured per tenant, because keeping identity evidence longer than a purpose justifies is its own risk.
The edges
Where this platform deliberately stops.
A platform that claims everything adjacent to identity ends up vague about the part it actually does. Three boundaries are drawn on purpose, and each one is a capability you will own somewhere else in your architecture.
Authorization
The platform establishes who or what is making a request and hands your application a verified principal with the claims you asked for. Whether that principal may perform a particular action is a separate decision, owned by the consuming application or by a dedicated authorization layer that holds the policy. We do not make that decision and we do not imply that we do.
Agent orchestration
An agent gets an identity here: an identifier, keys, an operator relationship and verifiable delegation evidence. Designing the agent, giving it tools, running it and listing it somewhere it can be discovered belong to an agent platform. Identity is the part other organizations have to be able to check independently.
Infrastructure and hosting
Your applications run wherever you run them. This platform is reached over its APIs and hosted flows; it does not host your workloads and it is not where your application data lives. General secrets vaulting, endpoint protection and runtime security stay with your infrastructure and security platforms.
The first of those three is the one worth repeating: authentication establishes who or what is making a request; authorization decides whether that principal may perform a particular action. This platform does the first thoroughly and hands the result over with the claims your policy needs. Read the trust centre for how that handover is designed and what we will and will not say about it.
The catalogue, by layer
What sits in each layer.
The architecture above is implemented by the service families below. Start with the one service your product needs now; the layer it belongs to is already there when you need the next.
Authentication layer — people
Customer identity and authentication
Signup, login, recovery and session control for the people who buy from you.
Federation and directory layer
Workforce and enterprise identity
Employees, contractors, business customers and the organizations they belong to.
Authentication layer — software, APIs and keys
Application, API and machine identity
Identity for the software itself — applications, services, workloads and devices.
Evidence and credential layer
Verified people, organizations and credentials
Evidence that an account belongs to a real person or a real company, and credentials others can check.
Portable trust and the event trail
AI agent identity and decentralized trust
Verifiable identity for autonomous software, and identity that travels between organizations.
Tenancy, interfaces and operations
Platform, administration and developer services
The tenancy, interfaces and operational tooling the rest of the catalogue runs on.
Read the architecture. Then build against it.
Start with the APIs and a sandbox tenant, or talk the whole thing through first — tenancy, federation and credential lifecycle are easier to get right in a conversation than in a migration.
Identity for everyone. Trust for everything.