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.

Start in one line $ npx @kye/cli SDK & quickstarts →
One call per action Signed & offline-verifiable Maps to SOC 2 Maps to EU AI Act
POST /v1/authority/check
Request{ "agent": "kye:agent:lending-07", "action": "approve_credit_line", "amount": 4200, "purpose": "lending.adjudicate" }
Decision
ALLOW
within delegated authority · purpose valid · policy SOC2-CC6 satisfied
Finality receipt
kye:decision:9f3ac1 · sha256:1c0f…a7 · verify ↗
Illustrative — the real /v1/authority/check surface, three live outcomes.

Protocol, not product

KYE isn’t another AI-governance product. It’s the authority protocol the rest of your stack builds on.

Every other tool governs one slice and stops at the edge of its category. KYE Protocol sits above your agents (proving a regulator’s or board’s intervention is authorised), beneath your execution (proving a wallet, deploy, or claim is admissible before it happens), and across every model, sector, and jurisdiction — model-agnostic, vendor-agnostic, framework-agnostic. One engine; your packs, agents, and surfaces are projections of it. That is why KYE moves up, down, and sideways where a product can only hold its lane.

See the protocol →
One engine, every domain

Authority for your

One authority engine underneath every consequential AI action — whatever your agents do, KYE Protocol proves it was allowed.

Maps to the regulation you answer to

KYE maps every action to 243 regulatory frameworks, each pinned to its jurisdiction.

A live projection of the coverage registry — real frameworks, real jurisdictions. Browse the full coverage map →

is not authority.

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. KYE Protocol resolves that authority before the action commits, and seals an Authority Finality record anyone can verify.

The six primitives, live

One authority hub. Six questions answered on every action.

Every consequential action your agents take flows through one deciding core. Tap any primitive to see the real schema, the numbers and the code behind it — the same objects your auditor verifies.

KYE AUTHORITY HUB Deciding live allow · deny · require-approval — sealed at t=0

Identity

who or what is acting?

One durable URN names every actor — human, business, service, AI agent, model, tool, workflow — and binds it to a public key. Identifiers persist across rebuilds, redeployments and tool invocations, so “which AI did this?” always has one answer.

1durable URN
7actor types
persistence
kye:agent:acme.co:tpp:payments-bot-7
  • Resolves subject, actor and principal in every authorize call.
  • Keys rotate; the identity never changes.
  • Tombstoned identities stay answerable — history is never orphaned.

On-Behalf-Of

on whose behalf?

A signed delegation chain binds every action back to a human or business who is legally on the hook. Each link carries a scope that must attenuate its parent’s — never exceed it — so “who authorised this?” is answered in seconds, not a Slack thread.

100%signed links
attenuate only
0implied authority
parent_delegation_id: kye:delegation:acme.co:root:2214
scope ⊆ parent.scope   // never exceeds
  • Every authorize call walks the chain from acting agent to root principal.
  • A break in the chain returns deny: chain_broken — fail closed.
  • The layer OAuth, OIDC and SPIFFE leave to ad-hoc app code, made explicit.

Authority

under what authority?

A grant declares what an actor may do, over what resource, under what conditions, until when — and always traces to a root principal. Revoke a parent and the cascade kills every child grant.

<1srevocation cascade
100%recursive
0orphan grants
decision: allow_with_constraints | require_approval | deny
Authority Finality — legacy IAM vs KYE

Legacy IAM

Role resolved at login. Static permissions. Revocation propagates eventually. No account of why the actor was entitled.

KYE

Authority resolved at t=0 of the action. Scope-bound, expiring, recursively revocable in under a second — with the entitlement sealed as evidence.

Scope

within what scope?

Every grant is bounded — amount, corridor, window, resource. An action outside the declared scope never commits, and ceilings deplete as they are consumed, so a hundred small actions can’t add up to one unauthorised exposure.

100%bounded grants
0unbounded approvals
denyoutside scope
scope: {
  amount:   { max: 25_000, currency: "GBP" },
  corridor: ["UK", "EU"],
  window:   "business-hours"
}
  • Consequential grants must declare limits and an expiry — unbounded, never-expiring approval rights don’t ship.
  • Jurisdiction is fail-closed: no declared jurisdiction, no cross-border action.

State

in what state?

Authority is state-aware. Suspended, expired, revoked, superseded — the decision answers to the actor’s state at the moment of the action, not the state when the grant was written.

t=0live state
revoked is not deleted
0stale verdicts
status: active → suspended → revoked  // terminal, evidence kept
  • A revoked mandate denies instantly — there is no propagation window to exploit.
  • Superseded records point to their successor; the evidence trail never gaps.

Audit

with what proof?

Every decision seals into a hash-chained Evidence Pack your auditor can verify offline, from published keys alone — no live service, no trust in our word for it.

100%offline verifiable
0trust required
tamper evident
event[n].hash = H(event[n-1] ‖ payload)
  • Tamper with one event and every later hash breaks — visibly.
  • Exam-prep drops from days of reconstruction to one verifiable pack.

Three questions you can’t answer today. KYE Protocol answers all three, on every AI action.

Was the agent allowed to do it? Can you prove what it did? Did it close cleanly? KYE Protocol answers all three on every consequential action — before it lands, and in a form your auditor can verify.

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

Start where you are. Eight ways in, one authority engine underneath.

Eight ways in — pick the one that matches what you came to do. Every path leads to the same authority engine underneath.

Platform The authority engine under every AI action The runtime that checks authority, seals evidence, and reaches finality on every consequential action your agents take — plus the SDKs, OpenAPI, and KYE MCP Server to build on it. Products Governed surfaces you can adopt today GovernedUI, embeddable widgets, off-the-shelf governed agents, rule packs, and the Agent Dev Kit — drop-in products that keep a human in control of AI authority. Industries Your sector, governed KYE Sector Pack authority mapped to your regulator and your workflows — banking, insurance, health, legal, public sector, and more. Compliance Prove it to your auditor Every framework KYE Protocol maps to, the control behind each claim, and evidence an auditor can verify — never asserted, always shown. Solutions Start from the outcome you need AI-agent auditability, runtime approval, evidence replay, and consequential-action governance — the problem-first path to the right KYE Protocol capability. Programs Pilot, partner, get certified Governed pilots, the Partner and Sector Pack Foundry programs, certified consultants and experts, and the trainer and auditor tracks — the on-ramps to adopt and extend KYE Protocol. Resources Learn the category Glossary, frameworks explained, playbooks, and governed research — the reference for authority, evidence, and finality in the agentic economy. Tools Try it free, right now The free self-serve toolbox — Authority Risk Profiler, Authority Diagram, readiness self-test, sandbox, and KYE Lens — no sign-up to see KYE Protocol work.

KYE Inside · Build on KYE

Sell authority to your own customers — without building a governance engine.

If you run a platform, an agent product, or a vertical SaaS, embed KYE Protocol underneath it: your customers get runtime authority checks, Replay-Proof evidence, and Authority Finality on every consequential AI action — multi-tenant, tenant-isolated, under your brand. You ship agent-authority governance in weeks instead of building a decision-and-evidence engine yourself.

Embed KYE Inside →
The Mechanism

From black box to Evidence Pack.

Every consequential action passes through five gates. What comes out the other side is a signed, offline-replayable artifact — not a log line.

Request1 Policy2 Context3 Authority4 Evidence5
STEP 01

Action Request

An agent or system proposes a consequential action. It enters the rail before anything irreversible happens.

STEP 02

Policy Gate

Rego, Cedar, or custom policy evaluates the request against your rules — deny, allow, or escalate.

STEP 03

Context Check

Identity, data classification, and jurisdiction are verified at the edge before authority is granted.

STEP 04

Authority Node

HSM-ready signing binds the decision to its proof — the verdict cannot be forged or repudiated.

STEP 05

Evidence Pack

An offline-replayable, tamper-evident archive. Verify it from public keys alone — no live service needed.

Pricing

Start free. Prove it. Scale.

Validate the fit with open tooling, prove it to your board with a scoped pilot, then scale with confidence.

Open Source
Validate the fit.
  • SDK (TypeScript · Python · Go)
  • CLI & local adjudication
  • Self-assessment fixtures
  • Community support
Explore the SDK
RECOMMENDED
Audit Pilot™
Prove it to your board.
  • A scoped Evidence Pack™
  • Regulator-ready report
  • Standard mutual NDA on request
  • Guided onboarding
Start a pilot
Enterprise
Scale with confidence.
  • HSM-ready (BYOK) signing
  • Dedicated support
  • Custom sector packs
  • Private connector profiles
Talk to us

See it run

A governed agent deployed in KYE Cloud™, connected to data, and its Evidence Pack™ trail opened — filmed end to end.

Platform walkthrough

Demo: working inside KYE Cloud™ — deploy a governed agent and verify its Evidence Pack™ trail

Governed agentDashboardOnboardingEvidence Pack™

Watch the full demo library