• 50 profiles
  • 41 / 41 conformance
  • 266 control mappings
  • 13 frameworks
  • 3 SDKs
  • v1.0 frozen Apr 2026
Built above your existing stack

Eleven read-only Stack Bindings — no migration required.

vpn_keyIAM / SSOOkta, Entra ID, Ping, Auth0, Keycloak
keyOAuth / OIDCScopes, tokens, claims, refresh chains
apiAPI gatewayKong, Apigee, AWS API GW, Cloudflare
smart_toyMCP serversTool calls observed
psychologyAI-agent frameworksLangChain, AutoGen, OpenAI Agents
routeWorkflow enginesTemporal, Camunda, Step Functions
monitoringSIEMSplunk, Sentinel, Elastic, Chronicle
fact_checkGRCOneTrust, Drata, Vanta, ServiceNow IRM
gavelPolicy enginesOPA, Cedar, Styra DAS
receipt_longAudit logsRead-only append-only ingest
storageData storesSnowflake, BigQuery, Postgres, S3
arrow_forwardApply for pilotClosed signup; 2-day qualification
Why this exists

AI-agent accountability is now a board-level liability.

The gap

An AI agent calls five services with five different identities. Stop signals don’t cross system boundaries. Auditors can’t reconstruct what happened. Regulators (EU AI Act, DORA, NIS2, PSD3, ISO 42001, NIST AI RMF) want a chain of authority — not an OAuth token.

The contract

One URN format. One delegation chain. One decision vocabulary. One cascading bus. One signed proof. The same answer in every system to who acted, on whose behalf, with what authority, under what scope, with what evidence?

Three legs to stand on

Regulatory tailwind · composes with OAuth / SPIFFE / MCP / KYC / KYA · implementable today on Apache 2.0 schemas + reference Gateway + 41-fixture conformance pack.

The metaphor

KYE produces the KYE Chain of Authority the way digital signatures produce chain-of-custody for documents. Courts already accept signed documents; KYE gives them signed delegations.

What it is

In one sentence: the open contract for who-acted-and-why.

Definition

KYE Protocol is the open identity, authority, scope, state and audit layer for every action a human, business, AI agent, service, model, tool or workflow takes — one URN, one delegation chain, one decision vocabulary, one cascading bus, one signed proof.

  • Identityproves who you are. Every actor (human, business, agent, service, model, tool, workflow) has one URN, verifiable across vendors.
  • Authorityproves what you’re allowed to do. A signed delegation chain back to a human or business; revocable in milliseconds, recursively.
  • Scopeproves the boundaries you operate within. Action lists, environment, money limits, time windows, obligations — each enforced by the PDP.
  • Stateproves the conditions right now. Six independent dimensions: lifecycle, authority, delegation, credential, recovery, risk. Each transitions independently.
  • Auditproves the full record forever. Append-only chain, signed proof bundle, point-in-time replay; an external auditor verifies with public keys alone.

More: why it exists / what it adds → · technical reference → · whitepaper →

Where KYE fits

AI governance is not one layer.

Compliance frameworks, governance architectures, authorisation models and runtime execution control are related but distinct. KYE Protocol sits where governance meets execution: the runtime authority and evidence layer that decides and proves whether a delegated action should happen.

01ruleCompliance frameworks

Question: What obligations must we meet?

Examples:
EU AI ActISO 42001SOC 2DORAGDPRNIS2HIPAAPCI DSS

KYE role: produces runtime evidence packs and Compliance Map mappings that frameworks consume.

Does not: replace the framework, the certifier, or the auditor.

02account_treeGovernance architecture

Question: How is accountability organised?

Examples:
AI governance boardRisk committeesControl librariesApproval workflowsModel governanceIncident processes

KYE role: turns governance intent into runtime authority decisions and replayable evidence.

Does not: replace organisational governance.

03keyAuthorisation model

Question: Who or what may be allowed?

Examples:
IAMRBACABACOAuth scopesPDP / PEPPolicy-as-code

KYE role: extends authorisation into delegated agency, capability scope, six-dimension state, Authority Continuity, Discoverability, evidence and revocation.

Does not: replace IAM.

04boltRuntime execution control

Question: Should this specific action happen now?

Examples:
Agent purchasePayment initiationTool callData accessContract signingClinical escalationInfrastructure command

KYE role: decides, records, revokes and proves authority at the point of action.

Does not: process the underlying payment, clinical action or infrastructure command itself.

KYE Protocol — the runtime authority & evidence bridge

Identity · Authority · Scope · State (6-dim) · Decision · Audit · Evidence Pack · Discoverability · Continuity. Resolves who or what is acting, on behalf of whom, under what authority, in what state — then produces a signed Decision Map + Evidence Pack any auditor or regulator verifies offline with public keys.

Frameworks tell you what must be governed. KYE controls and proves what actually happened at runtime.

IAM vs KYE

Why IAM is not enough for agentic systems.

IAM answers who logged in. Agentic systems require a deeper runtime question: what was actually acting through the chain?

IAM asks

Who logged in? What permissions were assigned at issuance?

KYE asks

Who or what acted? On behalf of whom? Through which delegation chain? Using which capability? Inside what scope? In what state? With what evidence? Was Authority Continuity preserved? Can it be discovered and revoked?

KYE does · does not

Honest about the boundary.

What it is

KYE does

  • Resolve actor and principal
  • Map delegation chains
  • Check capability + scope at decision time
  • Evaluate the six-dimension state vector
  • Produce signed Decision Map
  • Emit signed events on KYE Signal Bus
  • Cascade revocation through the authority graph
  • Generate Evidence Pack bundles
  • Policy-filtered masked discovery
  • Preserve Authority Continuity

What it is not

KYE does not

  • Replace compliance frameworks
  • Replace legal advice
  • Replace external auditors
  • Replace IAM entirely
  • Replace payment rails
  • Replace model-governance platforms
  • Guarantee regulatory compliance by itself
  • Decide moral intent or consciousness
  • Hosted Cloud Gateway SaaS today (v1.1)
Seven runtime profiles · on top of Core

Admissibility. Continuity. Discoverability. Ontology. Operating Model. Assurance. Formal Rules.

Core records who or what acted, on whose behalf, under what authority, in what state, with what evidence. Seven runtime profiles add the layers around it: an upstream admissibility layer that decides whether a proposed action may even enter the pipeline, continuity from intent to action, discoverability across the authority graph, an ontology-backed semantic layer, an operating-model adoption layer, an assurance-card layer, and a formal-rules layer that turns rights, obligations and governance into runtime authority decisions.

fact_checkKYE Action Admissibility ProfileUpstream pre-action layer. Decides whether a proposed action is admissible before any authority, formal-rule or commit-boundary check runs. Six decisions, fifteen inadmissibility classes.before authority → trending_upKYE Continuity ProfileBind interpreted-vs-declared intent + multi-dimension state + pressure + incentive + oversight into a signed pre-commit verdict. Ten drift types.preserve the chain → exploreKYE Discoverability ProfileTurn the cryptographically-bound authority graph into a queryable surface with discovery policy, row-level masking, federation traversal and signed audit per query.find the path → hubKYE Ontology ProfileSemantic layer — shared meaning of entities, authorities, capabilities, scopes, states, decisions, evidence, profiles, connectors and sectors. Six explicit mapping types prevent false equivalence.preserve meaning → routeKYE Operating Model ProfileFrom use-case intake to runtime control. Ten journey stages, eight Authority Gate types, Commit Boundary, Entity Authority Record, signed adoption evidence pack.assess. gate. decide. prove. → badgeKYE Assurance Card ProfileLiving lifecycle assurance record per delegated entity. KYE Human Involvement Plan enforced at runtime; provenance & supply-chain evidence; ten review triggers; decommissioning plan with cascade revocation.system cards become executable → policyKYE Formal Rules ProfilePermissions, obligations, prohibitions, powers, exceptions and governance meta-rules as machine-readable authority objects. KYE Rule Prover, KYE Control Compiler, KYE Obligation Ledger.rights, obligations, runtime →

Admit. Decide. Gate. Prove. Revoke. Replay. KYE does not only attribute delegated actions after they exist — it checks whether proposed actions are admissible before they enter the authority pipeline, then decides, proves, revokes and replays what happens next.

FAQ

The three most-asked questions.

What is Authority Finality and how is KYE different from IAM?

Identity tells you the front door — KYE Protocol tells you what happened on the other side. We call this Authority Finality: a replayable proof layer for AI-agent actions. Every action carries a delegation chain back to a human or business, attenuable scope, signed evidence, and standardised reason codes that any auditor can verify with public keys alone.

Is this production ready?

The v1.0 contract is bank-grade and frozen as of April 2026 (58 v1.0 normative profiles, 193 OpenAPI operations, 142 schemas, 266 control mappings, 126 conformance fixtures all passing). Reference implementations are pilot-grade (correctness-first, not throughput-tuned).

How is KYE different from KYA / MCP / SPIFFE / OAuth?

KYE composes with all of them. OAuth issues credentials; MCP gives agents tool access; SPIFFE handles workload identity; KYA vendors issue agent passports. KYE binds these into one open contract that carries delegation, scope, state, decision, and signed audit across every layer.

25 more — full FAQ →

KYE governs KYE · practicing what it preaches

The protocol's own engines run on the protocol itself.

Every release of KYE Protocol runs scripts/self-govern-kye-on-kye.mjs — eight engines (Identity, Authority, Admissibility, Continuity, Meaning Continuity, Formal Rules, Obligations, Evidence) evaluate the project as a governed entity and emit eight Ed25519-signed artefacts.

The honest part: the engines correctly classify the project as obligation: breached and admissibility: require_human_review when consistency-drift, missing SOC 2, or stat-mismatches surface. Most "trust" pages claim a green checkmark; KYE’s signs an honest red one and routes itself to human review.

verifiedSigned evidence pack8 artefacts per run: entity-authority-record, proposed-action, admissibility-decision, formal-rule, obligation-state, provenance-evidence, assurance-card, adoption-evidence-pack. Ed25519 over RFC 8785 canonical JSON.
linkAppend-only transparency logEach run hash-chains to the previous. Retention configurable (default 12 runs); chain integrity is independently verifiable.
offline_pinAnyone-can-verifyThe verifier ships in scripts/verify-self-audit.mjs with zero dependencies. Defaults to offline (against on-disk fixtures); pass --base for live verification.
policyHonest by constructionThe decision values, drift codes, and obligations the engines produce on KYE itself are exactly the same ones a customer's actions go through. No special-cased self-governance.