Fragmented identity
One agent typically holds three or four identities at once. Auditors stitch traces by timestamp.
Agentic Governance™ with Authority Finality™
Before your AI agent acts,
one API call proves it was allowed.
Was the action allowed? Can you prove what happened? Did it close cleanly? The KYE™ Authority API answers all three on every consequential action (allow, deny or require approval) and returns a signed receipt your auditor can verify offline, years later.
Know Your Entity™ at t=0: identity asks who; KYE™ proves whether it was allowed, the instant the action forms.
- Identity
- On-behalf-of
- Authority
- Scope
- State
- Audit
- Evidence Pack™
- Replay
- SDKs
- MCP Server
Authority Finality™: KYE Protocol™ enforces authority while the action is forming: it refuses out-of-scope AI-agent action before the side effect commits, and every refusal and approval is signed, replayable and verifiable offline.
AgentCredit decisioning agent
Decision: allow
- 1Identity: kye:agent:…:credit-07 resolvedDone
- 2On-behalf-of: Priya Shah, chain intactDone
- 3Authority: delegation activeDone
- 4Scope: £4,200 within £25,000Done
- 5State: entity active, risk nominalDone
- 6Evidence Pack™ sealed, Ed25519Done
0Questions per action
0Outcomes
0SDK languages
Built for the people who must answer who authorised the agent
CISOsCFOsGeneral CounselDPOsAuditors and GRCRegulatorsBuildersPartners and trainersBanks and regulated institutions
Why it exists
None of those is authority.
Observability, a trace, a permit, an identity, an API key, a guardrail: each proves something real (that an agent exists, that it behaved, that a rule was checked). None proves the institution empowered it to cause the effect.
Static authorisation
OAuth scopes describe state at issuance, not state now. Revocations don't propagate; a compromised agent keeps acting until the next review.
Unprovable history
Audit logs are vendor-specific. The decision, the inputs, the obligations and the cascade are not portable.
Fragmented ownership
Responsibility split across IT, data science, business lines and control functions, without a clear accountability framework.
Protocol, not product
The authority protocol
the rest of your stack builds on.
KYE Protocol™ sits above your agents, beneath your execution, and across every model, sector and jurisdiction: model-agnostic, vendor-agnostic, framework-agnostic. One engine; your packs, agents and surfaces are projections of it. Every action runs in one of three modes:
- 1Shadow Mode™
- 2Enforce
- 3Replay
- Entity admitted
- Delegation granted
- Scope declared
- Decision at t=0
- Evidence Pack™
- Shadow Mode™
- Audit Pilot™
- Enforce
- Replay years later
Three questions you can't answer today
Authority, evidence, finality, on every AI action.
Authority: was this allowed?
Stop an unauthorised AI action before it commits, not after the regulator asks. Authority is traced across the whole chain and is jurisdiction-aware.
Evidence: can you prove it?
Each decision is sealed into a signed record anyone can verify offline, from published keys alone. Nothing is asserted that isn't proven.
Finality: did it close?
High-stakes actions can require a second approver, or be held from becoming final until authority is re-anchored. Contestable later, never deniable.
Revocation that cascades
Revoke a parent and the cascade reaches every child grant before the response to the originating request returns.
One durable identity
One URN names every actor (human, business, service, AI agent, model, tool, workflow) and binds it to a public key.
Still true later
The pack carries the version of your estate the decision was judged against, so a rename years later cannot rewrite what the record means.
Where this applies to you
Each role gets the answer it is asked for.
Choose your role.
For CISOs
Runtime authority checks on every consequential agent action, Shadow Mode™ before you enforce, and a Rules Gateway™ in front of your stack.
For CISOsFor CFOs
Value-based pricing: start free, prove it with an Audit Pilot™, then scale. The evidence that turns exam questions from days into one pack.
For CFOsFor General Counsel
Authority Finality™: a replayable proof layer for accountability, dispute resolution and legally defensible audit trails. KYE™ does not replace legal agreements or signatures.
For counselFor auditors and GRC
Evidence Packs™ you verify offline from published keys, with the control behind each claim mapped to the frameworks you test against.
Auditor firm onboardingFor regulators
Decisions sealed at t=0 that a supervisor can replay, with the estate as it was, not as it is now.
For regulatorsFor builders
One API call per action, SDKs in TypeScript, Python and Go, the CLI and the KYE™ MCP Server™.
Developer portalFor DPOs
Purpose Permission™: every action is bound to the purpose it was granted for, and an action outside it is refused at the boundary.
For DPOsFor partners
KYE™ Inside: sell authority to your own customers without building a governance engine; multi-tenant and under your brand.
Partner programOne authority hub
Six questions answered on every action, and what is built on them
Select a module to see its lifecycle.
The mechanism
From black box to Evidence Pack™
An agent proposes a consequential action.
It enters the rail before anything irreversible happens.
ExampleCredit decisioning agent: approve a £4,200 credit line (demo)
OutputSubject URNActionPurpose
Policy evaluates the request.
Rego, Cedar, or custom policy evaluates the request against your rules: deny, allow, or escalate.
ExampleRetail credit policy, GB and IE only
OutputPolicy resultObligations
Context is verified at the edge.
Identity, data classification, and jurisdiction are verified at the edge before authority is granted.
Examplejurisdiction GB · data class personal · entity active
OutputAllowRequire approvalDeny
The decision is bound to its proof.
HSM-ready signing binds the decision to its proof; the Evidence Pack™ is an offline-replayable, tamper-evident archive.
Examplekye:decision:9f3ac1 · Ed25519
OutputReceipt→Evidence Pack™→Verifiable offline
Start where you are
Eight ways in, one authority engine underneath.
The runtime that checks authority, seals evidence and reaches finality.
Runtime gatewayDecision engineSDKsOpenAPIKYE™ MCP Server™
Governed surfaces you can adopt today.
GovernedUI™WidgetsGoverned Agents™Rule packsAgent Dev Kit™
Prove it to your auditor.
Framework coverageAssurance CardCompliance CardOSCALEvidence export
Pilot, partner, get certified.
Audit Pilot™Proof of ConceptPartner ProgramSector Pack Foundry™Certification
Try it free, right now.
Authority Risk ProfilerAuthority DiagramReadiness self-testSandboxKYE™ Lens™
Your sector, governed.
Financial services
Banks and regulated institutions whose supervisor is already asking who authorised the agent.
Open banking
Agent actions on accounts and payments, each checked against delegated authority.
Clinical AI
Governed AI over personal health information, with break-glass and evidence.
Legal
Dispute resolution and the agent as contracting party.
Public sector
Sovereign AI profiles per region: UK, EU, US, Gulf, Canada, Australia, Singapore, New Zealand.
Insurance
Underwriting and claims authority, refused before the side effect commits.
An empty sandbox is not enough
Start with fictional data from day one.
The terminal and the lab come with fictional tenants, agents, delegations and decisions, so you can see the authority engine work in the first minute.
Authority has a lifecycle
Admit, delegate, scope, decide, seal, replay, revoke.
Select a stage to see what happens in it.
Shadow Mode™ first
See the refusals before production does.
Choose a run mode and a scenario, and watch the decision and the evidence respond.
Scenario
- Choose a scenario and press "Run scenario".
Use cases
Two examples, from request to Evidence Pack™
Credit decisioning
A bank lets a credit agent approve retail credit lines within delegated authority.
- Entity admitted
- Delegation granted
- Scope declared
- Decision: allow
- Above threshold: require approval
- Head of Credit approves
- Evidence Pack™ sealed
- Replay verified
- Platform
- Runtime authority API
- Identity
- Durable URN, bound key
- Approval
- Informed Approval™
- Mode
- Shadow, then enforce
- Scope
- £25,000 per action, GB and IE (demo)
Accounts payable
A retailer's payables agent pays suppliers; larger invoices wait for a person.
- Invoice received
- Agent identity resolved
- Scope check
- Under threshold: allow
- Over threshold: require approval
- Finance lead decides
- Daily pack sealed
- Audit chain intact
- Platform
- Public playground decision
- Approval
- Finance lead
- Evidence
- Daily Evidence Pack™
- Replay
- Verified offline
- Scope
- €5,000 without approval (demo)
From API to app
See what the approver sees
Three demo consoles built on the same decision. Tap inside the phone or press play; each step shows the API call and the event it produced.
Credit consoleDelegate authority, then approve above the threshold
9:41
Finance appAn invoice above €5,000 waits for the finance lead
9:41
Claims consoleA prohibited capability is refused, a person pays
9:41
Tap any call in the list under a phone to open the same request in the API console. All data is fictional.
KYE™ Widgets™
Governance surfaces for your own product
GovernedUI™ widgets embed from widgets.kyeprotocol.com. Try a simplified preview here, then copy the embed snippet.
Notifications
One decision, to the right person on the right channel.
Approval required, delegation expiring, action denied, Evidence Pack™ sealed: one rule per event, with a delivery receipt for each message. Choose an event type and answer it on the phone. Demo data
Governed agents
An agent may act,
only within its authority.
KYE Protocol™ enforces authority while the action is forming: it refuses out-of-scope AI-agent action before the side effect commits, and every refusal and approval is signed, replayable and verifiable offline. An action commits only when:
- its identity resolves to one durable URN,
- the delegation chain back to a principal is intact,
- an authority grant covers the action,
- the action is within scope and the actor's state allows it,
- and the decision is sealed as evidence.
Credit agentPayables agentClaims agentKYC triage agentCollections agentSupport agent
Procurement agentSRE rollback agentResearch agentDrafting agentCompliance agentEvidence agent
Request from the payables agentPay €6,480.00 to Alder Joinery GmbH (demo), invoice INV-2026-0918
- Intent
- Identity
- On-behalf-of
- Authority
- Scope
- State
- Decision
- Evidence
- Replay
When an agent goes past its authority, a person decides.
DemoAll organisations, people, agents and amounts are fictional. Identifiers are shaped like real KYE Protocol™ identifiers but do not resolve to a governed record.
Governed workflows
Several agents, one person, one chain of authority.
Each node is an agent, a tool, a person or a policy. Every run is visible step by step, and waits for a person wherever the decision is require approval.
KYE™ Cloud™
One console for every governed agent.
Demo data
Governed agents0▲ 3
Active delegations0▲ 12
Held for approval today0No change
Denied today0▼ 2
Decisions, last seven days
MondayTuesdayWednesdayThursdayFridaySaturdaySunday
Recent decisions
- Credit agent · credit.line.approve £4,200 (demo)Allow
- Payables agent · €6,480.00 to Alder Joinery (demo)Require approval
- Claims agent · claims.pay_final (demo)Deny
- KYC agent · kyc.verify, region EU (demo)Allow
- Evidence Pack™ ep_2026_10_14 (demo)Sealed
The KYE™ terminal
Every agent, delegation and decision, in one environment.
Request, check, decide, approve and seal, from one place. Demo data
Identify→Delegate→Scope→Decide→Approve→Seal
DemoAll organisations, people, agents and amounts are fictional. Identifiers are shaped like real KYE Protocol™ identifiers but do not resolve to a governed record.
For developers
One call per action: API, SDK, CLI and MCP
Schema-first, dictionary-first, profile-first, registry-first, API-first, SDK-first, evidence-first, conformance-first. The same decision reaches your backend, your scripts and your agents.
Evaluate an agent action
POST/api/v1/runtime/evaluate
Interactive API console
Try the API here
Pick an endpoint, edit the request and send it. You see the path through the six checks, the decision, the headers, the events and ready-made code in four languages. Responses here are simulated and touch no real tenant.
POST
Press "Send" to see the response.
This session
- No requests sent yet.
Architecture
Eight first-class principles, from schema to conformance
Select a layer to see its role.
Surfaces
GovernedUI™WidgetsKYE™ Cloud™ consoleAdminAgent runtimes
Identity
EntityURNBound keyOwnerAccountable entity
Authority
DelegationOn-behalf-ofGrantScopeStateDecision
Policy
RegoCedarRule packsSector packsDictionaries
Evidence
Evidence Pack™Hash chainEd25519 sealReplayTransparency
Access
OpenAPITypeScript SDKPython SDKGo SDKCLIMCP Server
Select a layer.
Ecosystem
Above your agents, beneath your execution, across your stack
Connectors, integrations, the App Store, the Plugin Marketplace™, the State Library and the Directory: the ecosystem around one authority engine.
- Humans
- Businesses
- AI agents
- Models
- Tools
- Workflows
- Identity providers
- SIEM
- GRC
- MCP
- Auditors
- Regulators
Counterparty governance
When agents meet agents, authority on both sides.
A buyer's agent and a seller's agent each prove their authority; both receipts land in both Evidence Packs™. Demo data
DemoAll organisations, people, agents and amounts are fictional. Identifiers are shaped like real KYE Protocol™ identifiers but do not resolve to a governed record.
Connector Hub™
One authority model, every system it governs.
Systems differ; your authority model does not.
A connector maps each system's own contract onto the KYE™ decision. Delegations, scopes and evidence stay the same; only the connection changes.
KYE™ decisionPOST /api/v1/runtime/evaluate
Connector
Payment gateway (demo)POST /payments
Every connector in one registry
Systems, capabilities, versions and status, in one view (demo data).
| Connector | Capability | Environment | Status |
|---|---|---|---|
| Simulator | Decisions, delegations, evidence | Simulated | Ready |
| Identity provider (demo) | Principals, sessions | Sandbox | Connected |
| MCP gateway (demo) | Tool calls under authority | Shadow | Observing |
| SIEM export (demo) | Decision and audit events | Live | Active |
The decision path
One request, six checks, one sealed outcome.
Identity, on-behalf-of, authority, scope, state and audit, each checked before the side effect commits; every step is timestamped in the pack. Demo data
DemoAll organisations, people, agents and amounts are fictional. Identifiers are shaped like real KYE Protocol™ identifiers but do not resolve to a governed record.
The protocol governs itself
Every action authorised, bounded and provable.
The promise: KYE Protocol™ enforces authority while the action is forming: it refuses out-of-scope AI-agent action before the side effect commits, and every refusal and approval is signed, replayable and verifiable offline.
- Request
- Identity
- On-behalf-of
- Authority
- Scope
- State
- Evidence
Entity identityDelegationPurposeScopePolicyInformed Approval™Evidence Pack™Audit chainReplayTransparency logRevocation cascadeBreak-glass
Authority Finality™: legacy IAM vs KYE™
Why identity and logs are not authority
| Approach | Strength | Limit |
|---|---|---|
| Legacy IAM | Role resolved at login; well understood | Static permissions; revocation propagates eventually; no account of why the actor was entitled |
| Observability and traces | Shows what an agent did | Proves it behaved, not that it was empowered to cause the effect |
| Guardrails | Checks a rule on the content | A rule was checked; authority was not resolved |
| KYE Protocol™ | Authority resolved at t=0 of the action: scope-bound, expiring, recursively revocable, the entitlement sealed as evidence | Needs delegations and scopes declared for each use case |
Start free. Prove it. Scale.
Validate the fit, prove it to your board, then scale with confidence.
Open Source: validate the fit
SDK (TypeScript, Python, Go), CLI and local adjudication, self-assessment fixtures, community support.
Audit Pilot™: prove it to your board
A scoped Evidence Pack™, a regulator-ready report, a standard mutual NDA on request and guided onboarding.
Enterprise: scale with confidence
HSM-ready (BYOK) signing, dedicated support, custom sector packs and private connector profiles.
Value-based, not transactional
Platform fees and professional fees, anchored on the continuous value the runtime delivers.
Exam-prep in one pack
Audit exam-prep drops from days of reconstruction to a single verifiable pack.
Sell authority to your own customers, without building a governance engine.
Continue here
Try it, learn it, build it with us.
LabRun seven missions in your browser.
List entities, read a delegation's scope, evaluate an action, replay safely, hit the scope and read the events. No sign-up.
Open the lab TerminalTen views of governed agent actions.The decision path, delegations, require approval, workflows, notifications, counterparties, failure scenarios and evidence.
Open the terminal AcademyLearn the category.Authority, evidence and finality: learning paths over KYE™ Learn™, the glossary, the library and the playbooks.
Enter the academy PartnersPartner, get certified, build on KYE™.Resellers, integrators, ISVs, connector builders, trainers and auditor firms.
Become a partnerPodcasts
The protocol's vocabulary, one term at a time
KYE™ Minute explains one glossary term in about a minute, with a full transcript and an RSS feed. Episodes are published once audio is switched on; until then this section lists what is planned.
Glossary
Every KYE Protocol™ term, in plain English
190 terms in 16 groups, one paragraph per term, linked to its schema and its dictionary code.
Events
Webinars, workshops and report launches
A practitioner-led forum for agentic governance in the runtime era: conferences, workshops, webinars, office hours and governed-research report launches, each one dated entry you can register for.
Hear about new events first
We email you when a session is scheduled or a report is published.
FAQ
Questions we are often asked
What is KYE Protocol™ in one sentence?
The open contract that answers, for every action a human, service, AI agent, model, tool or workflow takes: who acted, on whose behalf, with what authority, under what scope, with what evidence?
Does KYE™ replace legal agreements or signatures?
No. KYE™ does not replace legal agreements, signatures, or regulatory obligations; it provides the technical control and evidence layer needed to support authority finality, accountability and legally defensible audit trails for agentic systems.
What does one call return?
A decision (allow, require_approval or deny) with a reason code from KYE™'s vocabulary, a replay-stable decision id, a receipt you can verify, and a sealed Evidence Pack™ that can be verified offline from published keys.
How is it different from IAM?
Traditional IAM answers who logged in. KYE™ answers everything that comes after: who or what acted, who they acted for, what authority they had, what capability they used, what state they were in, and what evidence proves it.
Can I try it without signing up?
Yes. The lab and the terminal run in your browser on fictional data; the free tools and the sandbox need no sign-up. An API key comes from the console.
What licence is the protocol under?
Apache License 2.0. KYE™, KYE Protocol™ and Know Your Entity™ are trademarks of the KYE Protocol™ project; see the trademarks page.
How is the information I enter in forms used?
Only to answer that request. Read the details in the and the full privacy policy.
Start free. Prove it. Scale.
Prove every agent action was allowed;
keep the proof.
Identity, on-behalf-of, authority, scope, state and audit, decided at t=0 and sealed into an Evidence Pack™ your auditor verifies offline.
Start in one line: npx @kye/cli