App Identity
Goal: Give the apps you deploy a directory to sign people in, and decide what each person may do in them.
This window opens as a panel: it floats at the right at first, docks anywhere, and keeps your place when you move it. See Node editors and work windows as panels.
Sign-in for your own apps. "The directory that signs users in to the apps YOU deploy on this platform: an Azure AD B2C directory, or your company's own Azure AD. This does not change how anyone signs in to Open Industrial."
Before you start
- A connected cloud and a provisioned private landing zone. Until both exist the menu has no App Identity. The directory's client secret is kept in the landing zone's Key Vault.
- For the guided setup, a Microsoft sign-in that reaches your Azure subscription. The manual form does not need one.
- To change anything here you are the workspace owner or hold
Workspace.Access.Manage(see Rights).
What the window shows
The hero reads Configured once a directory is complete, otherwise Not configured. Below it, the window follows the last save live, then four tabs:
| Tab | What it holds |
|---|---|
| App Identity | Your directories: set one up, open one, connect apps to it |
| Access Rights | The rights your apps check, such as samples:receive |
| Configurations | Named bundles of access rights - the access a person can hold |
| Access Cards | The people in your directories, and the configuration each one holds |
The last three are disabled until a directory is complete, and say Configure App Identity first. Access Cards says Attach a directory first when a directory exists but is not whole yet.
On every workspace, a fifth tab, Platform apps, holds OpenX's own Entra apps in the workspace's company directories. It is where the owner accepts the OpenX AI app an AI proposed; see OpenX AI App.
The last tab, Publisher, shows whether Microsoft lists your organization as the verified publisher of each application OpenX created in your Microsoft directory; see Publisher.
Set up a directory
The App Identity tab lists your Directories, each with its kind (Azure AD B2C or Company Azure AD), its state (Ready or Needs setup) and Open. Add directory starts a new one; ← All directories brings you back.
The guided setup starts with Which kind of directory?:
| Choice | What happens |
|---|---|
| Azure AD B2C | Create a new B2C directory in your connected subscription (an Azure resource that bills), or point at one you already have |
| Company Azure AD | Choose your company directory from the ones your sign-in reaches |
Then Approve once in Azure, for the management app, and OpenX registers the sign-in app and reads it back.
The manual form
Before you fill this in lists what you must do in the Azure portal first. Then:
| Field | What it is |
|---|---|
| Provider Lookup | Your name for this directory. Set when it is created |
| Display Name | How it is shown |
| Tenant ID | The directory. Set when it is created |
| Domain | B2C only, for example contoso.b2clogin.com. Set when it is created |
| Policy Name | B2C only: the user flow or custom policy, for example B2C_1_signupsignin |
| Client ID | The app registration |
| Client Secret | Write-only. Never sent back to the page. Once stored, leave it blank to keep it |
Click Save Provider (or Update Provider for a stored one).
A configured directory
Opening a complete directory shows its facts (the secret is never shown) and what you can do with it:
| Part | What it does |
|---|---|
| Sign-in web addresses | The reply URLs to add to the directory's app registration in Azure, each with Copy |
| Connect your app | Type an App name and click Connect: OpenX creates the app's identity and shows, once, the settings to add to your app's environment |
| Signing key | For an app that runs its own sign-in server, such as an MCP door: Create signing key |
| Automated job identities | Identities for jobs that call your API without a person. Each job's row shows its Access cards; Change access cards and Save access cards change them, and "The job's next call gets the rights of these configurations." A job has at least one |
| Sign-in apps | Other apps in the directory whose sign-ins your API accepts: Register a sign-in app, Revoke. Trust only, an app carries no rights of its own; its people call on their own access cards |
| Configure for app calls | Lets apps call your OpenX API with this directory's tokens. OpenX adds this workspace's own scope to the directory's sign-in app for you (see One token opens one workspace) |
| Edit these details | Opens the manual form for this directory |
| Add another directory | Starts a second directory |
| Run Set up again | Shown when the directory's setup key is not stored in this workspace, so its users cannot be listed |
The client secret an app receives when you connect it is shown only once.
One token opens one workspace
Each workspace has its own scope on the directory's sign-in app, named ws. followed by the workspace id. A
person's token opens only the workspace whose scope the sign-in asked for, even when several workspaces share
one sign-in app. A token asked for another workspace's scope is refused here.
| Directory | The scope your app asks for |
|---|---|
| Company Azure AD | api://<client id>/ws.<workspace id> |
| Azure AD B2C | https://<tenant>.onmicrosoft.com/<client id>/ws.<workspace id> |
| Any other OpenID directory | ws.<workspace id>, which the directory's owner publishes as a scope |
- Configure for app calls adds the scope and records it; the step then shows the exact scope. An app asks
for it when it signs a person in, beside
openid(andoffline_accessfor Azure AD B2C). - Azure AD B2C has no user consent: a directory admin grants it with the one-click link the window shows, and uses that link again for each workspace added to the same sign-in app.
- A directory set up before scopes were per workspace shows "Run it again". Its people's tokens are refused until OpenX adds this workspace's scope, which the next save or Deploy does. Jobs keep working meanwhile.
- This sign-in app is full. One sign-in app holds a scope for as many workspaces as Microsoft allows (about 30 on Azure AD B2C, far more on a company directory). Past that, the window says so and walks you through it: add another App Identity for the same directory and leave its client id empty, so OpenX registers a new sign-in app, then choose Configure for app calls on it.
The scope says which workspace a token is for. It does not say who may use it: anyone who can sign in to the directory can ask for any workspace's scope. What a person may do is decided by their access cards in that workspace, below.
Access Rights, Configurations and Access Cards
| Tab | Fields and buttons |
|---|---|
| Access Rights | New Access Right: Lookup Key, Name, Description, Tags, Enabled; Save, Cancel, Delete |
| Configurations | New Configuration: Lookup Key, Name, Description, Linked Access Rights; Save, Cancel, Delete |
| Access Cards | Refresh, Find a person, and per person Choose an access configuration, Assign, and a remove mark on each card |
"People from your App Identity directories who can sign in to the apps you deploy, and the access configuration each one holds. Access follows the email, so someone found in two directories is one row, and assigning gives them that access in each directory. They do not need to be team members of this workspace."
A person with no sign-in name in the directory cannot be given access here, and is listed as such.
A new workspace starts with no configurations and no cards here, so nobody holds a right through App Identity yet. Before teammates, or your apps and agents, can read tables through App mode, an owner builds a configuration and assigns it. A workspace that already holds an Administrator configuration keeps it, and the people holding its card keep its rights.
Publisher
When someone is asked to consent to an application, Microsoft shows whether its publisher is verified. The Publisher tab lists every application OpenX created for this workspace in your own Microsoft directory: the OpenX Mail applications, the vault readers, the workspace sign-in app, the shared management app, the job identities, the OpenX AI sign-in app and the Cloud Connect app. Applications in Fathym's own directory are not listed. OpenX finds each one by the tag it put on it or the id it recorded, never by its name.
Enter your Partner ID once at the top (digits only; see Getting a Microsoft Partner ID). OpenX keeps it only while the window is open. Then each row offers what fits its state:
| Pill | What the row says | What you can press |
|---|---|---|
| Verified | "Microsoft shows" your publisher name "as the verified publisher." | Undo |
| Not verified | "People asked to consent to this application see it as unverified. Enter your Partner ID and press Verify." | Verify, once the field holds digits |
| Could not read | "OpenX could not read this application's publisher from Microsoft." or why | Nothing; reopen the window to read again |
| Not available | "Microsoft does not verify publishers in Azure AD B2C directories." | Nothing |
After Verify, OpenX reads the application back from Microsoft and shows Verified only when Microsoft says so. A refusal shows on that row only, and nothing changed. If Microsoft says you are not an administrator of the directory, the row offers Email it, Copy it and I've sent it, with text that names the application, your Partner ID and where to add it in Microsoft Entra.
Only the workspace owner or someone with Workspace.Access.Manage sees this tab's rows. Verifying also needs
the Microsoft roles listed in Getting a Microsoft Partner ID.
| When | Message |
|---|---|
| A Partner ID with a letter | "A Partner ID is digits only." |
| Microsoft could not be reached | "OpenX could not reach Microsoft to change the publisher. Nothing changed. Press it again." |
| The list could not be read | "OpenX could not read your applications' publishers just now. Close and reopen this window to try again." |
| No applications yet | "OpenX has not created an application in your Microsoft directory yet." |
Save and Deploy
| Action | When it takes effect |
|---|---|
| Save Provider / Update Provider | At once: the save sets the directory up in Azure, and the window follows it |
| Connect | At once: the app's identity is created and recorded |
| Configure for app calls | At once: OpenX configures the directory, then records it |
| Create signing key | On the next Deploy ("Signing key: being created on the next Deploy") |
| Access rights, configurations and access cards | When saved - no Deploy needed |
A green save means the directory is stored; the window says when setup in Azure has finished.
Rights
Everything that changes this window - saving a directory, connecting an app, creating a signing key,
configuring app calls, and changing access rights, configurations or cards - needs the workspace owner or the
Workspace.Access.Manage right. Nobody can change their own access, and the last access configuration that
grants a platform administrator cannot be removed or emptied.
Thinky and agents
Thinky and agents can propose a directory - its name, tenant, domain, policy, client id, scopes and reply URLs, a request to configure app calls, and a signing key for an app already connected - but never the client secret. An accepted directory proposal lands as a draft: "Everything else is already filled in. The client secret is the one value an agent is never permitted to send, so it is the only field left for you." Enter it and save.
Access rights and configurations can be proposed too, and they show in this window (Proposals in this window, below). A job identity proposal is accepted in this window, and accepting it creates or revokes the identity in your directory straight away.
Proposals in this window
The window shows what has been proposed for it, so you do not have to find it in the Proposals panel first.
- A count on the tab. The App Identity, Access Rights and Configurations tabs each wear the number of proposals waiting for them, beside their label. A tab with nothing waiting shows no number.
- A line over the list. Access Rights and Configurations open on "2 changes proposed by Claude" (the name of whoever proposed them) with Review, which opens the Proposals panel.
- The proposals come first. Each waiting proposal is a row above your stored rights, marked Proposed new or Proposed change, with Accept proposal, Reject proposal and Edit. They are never mixed in among the rights you already have.
- One proposal covers its whole bundle. A proposal arrives with the other changes it was made with, some of them in the other list. Accept proposal and Reject proposal act on all of them, and the list says so when that is the case.
- Edit opens the proposal in the form. The form comes into view and the cursor waits in its first field. It says who proposed it and that nothing changes until you accept it, and its buttons are Accept proposal, Reject proposal and Cancel. There is no Save on a proposal: your edits are kept in the proposal and stored when you accept it. A right you already have still opens a form with Save.
Accepting a proposal stores the records; it does not deploy anything. Deploy as you would after a change you made yourself.
Giving a job more access
A change that gives a job a right it did not have, or changes how it signs in, asks you to sign in again first. This applies to Save access cards and to accepting a proposed update. A change that adds no right, such as removing a card or changing a lifetime, goes straight through.
- OpenX sends you to its own sign-in. This is your OpenX login, not the directory this window manages. Nothing has changed yet.
- Sign in. You come back to your workspace, and App Identity opens by itself.
- OpenX makes the change you asked for, once, and shows the result at the top of the window.
If it does not finish, nothing was changed:
| When | What you see |
|---|---|
| You left the sign-in without finishing | "The sign-in did not finish, so this change was not accepted." |
| OpenX could not confirm your sign-in | "The fresh sign-in was not confirmed, so this change was not accepted. Try again." with a code beside it |
| OpenX asks again after you signed in | "You signed in again, but OpenX still asks for a fresh sign-in, so this change was not accepted. Try again." |
| Your browser blocks this tab's storage | "A fresh sign-in cannot be started from this window, so this change was not accepted." |
Reloading the page after you come back does not make the change a second time.
Any workspace member can accept a proposal; some changes (access, licenses, connected-app requests) need a management right.
Messages you may see
| Code or place | Message |
|---|---|
PRIVATE_LANDING_ZONE_REQUIRED | "This needs a private landing zone, which this workspace does not have yet." |
| Saving without the right | "Only a workspace owner or an access admin can manage connected apps." |
ACCESS_MANAGE_REQUIRED | "Only the workspace owner or someone with the 'Workspace.Access.Manage' right can change a user's access." |
SELF_GRANT_REFUSED | "You cannot change your own access. Ask another access admin to make this change." |
| Connecting with no landing zone vault | "This workspace has no landing zone yet, and the app reads its settings from the landing zone Key Vault. Provision one in Cloud, then connect the app." |
| Connecting after the sign-in expired | "Your Azure sign-in has expired. Sign in again and connect the app." |
| This sign-in app is full | "This directory's sign-in app already holds a scope for as many workspaces as Microsoft allows on one app, so OpenX could not add this workspace's own scope, and nothing was changed." Follow the steps the window shows |
| The form | A B2C directory needs its tenant, domain and policy together; a company directory has no domain or policy; a new directory needs its client secret |
Next steps
- Use a directory's tokens for API calls -> API Manager
- The app the AI's Azure sign-in uses -> OpenX AI App
- Who accepts what -> Team Review & Access Rights
- The order things unlock in -> Cloud
On fathym.com: OpenX App Identity →