One Word. Full Governance.
Custom Commands Turn Domain Knowledge Into Governed Automation.
Your best operators workflows live in their head. When they leave, the knowledge leaves with them. IdentityRM lets customers encode domain knowledge into governed commands that anyone can run. No coding. No runbooks. One word.
"A portal takes 7 steps and a specialist. A prompt takes one sentence. A governance command takes one word. Each layer eliminates not just time, but the need to know how the systems work underneath. That is governed speed."
— Martin Gee, Founder & CEO, IdentityRM
Your best operator knows how to onboard a Seattle vendor in 4 minutes. They know which systems to hit, which scope to set, which approvals to skip for standard tier.
That knowledge lives in their head. Maybe in a runbook — if you are lucky.
When they leave, the runbook becomes archaeology. The next operator reads it, guesses, gets it wrong, opens a ticket. The one after that skips the runbook entirely because nobody told them it existed.
This is the bus factor applied to governance workflows. And every enterprise has it.
What if the workflow itself was a product — governed, reusable, and available to anyone with the right persona?
The Prompt Advantage
The first step is replacing the portal with a prompt.
Instead of navigating a custom-built vendor admin screen — the one that only Dave understood, the one nobody maintains anymore — the operator just says:
“Provision Acme Corp vendor accounts for the Seattle distribution partnership.”
IdentityRM resolves intent, checks scope, delegates authority, logs the decision. Four seconds. Every step governed. Full decision trace.
A Stanford study confirmed speech is 3x faster than typing. Your prompt-based interface is not just simpler — it is physically faster to operate. Operators dictate a sentence in 3 seconds that would take 10 to type.
But the prompt still requires the operator to know the workflow — what to ask for, how to phrase it, what scope applies. A new hire stares at the prompt the same way they stared at the portal. The input is faster. The knowledge requirement is identical.
The prompt eliminated the portal. It did not eliminate the knowledge requirement.
That is what commands do.
Governance Commands
Here is the reveal: customers can create their own commands that chain governance operations into a single governed workflow.
No code. No orchestration framework. No YAML pipeline. Just a command definition that encodes what your best operator already knows:
That is the entire definition. A customer admin creates it in minutes. No developer involved.
Now watch it run:
resolve_partner
→
Acme Corp → Standard Tier
check_scope
→
Operator authorized for Seattle vendor delegation
delegate_authority
→
Standard Vendor role, scope: Seattle, 90-day review
log_decision
→
Decision trace #DT-5102 recorded
One word triggered four governed operations. All persona-scoped. Full decision trace. The operator did not need to know which systems are involved, which API to call, or what scope rules apply. The command encoded that knowledge. The platform enforced the guardrails.
The Dave Problem — Solved at a New Level
Remember Dave? The operator from Boulevard of Broken Dreams who left in 2023 and took the portal knowledge with him?
Dave’s runbook becomes a command. Dave leaves. The command stays. Anyone with the Partner Admin persona runs it. The knowledge is not in Dave’s head — it is in the platform.
But this goes further than preserving Dave’s knowledge. Commands compound. The vendor onboarding team creates /onboard-seattle-vendor. The compliance team creates /quarterly-vendor-review. The offboarding team creates /offboard-vendor-cascade. Each command encodes a different specialist’s knowledge. Together, they form a governed library of institutional workflows that survives any single departure.
The command does not bypass governance. It rides on top of it. Same persona-scoping. Same decision traces. Same audit trail. The speed comes from encoding the workflow, not from skipping the guardrails.
Think of it as a governed macro. The command encodes what to do. The platform enforces who can do it, to whom, and within what scope.
The Guardrail Inversion
Same command. Different operator. Different result.
Same command. The persona determines what happens.
This is the inversion. Governance is not a constraint that slows you down. It is the rails that let you go faster. Without guardrails, every command would need manual scope verification — a human checking that the operator should be doing what they are doing. With architectural guardrails, operators run commands at full speed knowing the boundaries cannot be crossed.
| Runbook | Orchestration Layer | Governance Command | |
|---|---|---|---|
| Who creates | The specialist | A developer | Any admin — no code |
| Who can run | Whoever finds it | Systems it is wired to | Anyone with the right persona |
| Guardrails | Hope and documentation | Hardcoded in the workflow | Architectural — enforced per persona |
| When Dave leaves | Knowledge walks out | Code rots without maintainer | Command stays. Governance stays. |
Orchestration layers encode workflows. IdentityRM encodes governed workflows. The governance is not overhead. It is the product.
One Word
Portals required training. Prompts require intent. Commands require one word.
Your fastest operator on Day 1 is faster than your specialist was on Year 5 — because the specialist’s knowledge is encoded in the command, and the guardrails are architectural. The compounding effect is real: every command created is institutional knowledge preserved, every correction improves the underlying model, every new persona-scoped variant extends the library without duplicating logic.
Stop building orchestration scaffolding. Start encoding governance.
IdentityRM lets customers create governed commands — no code, no orchestration frameworks, full persona-scoped enforcement. See the platform or request a demo.
