IDefy · AI agent authority governance
Letting an AI agent spend money usually means handing it a standing secret and hoping. IDefy takes the hoping out: every call the agent makes is checked against what a person actually approved. Routine payments go through on their own, anything over the limit pauses for a human's passkey, the running total can't be wound back by restarting the agent, and one switch stops it mid-task — with a signed record of every decision you can hand an auditor.
The person
Delegates the work, approves the big calls.
Person passkey
Consents once and approves over-limit actions with a phishing-resistant passkey. The human root of trust every agent action traces back to.
Customer's systems
The customer's own; stand-ins in the demo.
AI agent
Runs autonomously. Holds its own key and signs every call (proof-of-possession). Never holds a long-lived secret.
Workload identity issuer
Gives the agent a workload token (OIDC / SPIFFE). IDefy trusts it as a registered external issuer, verified over WebPKI.
Payments API
The protected upstream. Reachable only through IDefy over mutual TLS, and re-checks the permission slip itself.
IDefy — the product
What you're actually buying.
Portal & Admin passkeys
One place for people to approve what agents may do — and for you to set who can delegate and to pull the plug.
Mint
The agent carries a short-lived pass tied to its own key, not a standing secret — nothing lasting to steal, leak, or forget to rotate.
Gateway (the front door)
Every call the agent makes is checked — who it is, what it's allowed, and how much is left — so it can never quietly exceed what it was given.
Budget ledger
A ceiling on what the agent can spend, per action and over time — and restarting or re-creating the agent can't wind the meter back.
Evidence chain
A signed, hash-chained record of every decision — so you can prove exactly what each agent did, show the record wasn't altered, and verify it yourself offline.
The person consents, once, on a passkey
Approving freezes the limits: up to $X per action and $Y in total. What they sign is exactly what they see.
Person → IDefy Portal
The agent gets a key-bound permission slip
It fetches a workload token from the issuer, and IDefy's Mint exchanges it for a short-lived grant bound to the agent's own key.
AI agent → Issuer → IDefy Mint
Every call goes through the gateway
The agent sends the grant, a fresh proof, and the amount. The gateway checks grant, proof, scope, tier, and budget before anything happens.
AI agent → IDefy Gateway
Under the limit → it pays, on its own
The gateway forwards the call to the Payments API over mutual TLS, and writes a signed record. No human needed for routine work.
IDefy Gateway → Payments API
Over the limit → it holds for the person
The gateway does not pay. It pauses and asks the person to approve this exact action on their passkey. Only then does the call proceed. Deny, and it never happens.
IDefy Gateway → Person (passkey) → Payments API
Every decision is recorded
Permit or deny, and why, lands in the tamper-evident evidence chain. The kill-switch is one click away, and it denies the very next call.
IDefy Gateway → Evidence chain
Consent, once
The person approves the agent on a passkey, freezing a per-action cap and a total cap.
Bounded autonomy
Under the per-action cap, the agent pays on its own — checked on every call, recorded every time.
The approval gate
A payment over the cap pauses and asks the person to approve that exact action on a passkey.
The running-total wall
Small payments add up to the total cap, then stop — and the wall survives re-creating the agent.
The kill-switch
Revoke, and the very next call is denied. No secret rotation, no waiting for a token to expire.
The evidence
Every decision is a signed, tamper-evident record the security team can verify independently.
Real IDefy product
Mint, gateway, tiers, budgets, the passkey approval, the evidence chain, the resource-side backstop, and the kill-switch.
Customer's own systems
The identity issuer and the payments API, verified over WebPKI. In production these are the customer's own; here they're stand-ins on the customer host.
Not in Demo 1
Hosted identity issuance, credential vaulting, and estate discovery — on the roadmap.
Today you bring the agent's identity and we verify it. Next, a lightweight IDefy gateway running beside your agents removes even that step — and brokers the credential too.
Attest, no issuer needed
The gateway proves each workload from its own platform (Kubernetes, cloud) — no identity issuer for you to run.
Broker the credential
It injects the downstream credential just-in-time, so the agent holds no secret and your static keys stop being something you copy around.
Hosted, or run it yourself
The same gateway runs in IDefy's cloud, or inside your network for on-premises agents and apps.
The governance never changes — budgets, the human approval, one-switch revoke, and the tamper-evident record are identical. The gateway just makes identity a non-issue: we attest it, or accept the one you already have.
IDefy — bound & proven authority for AI agents · Demo 1 of the agent-governance series