How to prove a human approved an AI agent's action
Have the person sign the exact action โ its target and parameters, not a session or a summary โ with a key they control, such as a passkey, and have the service that executes the action verify that signature against what it is about to do. The signed receipt is the proof: anyone holding the approver's public key and the expected action can check it offline, without trusting the agent, your logs or the vendor that relayed it.
What the proof has to survive
The person who asks for proof โ an auditor, a customer, an assessor, your own incident review โ trusts neither the agent, nor your application logs, nor the vendor in the middle. A log row saying an action was approved was written by the system under review, which is the party being audited. Proof has to be checkable by someone who controls none of those parties.
That rules out the three answers teams usually reach for first: an APPROVED status returned by an API, a chat message saying go ahead, and a login event showing the person was authenticated at the time.
Three things the record must bind
- Who decided. A credential bound to a named person, kept distinct from the agent that asked. The signature is made inside the approver's authenticator, and the agent's identity comes from its token, not from what the model writes.
- What was decided. The exact target, action type and parameters, in canonical bytes. An approval for one wire transfer must fail verification against another, and one changed byte must fail.
- When, and how often. An expiry and a single-use nonce, so the approval cannot be replayed later or against a second system.
What the approver signs
For an AI agent, the signed intent also names the agent's configuration digest and the session the request belongs to. This is the payload from the DIV conformance vectors (tenant-bound version 2), indented for reading. The approver's signature covers its canonical form: RFC 8785 JSON, keys sorted, no whitespace.
{
"action": { "amount": null, "reversibility": "irreversible" },
"actionType": "payments.wire",
"agent": {
"configDigest": "sha256:1111111111111111111111111111111111111111111111111111111111111111",
"delegatedBy": null,
"label": "Release agent"
},
"display": "Wire USD 4,200",
"evidence": null,
"exp": "2026-10-10T12:05:00.000Z",
"nbf": "2026-10-10T12:00:00.000Z",
"nonce": "tenant-vector-nonce",
"params": { "amount": 4200, "currency": "USD" },
"requester": { "attestation": null, "did": "did:intyga:service:release" },
"requirement": {
"allowedAaguids": [],
"requesterCannotApprove": false,
"requireHardwareKey": false,
"requiredApprovals": 1,
"signerClass": "human"
},
"session": {
"aggregate": null,
"id": "sha256:2222222222222222222222222222222222222222222222222222222222222222",
"prev": null,
"seq": "1"
},
"target": "prod-payments",
"tenantId": "tenant-alpha",
"type": "div-intent-verification",
"v": 2
}The configuration digest and session fields are assertions the relying party prepared. They protect against drift only when the executing service recomputes and enforces them, which is the next step.
Verify where the action runs
The agent carries the receipt and nonce to the service that performs the action. That service recomputes the expected action from what it is about to do, resolves approver keys from its own trust anchor, checks the receipt against its own retained context, the live agent configuration and a locked session head, and reserves the nonce before the side effect. An APPROVED status alone cannot unlock the action, and no INTYGA secret or network call is involved. The code below gates a different action than the payload above, a production database wipe; for any action, the target, action type and parameters it recomputes must be the ones the approver signed.
// YOUR service โ the one place that can actually refuse. No INTYGA secret, no gateway round-trip.
import { readFileSync } from "node:fs";
import { parseTrustAnchorFile, trustAnchorApprovers, verifyAgentForExecution } from "@intyga/sdk";
const anchor = parseTrustAnchorFile(readFileSync(process.env.INTYGA_APPROVERS_FILE!, "utf8"));
const approvers = trustAnchorApprovers(anchor);
const TARGET = "prod-db-cluster-01"; // THIS service, by the name approvals are bound to
app.post("/admin/drop-database", async (req, res) => {
const { receipt, nonce, database } = req.body; // treat all agent-supplied fields as untrusted
if (!receipt || !nonce) return res.status(403).end(); // no receipt, no action โ never "check later"
// Recompute the action from what YOU are about to do โ never from what the agent says was approved.
const action = { target: TARGET, actionType: "wipe_production", params: { database } };
// These are YOUR protected records, retained when the request was created. Never copy expected
// context, configuration or the session head from the receipt or this incoming request.
const pending = await db.pendingApprovals.get(nonce);
if (!pending) return res.status(403).end();
await db.transaction(async (tx) => {
const state = await tx.agentSessions.lockState(pending.sessionId); // head, seq, aggregate
const check = verifyAgentForExecution(
receipt,
{ ...action, nonce, approvers, requesterDid: pending.agentDid,
agentContext: pending.agentContext },
await runtimeConfigFor(pending.agentDid), // live model, tools and prompt from YOUR runtime
state,
{ expectedOrigin: anchor.webauthn?.origin, expectedRpId: anchor.webauthn?.rpId,
agentAuthorityChain: pending.authorityChain },
);
if (!check.ok) throw new Error("approval refused: " + check.reason);
await tx.redeemedNonces.insert({ nonce, expiresAt: pending.expiresAt });
await tx.agentSessions.advance(pending.sessionId, check.nextHead,
pending.agentContext.session.seq, pending.agentContext.session.aggregate);
await tx.agentBudgets.reserve(pending.agentDid, pending.agentContext.action.amount);
await tx.dropDatabase(database);
});
return res.status(204).end();
});The full contract, including trust anchors, authority chains, and the wrapper and proxy that do this at a tool boundary, is in the MCP receipt verification reference.
Keep a record a third party can check
Keep the receipt with the action it authorized. INTYGA also witnesses each approval in a tamper-evident log whose checkpoints are anchored to independent transparency logs, so a reviewer can check that a committed record was not altered afterwards. The log proves committed entries were not altered; it cannot prove that an event was never withheld from commitment.
Both halves are open specifications: DIV defines the signed intent and its offline verification, and DEWP defines the tamper-evident record.
What this does not prove
- That the action then succeeded. Approval and execution are separate records.
- That the approver understood the consequences or was right. The gate proves a person decided, not that the decision was good โ and an approver who approves everything defeats it.
- Anything about an action no person signed. A request a policy approved automatically is recorded as AUTO_APPROVED with no human signature, and verifiers refuse it by default.
- That the agent had no other way in. If the agent also holds a credential that can perform the action directly, it can bypass the approval; the executing service must hold the only credential.
For the record that comes after the approval, see how to verify an AI agent's action actually succeeded.
Where INTYGA fits
INTYGA holds high-risk actions by AI agents, pipelines and backend services until a person signs their exact parameters. The service that runs the action verifies that signature against what it is about to execute, and a tamper-evident record lets a third party check later what was approved โ not only who approved it.
Questions people ask next
Is an MFA login enough to prove a person approved an agent's action?
No. A login proves who authenticated to a session; it does not bind that person to a specific action or its parameters. The approval has to be a signature over the action itself.
Do I need INTYGA's servers to verify the receipt?
No. Verification needs the receipt, the action your service is about to execute, the expected nonce and your trusted approver keys. It runs offline, with no INTYGA secret and no network call.