How to verify an AI agent's action actually succeeded
Have a party independent of the agent and of the service that sent the command โ a meter, a protection relay, a measured-boot attester โ sign what it observed, bound to the hash of the approved action, and keep that statement in the same tamper-evident record as the approval. Your own logs say what your system believes it did; a third party needs an observation your system could not have written. A confirmed status means a trusted source signed an observation of the approved effect, not that the effect is physically proven; a compromised or misconfigured source can sign a false observation.
Approval and execution are different facts
A signed approval proves a person approved exact bytes. It says nothing about whether the action then took effect: the command can fail, time out, reach the wrong target or be blocked further down. Which of those happened is a separate question, and it needs a separate record.
Why your own logs are not evidence to a third party
An application log, an API response or an agent's own report is written by the party whose action is in question. To a customer, an auditor or a counterparty it is a claim, not a measurement: the system that might have failed is the one saying it succeeded, and whoever administers it can change what it says.
Tamper-evident storage solves the second problem and not the first. A perfectly preserved log of what your service believed is still only what your service believed.
What counts: a signed observation from an independent source
DEWP 1.1 defines the record. An evidence source โ a party independent of the one that sent the command, such as a protection relay reporting breaker position or a measured-boot attester reporting the firmware that actually booted โ signs an Execution Evidence Statement. It names the approval's nonce and the SHA-256 of the approved payload, so it cannot be moved to another approval, and carries the verdict, the observation, when the measurement was sampled and a gapless sequence number that exposes a withheld statement.
{
"approval": {
"nonce": "4f6c1c9e-1b8a-4e2f-9d3a-7c2b5e8f0a1d",
"payloadSha256": "5d1fโฆ(64 lowercase hex)โฆ"
},
"observation": { "breaker": "open", "currentA": 0, "previousCurrentA": 412 },
"observedAt": "2026-10-05T14:02:11.000Z",
"sampledAt": "2026-10-05T14:02:09.500Z",
"sequence": 418,
"source": "did:example:relay-7",
"type": "dewp-execution-evidence",
"v": 1,
"verdict": "confirmed"
}How the pieces fit
- The executing service verifies and consumes the approval, then sends the command.
- It reports the dispatch and how long the source has to answer. The ledger records an EXECUTION_DISPATCHED entry.
- The evidence source observes the effect and signs a statement with its own P-256 key, which an administrator registered in advance.
- Your service relays the statement. INTYGA relays statements and never writes a confirmation itself.
- The accepted statement is committed to the same tamper-evident log as the approval, signature included, so it verifies offline with no INTYGA secret.
// 1. YOUR executing service: the approval is verified and consumed, the command has been sent.
await intyga.reportDispatched(nonce, { evidenceWithinSeconds: 300 });
// 2. The evidence source: a separate system with its own registered P-256 key.
import { buildExecutionEvidence, signExecutionEvidence } from "@intyga/sdk";
const statement = buildExecutionEvidence({
approvalPayload, // the approved DIV payload bytes; their SHA-256 binds the statement
nonce,
source: "did:example:relay-7",
verdict: "confirmed", // or "contradicted"; a source that cannot decide does not sign
observation: { breaker: "open", currentA: 0 },
sampledAt, // when the measurement was taken; the window is judged on this
sequence: await nextSequence(), // durable, gapless, one counter per log
});
const signature = signExecutionEvidence(statement, SOURCE_PRIVATE_KEY);
// 3. YOUR service relays it. It cannot write one itself: it does not hold the source's key.
const result = await intyga.submitEvidence(nonce, { statement, signature });
// result.executionStatus: "confirmed" | "contradicted" | "unconfirmed" | nullRead the status the way a verifier does
From the approval, dispatch and evidence records, a verifier derives one Execution Status per approval, under its own choice of trusted evidence sources, kept separate from the approvers it trusts.
| Status | What it means | Response |
|---|---|---|
| contradicted | A trusted source observed that the approved effect did not take place. It outweighs any confirmation. | Escalate |
| confirmed | A trusted source signed an in-window statement that it observed the approved effect. | Keep the record |
| unconfirmed | The window closed with no qualifying statement โ often a lost or stale sensor. | Investigate |
| pending | The action was dispatched and the window is still open. | Wait |
| not_reported | No dispatch was ever reported for the approval. | Find out whether it ran |
Offline, the verifiers in all five languages derive the same status from an exported evidence bundle, under the evidence-source trust the caller supplies โ never from INTYGA's bookkeeping.
What this does not prove
- Physical truth. confirmed means a source you trust signed an observation. A compromised, misconfigured or mis-wired source produces a genuine signature over a false observation, so trust only sources whose observations are independent measurements, and claim no more than they support.
- That no statement was withheld before commitment. The sequence counter exposes a statement missing from inside an exported range; it does not expose a source that stopped signing.
- Anything for offline approvals or platform receipts. In this revision they are not Approval Records, so actions approved through them cannot be dispatched or confirmed this way.
- Anything about the approval. Execution evidence is kept after and outside it, and cannot refuse, delay or roll back an approval.
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.
This guide covers what comes after proving a human approved the action. The record format is DEWP's execution evidence section, and the integration steps are in the developer reference.
Questions people ask next
Is a success response from the target system enough?
It is useful to your own operations, but it is a response your integration received, not an observation a third party can check. If the target can sign what it observed, register its key and it can act as an evidence source.
Can the agent or our own service mark an action as confirmed?
No. Only a statement signed by a registered evidence source counts, and the service relaying it does not hold that key. INTYGA relays statements and never writes a confirmation itself.