The trust layer for consequential action
286 evidence packs verified 24 decisions governed 20 frameworks mapped last 24h

Self-governed · live signed receipts Framework coverage · machine-readable

Agentic Governance with Authority Finality.

AI agents are acting on your behalf. Refuse what they’re not allowed to do — at the moment of the action, not after.

Governance without enforcement is a recommendation. KYE Protocol™ enforces authority while the action is forming — before the wire transfer commits, before the clinical recommendation issues, before the contract is signed. Authority expires, context drifts, legitimacy disappears mid-flight; KYE™ refuses out-of-scope action before the side effect lands. Every refusal and every approval is signed, replayable evidence — but the enforcement is the primitive, not the receipt.

AI agent
wire €182,400 → Supplier-X
KYE™ PDP · admissibility check
Refused out of scope · signed envelope Admitted within scope · signed evidence
Runtime enforcement, not after-the-fact audit. KYE Protocol™ intercepts every AI-agent privileged action at the admissibility layer — out-of-scope refused, in-scope admitted — each decision signed and verifiable offline.
  • 50 profiles
  • 41 / 41 conformance fixtures
  • 289 control mappings
  • 13 compliance frameworks
  • 3 Apache-2.0 SDKs
  • v1.0 contract, frozen Apr 2026

Three questions decide whether an AI action is legitimate.

Three questions decide whether an AI action is legitimate. Everything else KYE Protocol does sits under one of them.

Authority

Was this action allowed?

Stop an unauthorised AI action before it commits — not after the regulator asks.

  • Every consequential action is checked at the moment it happens, against who delegated what, to whom, within what limits.
  • Authority is traced across the whole chain — the organisation, the agent, the tool it calls, the human who approves.
  • It is jurisdiction-aware: the action answers to the rules of where it lands.
Authority Governance

Evidence

Can you prove it?

Turn every action into proof an auditor can verify in seconds — without trusting your word for it.

  • Each decision is sealed into a signed record anyone can verify offline, from published keys alone.
  • Audit exam-prep drops from days of reconstruction to a single verifiable pack.
  • Nothing is asserted that isn't proven — no claim without its source.
Evidence Pack

Finality

Did it legitimately close?

Let irreversible actions reach signed closure — contestable later, never deniable.

  • High-stakes actions can require a second approver, or be held from becoming final until authority is re-anchored.
  • Closure means it legitimately ended under the authority and evidence that existed then.
  • Provenance is kept: the action can still be contested in the future, never quietly erased.
Authority Finality

What KYE Protocol™ is made of — colour-coded.

New here? The protocol is a small set of building blocks, and each one always wears the same colour across the whole site. Learn the nine colours once and the rest of KYE Protocol™ reads itself.

Rail

A governed lane of capability — Evidence, Billing, Onboarding, Comms.

Engine

The runtime that actually decides or computes — the working parts.

Agent

An autonomous actor KYE™ governs as a first-class principal.

SKU

Something you can buy — a product, pilot or add-on.

Framework

A regulation or standard KYE™ maps to — EU AI Act™, SOC 2, DORA.

Sector

An industry pack — banking, healthcare, insurance, public sector.

Report

A sealed, replay-verifiable document you can defend to an auditor.

App

A customer-facing application surface you log in and use.

Profile

A canonical entity profile — how KYE™ recognises who or what acts.

See the full colour taxonomy

Constitution §0.3 · the protocol governs itself

KYE Protocol™ holds itself to the exact bar it holds your AI’s actions to.

Every privileged action this codebase takes — a CI gate, a deploy, a schema migration, a key rotation — is admissibility-checked, evidence-emitting, and Replay-Proof™ verifiable from public keys alone. Not "trust us": evidenced, governed, and verifiable by you, offline. See the full receipts on the self-governance page.

Latest signed self-audit passing
5 / 5checks passed
13 / 13engines healthy
10profiles tested

EdDSA over RFC 8785-canonical JSON · signing key kye:key:self-audit-fixture-2026-06 · published . Verify the signature against the published JWKS — no portal log-in, no vendor cooperation.

Scoping an AI project?

Design governance in before you build — the KYE Governance Design Brief.

Digital-transformation teams decide scope, capabilities and autonomy long before governance shows up. KYE Protocol turns your project scope into a sealed governance design — controls, evidence, autonomy tier and the frameworks that apply — and the fee credits 100% into a pilot.

design_services Design governance in → cloud Governance as a service

Select any action. Resolve its authority. Seal the evidence.

The protocol resolves four kinds of AI-agent action at the moment they form — a wire transfer, a payment, a clinical decision, an audit replay. Each is checked against its authority contract and sealed as signed evidence: out-of-scope refused, in-scope admitted, every decision verifiable offline from published keys alone.

per hour, before lunch
decisions, every hour, one agent

The world where humans review the books in six months has already ended.

An insurance AI agent triages 40,000 claims an hour. Six months later, the compliance team sits down with the auditor. They cannot review what was done — the speed broke the model. Post-facto governance is forensics, not control.

Once execution moves at machine speed, authority has to be resolved before the action commits — not in the audit log it leaves behind.

“That world has already ended without people even realising it had ended.”
The category that has not been built

Everyone is making the car parts. Nobody wrote the highway code.

AI safety, observability, guardrails, compliance frameworks — every layer of the agent stack is being built in parallel. None of them answer who is authorised to act, on whose behalf, with what evidence, at the moment the action executes.

  • AI safety frameworksSeatbelts — reduce harm if an action goes wrong
  • Guardrails + prompt engineeringAirbags — soften the impact, don't refuse the action
  • Observability + monitoringDashcam — records what happened, not authority to do it
  • Compliance attestationsMOT certificate — vehicle roadworthy, doesn't drive it
  • Agentic commerce SDKsToll booth — collects payment, doesn't grant right-of-way
  • KYE ProtocolThe highway code + the driver's licence

Without highway code, the rest is logistics. KYE Protocol answers the questions nobody else is answering: who is authorised to act, within what scope, under which delegation, against which policy — resolved at the speed the agent acts.

The full authority lifecycle, end to end

From entity declaration to Authority Finality — ten signed states.

Behavioural control planes intercept at one point in the chain. KYE Protocol owns the whole timeline. Here are the three anchor states — the full ten are on the dedicated page.

  • 01
    Entity declareskye:org:gb:acme publishes key material to its JWKS — the root of trust every downstream signature resolves to.
  • 08
    Authority Finality reachedThe gateway returns a signed verdict at the integrating system's commit boundary. The authority decision is immutable from that moment.
  • 09
    Evidence Pack sealedIntent, delegation chain, state vector, decision map and outcome composed into one signed bundle. Replayable from public keys alone.

timeline See the full lifecycle →

The full authority governance lifecycle

Ten governed stages — from Intent to Revocation.

Each stage is a governed checkpoint. KYE Protocol spans the full spine. Click any stage for its canonical surface.

timeline Explore the full lifecycle →

The governed path — end to end

Partner Journey Board — ten stages across four phases.

Every KYE Protocol integration traverses the same lifecycle — from Intent through Authority Finality to Renewal or Revocation. Up-arrows show advancement; dashed exits show revocation paths.

timeline Explore the full lifecycle →

Federated authority

Authority that crosses trust domains.

A consequential action's authority almost never lives in one place. It spans the principal organisation, the delegated agent, the external tool it calls, the vendor behind that tool, the human who must approve, and the regulator who can later challenge it. A local tool-call guard sees only its own boundary. KYE Protocol resolves — and signs — authority across every domain the action touches.

  • PrincipalOrganisation
  • DelegateAI agent
  • CallsExternal tool
  • Behind itVendor
  • ApprovesHuman reviewer
  • Can challengeRegulator / auditor
KYE resolves authority across all six — delegation chain, scope, policy, evidence and Authority Finality — Replay-Proof from public keys alone. A local guard governs one hop; KYE governs the chain.
Entity model

One governed hierarchy — tenant to principal.

Authority only means something if every actor resolves to a known place in one tree. In KYE Protocol the Tenant is the billing and isolation root; every workspace, team, resource, model, tool and acting party resolves up a parent chain to exactly one Tenant. Nothing acts from nowhere.

  • Tenant (kye:tenant:…) — billing + isolation root; owns legal entities, billing, domains and policies.
  • Workspace (kye:wsp:…) — an environment / dataspace owned by a Tenant.
  • Within it — Projects, Teams, Resources, Models, Tools, External Apps and Audit Streams, each with its own canonical ID.
  • Principal (kye:prin:…) — the acting party; every decision, tool call and audit row resolves to exactly one.

A Principal is exactly one of four classes — the same governance applies whether the actor is a person or a piece of software:

  • PrincipalHuman
  • PrincipalSystem
  • PrincipalAgent
  • PrincipalExternal app
Every action resolves to one Principal inside one Tenant — Replay-Proof to its parent chain. See the full entity tree →
The wedge · in three lines

Authentication is not authority.
Audit is not governance.
Logs are not evidence.

KYE Protocol proves who or what acted, on whose behalf, under what authority, inside what scope, with what decision and what evidence — before the action executes, not after the regulator asks.

What KYE is not

  • another IAM layer
  • another OAuth scope vocabulary
  • another audit log
  • another GRC spreadsheet
  • another SIEM event stream

What KYE is

  • runtime authority for delegated action
  • policy + purpose + scope + state at decision time
  • continuity + drift detection across the chain
  • signed, replayable evidence per action
  • revocation that propagates — provably
Beyond agent identity

Identity is the first layer. Authority is the missing layer.

Giving an AI agent a cryptographic identity is necessary — and the enterprise is already racing to do it. Uber has publicly described building agent identity, an AI Agent Mesh, a Security Token Service and an MCP gateway that propagate the full actor-chain (originating human → agents → tool) through every hop. That answers who is acting. It does not answer whether the action was allowed.

An authenticated agent with a valid key may still lack authority to approve a refund, release a legal document, call a sensitive tool, read protected memory, spend budget, merge code, or trigger a regulated workflow. KYE Protocol extends agent identity into runtime authority:

  • Who or what is acting, and on whose authority?
  • Under which delegation — scoped, current, and revocable?
  • Within what scope, against which policy version?
  • Was the proposed action admissible before it executed?
  • Was the tool / model / memory / data use within scope?
  • Was evidence captured at T=0 — signed, replay-derivable?
  • Can the action reach Authority Finality — and be contested, replayed, or revoked?
Identity proves the caller. KYE proves the authority of the action. Agent-identity layers — enterprise meshes like Uber's, agent-identity products, runtime tool-call guards — establish who and what. KYE is the layer above: it resolves whether the action had authority, and seals the proof. It consumes their identity and audit signals as inputs to Action Admissibility — it does not compete at their altitude.
KYE Governed Research Rail · publisher of authority

Research you can replay-verify — not assert-and-trust.

KYE Protocol publishes governed AI research held to the same bar as a regulated decision: every claim traces to a pinned source, every edition is sealed and Ed25519-signed over the published keys, and any reader can verify the seal offline. Subscribe to the editions that match your sector and role — the categories are drawn live from the canonical report matrix, never a hand-kept list.

Browse the report library
Built for trust and scale · every property below is a shipped surface, not a promise

KYE Protocol™ first-class properties

verified_userGovernance-firstEvery action runs the Decision + Purpose engines
schemaSchema-first258 canonical JSON schemas
apiAPI-first11 OpenAPI rails + core
auto_awesomeAI-firstBuilt for AI-native systems
groupsMultitenantPer-tenant scope on every row
publicJurisdiction-aware8 jurisdictions · cross-border evidence automatic
verifiedProduction-gradeNo-stubs gate · 0 violations
account_balanceBanking-gradeDual-channel · public-key replay
gavel100% Framework Mappings19 frameworks · OSCAL exporter
Show the other 21 first-class properties →
menu_bookDictionary-first18 canonical dictionaries
spellcheckVocabulary-first31 vocabulary files
list_altManifest-first5 canonical manifests
domainRegistry-first6 canonical registries
receipt_longSKU-first19 canonical SKUs
smart_toyAgent-first16 governed agents
hubGitHub-first74 CI/CD workflows
cloudEdge-nativeServerless edge runtime
boltServerlessZero VMs · zero containers
extensionComposable10 engines · 16 agents · 18 widgets
trending_upScaleableGlobal edge · auto-scale
corporate_fareEnterprise-gradeOIDC · mTLS · RBAC · CSP-strict
policyOwn Compliance EngineOSCAL exporter · Conformance runner
shieldOwn Governance EngineLive on the public perimeter
lockImmutable Audit (WORM)structural triggers · object-store immutability
workspace_premiumPatent-secured43 claim families · UK/EU/US/AU
labelsData Classification6-element lattice · GDPR Art. 9
crisis_alertRisk Engine5 tiers · 8-framework floor map
searchKYE Native Search™Signed result envelope
memoryKYE Memory Engine™Retention-bounded
summarizeKYE Reporting Engine™Per-framework reports

6 months of evidence archaeology.

Audit prep means combing six vendor consoles, screenshotting logs, interviewing engineers, and rebuilding a story the regulator has to take on trust.

3 days. One signed evidence pack.

The auditor fetches one URL, verifies the signature with public keys, replays every decision, and maps it to 289 controls across 170 frameworks.

Why KYE™

From KYX to KYE™. From categories to a protocol.

KYC, KYB and KYA verify categories of actors. KYE™ governs entities capable of action.

  1. KYC verifies the customer. A human, at onboarding.
  2. KYB verifies the business. A legal entity, at onboarding.
  3. KYA verifies the agent. A single AI agent, at the moment it is registered.
  4. KYX generalises the pattern. Verify any new category.
  5. KYE™govern any entity capable of delegated action. Runtime, signed, replayable.

Once AI agents, tools, workflows and APIs act through delegated authority chains at machine speed, governance cannot remain a post-facto stitching of IAM, OAuth, SIEM logs and GRC systems. KYE Protocol™ provides the runtime authority and evidence layer for delegated AI actions — one signed delegation chain, one Decision Map™, one Evidence Pack™, one Replay Proof™ — under a single open contract.

Tell me more about KYE Protocol™
Simulate before action

Test the future, then approve informed.

High-blast-radius AI-agent actions don't have to be a leap of faith. KYE Scenario Testing™ runs the proposed action through a deterministic stress evaluator before it executes — emitting a risk level, a recommended decision, and a list of recommended controls. KYE Approval Brief™ then composes 13 required-knowledge slots into a structured, signed brief so the human approver decides on facts, not vibes — and the decision is sealed into a KYE Approval Evidence Pack™ any auditor verifies offline. Read more: Scenario Testing™ · Informed Approval™.

Authorised. Evidenced. Grounded.

Reality Coupling™ — the layer between authority and action.

A delegated AI system can remain explainable, trusted, high-performing and cryptographically verifiable while slowly decoupling from current operational reality. KYE Reality Coupling™ detects that stable-drift failure mode — locally valid, globally wrong — before trusted automation causes trusted harm. The new n_reality_coupling decision step grounds every decision in a current view of the world, and emits a signed kye.stable_drift_event.v1 the moment the world moves.

KYE Consultant Program™ · multiply your governance practice

Offer KYE™ to your clients — without rebuilding the evidence layer.

If you advise on AI governance, data privacy, or security, you bring the regulator credibility. KYE™ brings the cryptographically-signed evidence layer. Together your clients get evidence-grade governance in weeks, not the 12 months it takes to build from scratch. The KYE Consultant Toolkit™, a multi-tenant console, signed attribution on every action, and a public marketplace listing — for CISO, DPO, and AI-governance practices.

Sovereign AI · per-jurisdiction

Runtime authority, jurisdiction-tuned.

Every jurisdiction running a serious AI program is converging on the same expectation: AI must prove its authority at runtime, not declare it in a policy. KYE Protocol ships per-region reference pages mapping the protocol to the regulators each jurisdiction reads first.

Plus sector pilots: Clinical AI · KYE HAARF Readiness Pilot™ · Financial services · Trust Center

Free, in your IDE, in 60 seconds

Try the Authority Finality Diagnostic — free, signed, replayable.

Run the free 24-question / 6-lens self-assessment from any IDE that speaks Claude Code, MCP, or our CLI. Get an unsigned score instantly. Sign up for a free KYE account and convert it into a signed kye.report.v1 envelope — auditor-grade, regulator-grade, verifiable offline against our published JWKS. 3 signed envelopes / month / email on free tier.

When you're ready to close the gaps the diagnostic finds (not just measure them): apply for a paid pilot — unlimited signed envelopes + the runtime that turns gaps into enforced policy.

Built above your existing stack

Eleven read-only Stack Bindings — no migration required.

Every claim here is backed by the open KYE Protocol™ contracts and verifiable end-to-end from the publisher's JWKS — you check it yourself, you don't take our word for it.

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.

Every claim here is backed by the open KYE Protocol™ contracts and verifiable end-to-end from the publisher's JWKS — you check it yourself, you don't take our word for it.

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 + 129-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.

You stop relying on vendor good-faith and start relying on cryptographic proof — that is what changes when AI agents act on your behalf at runtime.

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.

Every claim here is backed by the open KYE Protocol™ contracts and verifiable end-to-end from the publisher's JWKS — you check it yourself, you don't take our word for it.

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)
Six protocol primitives

Click into any primitive for schema, endpoint, example.

Every claim here is backed by the open KYE Protocol™ contracts and verifiable end-to-end from the publisher's JWKS — you check it yourself, you don't take our word for it.

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, a shared-vocabulary 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 Profile™Upstream 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 Profile™Bind interpreted-vs-declared intent + multi-dimension state + pressure + incentive + oversight into a signed pre-commit verdict. Ten drift types.preserve the chain → exploreKYE Discoverability Profile™Turn 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 Profile™Semantic 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 Profile™From 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 Profile™Living 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 Profile™Permissions, 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 (10 canonical profiles + 57 rule packs + 49 sector packs + 191 dictionaries, 550 OpenAPI operations, 276 schemas, 289 control mappings, 133 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 →

How the protocol governs itself
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.

Signed Evidence Pack™ 8 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.
Authority Chain™ Every action carries a delegation chain back to a human: human → CEO → CFO → agent. Each link is signed, scope-bound, and revocable; the chain hash-links to the previous run for tamper-evidence.
Replay Proof™ The verifier ships in scripts/verify-self-audit.mjs with zero dependencies. Defaults to offline (against on-disk fixtures); anyone with the publisher's JWKS can re-derive the decision — no vendor server in the path.
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.
notifications_activeWake-up contractEvery failure signal — workflow_run completions, hourly liveness probes, deployment snapshots — has at least one wake-up path with bounded latency. Three layers: live webhook (seconds), post-push verifier (≤ 90s), session-resume ingest (next resume). Silence is not a state.