Internet-Draft Open Action Record (OAR) November 2026
Malhotra Expires 22 May 2027 [Page]
Workgroup:
Supply Chain Integrity, Transparency, and Trust
Internet-Draft:
draft-malhotra-scitt-oar-00
Published:
Intended Status:
Informational
Expires:
Author:
R. Malhotra

Open Action Record (OAR): Authority, Approval and Outcome Evidence for AI Agent Actions

Abstract

Several profiles record what an AI agent was asked to do, and the decision taken, as signed statements registered with a transparency service. Protocols for agent identity and delegated authorization say whether an agent may ask. After an incident or in a dispute, three further questions decide the case: were the authorizations the action relied on still valid when it committed, did a named person approve this exact action, and did the action change the system of record as recorded?

This document defines evidence that any agent action profile can add to answer them: an authority set that binds the digests of the outside authorizations an action relied on to that one action, with a re-check recorded at the moment it commits; an approval binding that ties a person's confirmation, by a passkey or an outside approval service, to the exact action and to what the person was shown; salted commitments to the affected state before and after execution; an outcome confirmation made by reading the system of record; and three outcome classes a relying party can act on. Values are hidden behind salted commitments and can be disclosed field by field. The constructions are implemented in the Open Action Record (OAR) format, with three verifiers that agree on published test vectors.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 22 May 2027.

▲

Table of Contents

1. Introduction

AI agents increasingly take consequential actions through tools: payouts, transfers, changes to payee bank details, account recovery, refunds and changes to production systems. Signed receipts of those actions are emerging in several forms ([I-D.farley-acta-signed-receipts], [I-D.noa-scitt-ai-agent-receipt], [I-D.mih-scitt-agent-action-capsule]), and the SCITT architecture [RFC9943] provides a Transparency Service that registers Signed Statements and returns Receipts. Separately, protocols such as [I-D.hardt-oauth-aauth-protocol] and OAuth 2.0 Rich Authorization Requests [RFC9396] let an agent carry a delegated authorization for a specific kind of action.

A party that later relies on the record of an action (a customer in a dispute, an auditor, an insurer, a bank's fraud team, a regulator) needs to join these pieces. Two joins matter:

  1. Authority to action. Which outside authorizations, sessions, mandates and approvals this action relied on, bound to this one action rather than to the agent or the session in general, and whether each was still valid at the moment the action committed rather than only when it was decided.
  2. Action to outcome. What the action changed in the system of record, beyond the claim that it "executed", and whether a later read of that system agrees.

Between decision and commit there is a window. A token can be revoked, a session can end, a SIM can be swapped, a mandate can expire. A record that shows only that the authorization was valid at decision time does not show that the action was still authorized when it ran. Equally, an approval that proves only that a person authenticated does not show what that person approved.

This document addresses these gaps. It does not define a new receipt envelope, a new authorization protocol or a new approval method. It defines fields and checks that compose with existing agent action profiles and authorization protocols. Which authority takes precedence when several apply is the receiving party's policy and is out of scope; this document makes the policy that was applied checkable afterwards.

1.1. Requirements Language

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

1.2. Terminology

This document uses the terms Issuer, Signed Statement, Transparency Service and Receipt as defined in [RFC9943]. In addition:

Action:
One requested operation by an agent on a system, for example one payout. An action has a decision and may have an approval, an execution and a confirmation.
Action statement:
A Signed Statement about one step of one action, as defined by an agent action profile.
Decision statement:
The action statement that records whether the action is allowed, held for a person, or denied.
System of record:
The system the action changes, for example a payment processor, a core banking system, an identity provider or a database.
Authority:
An artifact from outside the Issuer that the decision relied on: a delegated authorization token, an OAuth grant with authorization details, a session, a payment mandate, a device or SIM check, or an outside approval service's result.
D(x):
"sha256:" followed by the lower-case hexadecimal SHA-256 digest of the JSON Canonicalization Scheme [RFC8785] serialization of the JSON value x.
Commitment:
C(v, s) = D({"salt": s, "value": v}), where s is 32 bytes from a cryptographically secure random generator, in lower-case hexadecimal.
Disclosure:
A pair (s, v) that opens a commitment.
Instance commitment:
A commitment to the exact action instance: its type, its parameters and its idempotency key.
Relying party:
Any party that verifies the statements of an action and acts on them.

Times are [RFC3339] timestamps in UTC.

2. Commitments and Selective Disclosure

Statements defined here MUST NOT carry amounts, account or payee identifiers, addresses, email addresses, customer identifiers or other personal data in clear. Each such value is carried as a commitment C(v, s). A verifier given a disclosure (s, v) checks that C(v, s) equals the committed value. Salts MUST NOT be reused across values. A fresh 32-byte salt makes commitments to small value spaces, such as amounts, infeasible to guess.

Salts and values SHOULD be stored apart from the statements. Deleting every copy of a value's salt and value leaves the commitment impossible to open, while every statement still verifies. This lets an operator keep statements for as long as record-keeping rules require while erasing the personal data behind them.

3. Lifecycle of an Action

The statements of one action are linked: each statement after the first names the statement it follows (in OAR, the field decision_ref). The lifecycle is:

  1. Decision: allowed, held, or denied, with reason codes and a digest of the rules that decided. A decision MAY carry an authority set (Section 4).
  2. Approval (optional): approved, rejected, or expired, for a held action, with approval evidence (Section 5).
  3. Execution: executed, failed, or refused. Refused means the action did not run because an authority it relied on changed before it committed (Section 4.2). An executed statement SHOULD carry state commitments (Section 6.1).
  4. Confirmation: confirmed or not_confirmed, from a read-only check of the system of record (Section 6.2).

An Issuer SHOULD NOT execute an action whose decision could not be registered, and MUST NOT execute one whose authorities could not be checked again at commit (fail closed).

4. Authority Set

4.1. At Decision

A decision statement MAY carry "authorities", a non-empty array listing each authority the decision relied on:

"authorities": [
  {
    "type": "aauth",
    "issuer": "https://auth.example",
    "digest": "sha256:<hex of the artifact's bytes as received>",
    "not_before": "2026-11-18T14:00:00Z",
    "expires_at": "2026-11-18T14:15:00Z",
    "checked_at": "2026-11-18T14:02:11Z",
    "status": "valid"
  }
]
type:
REQUIRED. The kind of artifact, for example "aauth", "oauth-rar", "session", "mandate", "sim-check". Verifiers treat unknown types as opaque.
issuer:
REQUIRED. A stable identifier of who issued the artifact, such as a URL. Not personal data.
digest:
REQUIRED. "sha256:" followed by the hexadecimal SHA-256 digest of the artifact's bytes exactly as received. The artifact itself is not in the statement.
not_before, expires_at:
OPTIONAL. The artifact's own validity window.
checked_at:
REQUIRED. When the Issuer checked the artifact.
status:
REQUIRED. What the check found: "valid", "expired", "revoked", "invalid" or "unknown".

A decision with result allowed, and an approval with result approved, MUST NOT rely on an authority whose status is not "valid". An authority recorded as "valid" MUST be inside its validity window at its checked_at time. Because the decision statement is signed and registered, the set cannot be changed later without detection.

The authority set binds each artifact to the one action through the decision statement's instance commitment. An artifact that is reused for a different action appears in that action's own set, so reuse is visible to an auditor holding both.

4.2. Re-check at Commit

Immediately before the action commits, the Issuer checks every authority in the set again (for example, by token introspection, a revocation list, a session lookup, or a call to the approval service) and records the result on the execution statement:

"authority_check": {
  "checked_at": "2026-11-18T14:04:02Z",
  "set_digest": "sha256:<hex>",
  "result": "current"
}
  • set_digest is D({"v": 1, "purpose": "oar.authorities", "authorities": A}), where A is the authorities array of the nearest earlier statement of the same action that carries one. The re-check thereby names exactly the set it covers.
  • result "current" means every authority was still valid at checked_at. The execution result is then executed or failed.
  • result "changed" means at least one authority had expired, been revoked or become invalid. The action MUST NOT run; the execution result is refused, and the statement MAY carry "changes": an array of {"index", "status"} naming which authorities changed. The reason code is authority_revoked, authority_expired or authority_invalid.
  • An action whose decision carries an authority set MUST NOT be recorded as executed without an authority_check.
  • If an authority cannot be checked at commit, for example because its issuer cannot be reached, the action is refused with reason authority_invalid or system_unavailable.

This document records what was checked, when, and with what result. It does not define how each kind of artifact is checked; that belongs to the protocol that issued it.

4.3. Evidence from the Authority

Where an authority's issuer answers the re-check with something verifiable, such as a signed token introspection response [RFC9701] or a signed status from an approval service, the Issuer SHOULD record it in the authority_check, so that the re-check does not rest on the Issuer's word alone:

"evidence": [
  { "index": 0,
    "format": "jwt-introspection",
    "digest": "sha256:<hex of the answer's bytes as received>",
    "id": "<optional identifier>" }
]

index is the authority's position in the set, from 0. The Issuer MUST keep each answer so that it can be disclosed. A relying party holding an answer checks its digest, its signature by the authority's issuer, that it concerns the artifact whose digest is in the set, and that it was made close to checked_at.

4.4. Several Authorities

An action can rely on several authorities at once, for example a delegated token and an outside approval. When they disagree, which one prevails is the receiving party's policy. The statements show each authority, its status at decision and at commit, and the result, so the policy that was applied can be checked afterwards. A conflict that the policy did not allow is recorded with reason code authority_conflict.

5. Approval Evidence

An approval statement records a person's decision on a held action: the method ("passkey", "external", "button" or "standing_mandate"), a stable approver reference (not an email address), and the time.

5.1. What the Approver Was Shown

The Issuer MAY commit to the text and values displayed to the approver, for example {"text": "Pay $48,000.00 to payee P-1002", "amountCents": 4800000, "payee": "P-1002"}, and carry the commitment as display_commitment. Payment rules that require dynamic linking ask for this: the payer is made aware of the amount and the payee, and any change to either invalidates the authentication.

5.2. Approval Binding

Before asking the approver, the Issuer computes:

binding = D({
  "v": 2,
  "purpose": "oar.approval",
  "action_id": <identifier of the held decision statement>,
  "instance_commitment": <the action's instance commitment>,
  "display_commitment": <display_commitment, or null>,
  "nonce": <32 random bytes, lower-case hex>,
  "decision": "approve" | "reject"      (only when the
                                         approver's device signs
                                         the decision)
})

and records binding = {"v": 2, "nonce", "decision" (when present), "digest": binding} in the approval statement. A nonce MUST NOT be reused, and a binding is valid for one approval statement only.

Passkey:
The WebAuthn [WEBAUTHN] challenge is the 32 bytes of the binding digest, base64url-encoded, with one challenge per decision. The Issuer MUST verify the assertion (origin, relying party identifier, user verification, signature counter) before recording the decision, MUST keep the full assertion so that it can be disclosed, and records its digest. A verifier given the assertion and the approver's credential public key can check that the approver's authenticator signed this decision on this action instance, as displayed.
External:
A bank app, a SIM or device check, a digital identity wallet or another service confirms the approver. The Issuer sends the binding digest to the service, which SHOULD include it in its proof. The statement MUST carry the binding and evidence = {"provider", "format", "digest", "id" (optional)}, where digest is the SHA-256 digest of the proof's bytes exactly as received. The Issuer MUST keep the proof so that it can be disclosed.
Button:
A decision made in an authenticated session without an authenticator assertion. Verifiers SHOULD treat it as weaker evidence.

Every verifier recomputes the binding. An Issuer then cannot record a binding made for another action, change what the approver was shown after the fact, or record "approved" where the approver's device signed a rejection, without verification failing.

6. Outcome Evidence

6.1. State Commitments on Execution

An execution statement SHOULD carry commitments to the affected state read just before and just after the change, and to the system's identifier for what changed:

"state_before_commitment": "<C(state read just before)>",
"state_after_commitment":  "<C(state read just after)>",
"target_ref_commitment":   "<C(identifier of what changed)>"

The state is the minimal projection of the system of record that the action type changes. For example: a payout, the payee and the amount paid; a change of payee bank details, the payee's account reference; an account recovery, the account's sign-in methods; a database delete, the row count and primary keys. Profiles SHOULD document a projection per action type.

6.2. Outcome Confirmation

After execution, the Issuer (or another party with read access) reads the system of record, read-only, and registers a confirmation statement whose result is confirmed, or not_confirmed with reason outcome_missing or outcome_mismatch. A not_confirmed result MUST be registered as well. A missing confirmation is itself a signal, and verifiers SHOULD report it.

6.3. Outcome Classes

So that a relying party can act on an outcome without being given any value, verifiers SHOULD report each action in one of three classes:

committed:
The outcome is confirmed: the action ran and the system of record shows the change.
refused:
The outcome is denied, rejected, expired or refused: the action did not run, and the statements show why.
unresolved:
Any other outcome: held, approved without a recorded execution, failed, executed without confirmation, or not_confirmed.

Only committed means the change is known to have happened. A relying party SHOULD treat unresolved as not done until a later statement resolves it.

7. Reason Codes

Statements carry short, stable reason codes. Verifiers MUST treat unknown codes as opaque. Where one of the following fits, Issuers SHOULD use it, so that statements from different systems read the same way:

new_payee:
The payment goes to a payee not paid before.
payee_details_changed:
The action changes a payee's bank or payout details.
identity_change_requires_approval:
The action changes who controls an account (an email address, a phone number, a sign-in method).
velocity_exceeded:
Too many actions of this kind in a short period.
system_unavailable:
A check, the Transparency Service or an approval service could not be reached, so the action did not run.
rules_changed_since_decision:
The rules changed between decision and execution.
outcome_differs_from_approval:
What changed differs from what the person approved.
authority_revoked, authority_expired, authority_invalid:
An authority changed before the action committed, so it did not run.
authority_conflict:
Authorities the action relied on disagreed, and the receiving party's policy did not allow the action.

8. Verification

In addition to checking each statement's signature and its Receipt (or its coverage by a signed checkpoint), a verifier:

  1. Groups the statements of each action by following the reference to the previous statement back to the decision.
  2. Given disclosures, checks each commitment.
  3. For each approval carrying a binding, or with method external: checks that the binding version is 2, the nonce is 64 lower-case hexadecimal characters, and recomputing the binding from the held decision's identifier, the instance commitment, the display commitment, the nonce and the decision gives the recorded digest; that a signed "approve" is recorded as approved and a signed "reject" as rejected; and that an external approval carries evidence with a provider, a format and a SHA-256 digest. Given the assertion or proof, it also checks that it confirms the binding.
  4. For each statement carrying an authority set: checks that every entry is well formed; that no entry recorded as valid was outside its validity window at its checked_at time; and that an allowed or approved result relies only on valid entries.
  5. For each execution statement carrying an authority_check: checks that an earlier statement of the action carries an authority set; that recomputing its set digest gives set_digest; that a "current" check names no authority that had expired by its checked_at time and is not on a refused statement; and that a "changed" check is on a refused statement; and that each evidence entry names an authority in the set and carries a format and a SHA-256 digest. An executed statement whose action carries an authority set but no authority_check fails.
  6. Reports each action's outcome and outcome class.

Given an authority artifact, a relying party can check that its digest appears in the action's set, and so that the action relied on that artifact and on no other of its kind unless also listed.

9. Registration with a Transparency Service

Statements defined here are Signed Statements in the sense of [RFC9943]. They SHOULD be registered with the same Transparency Service as the action statements they extend, so that one inclusion proof or checkpoint covers the whole lifecycle of an action. Where an action is already recorded in another receipt format, the Issuer can carry the fields defined here in statements that reference that receipt by digest, rather than replacing it.

A COSE encoding and a SCITT registration policy for these statements are left for a future revision, in coordination with the agent action profiles cited above.

10. Implementation Status

Note to the RFC Editor: please remove this section before publication, as described in [RFC7942].

The Open Action Record (OAR) format [OAR] implements every construction in this document, with JSON statements, JCS canonicalization [RFC8785], Ed25519 [RFC8032] signatures, optional countersignatures from a separately operated sealing service over a hash-chained log with signed checkpoints, and optional [RFC3161] timestamps on those checkpoints.

11. Open Questions

The author would welcome discussion of the following, ahead of a next revision:

  1. Delegation across agents. When one agent hands a task to another, how the authority set should record each hop and the narrowing of rights at each step, in line with the delegation models of [I-D.hardt-oauth-aauth-protocol] and OAuth token exchange.
  2. COSE encoding and registration. A COSE_Sign1 encoding of these statements and a registration policy for a SCITT Transparency Service, so that they can be registered alongside other agent action profiles.
  3. Evidence formats. Which authority answers are common enough to name (for example [RFC9701] introspection responses), and whether the re-check should be made by the authority's issuer directly.
  4. Precedence. Whether a common way to state which authority prevails is useful, or whether recording the receiving party's policy by digest, as now, is enough.
  5. Alignment with other profiles. Whether the fields defined here are better carried as an extension of an existing agent action profile.

12. Security Considerations

Window between re-check and commit:
The re-check narrows, but does not close, the window in which a revoked authority can still be used: the time between authority_check.checked_at and the commit. Issuers SHOULD keep it short and record the re-check as close to the commit as their systems allow. Where the system of record supports it, the re-check and the commit SHOULD be made atomic.
Trust in recorded statuses:
Statements carry digests of authority artifacts and the Issuer's record of their status, not the artifacts. A relying party can check that a given artifact is the one relied on. Without evidence from the authority (Section 4.3), it trusts the Issuer's report of each check; with it, the re-check can be verified against the authority issuer's own signed answer.
Approval binding:
Without the binding, an authenticator assertion or an outside approval proves only that the approver authenticated, not what they approved. The display commitment prevents an Issuer from claiming afterwards that the approver saw different details.
State reads:
The before and after reads are made by the Issuer. A compromised Issuer could record false state. The outcome confirmation, reproducible by any party with read access to the system of record, limits this; profiles MAY have the confirmation made by another party.
Same operator:
A sealing service run by the same organization as the Issuer protects against changes by others, but not against the operator holding both keys. Countersignatures or timestamps from another party give stronger assurance.
Withholding:
A verifier given a subset of statements can detect omissions only up to the latest checkpoint.
Time:
Times are claims of the Issuer and the sealing service. Outside timestamps [RFC3161] bound them from above.

13. Privacy Considerations

All values are committed with fresh salts. Authority sets carry digests and issuer identifiers, not tokens, which may contain personal data and SHOULD be disclosed only to parties that need them. Approver references are stable identifiers, not personal data in clear. Assertions and outside approval proofs may contain personal data and SHOULD be disclosed only to verifiers that need them. Erasure is achieved by deleting the openings of commitments, not the statements (Section 2).

14. IANA Considerations

This document has no IANA actions. A future revision may register statement content types, authority types and reason codes.

15. References

15.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC3339]
Klyne, G. and C. Newman, "Date and Time on the Internet: Timestamps", RFC 3339, DOI 10.17487/RFC3339, , <https://www.rfc-editor.org/info/rfc3339>.
[RFC8032]
Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital Signature Algorithm (EdDSA)", RFC 8032, DOI 10.17487/RFC8032, , <https://www.rfc-editor.org/info/rfc8032>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/info/rfc8785>.
[RFC9943]
Birkholz, H., Delignat-Lavaud, A., Fournet, C., Deshpande, Y., and S. Lasker, "An Architecture for Trustworthy and Transparent Digital Supply Chains", RFC 9943, DOI 10.17487/RFC9943, , <https://www.rfc-editor.org/info/rfc9943>.
[WEBAUTHN]
W3C, "Web Authentication: An API for accessing Public Key Credentials, Level 3", <https://www.w3.org/TR/webauthn-3/>.

15.2. Informative References

[I-D.farley-acta-signed-receipts]
"Signed Decision Receipts for Machine-to-Machine Access Control", Work in Progress, Internet-Draft, draft-farley-acta-signed-receipts-03, , <https://datatracker.ietf.org/doc/draft-farley-acta-signed-receipts/>.
[I-D.hardt-oauth-aauth-protocol]
Hardt, D., "AAuth Protocol", Work in Progress, Internet-Draft, draft-hardt-oauth-aauth-protocol-11, , <https://datatracker.ietf.org/doc/draft-hardt-oauth-aauth-protocol/>.
[I-D.mih-scitt-agent-action-capsule]
Mih, S., "An Agent Action Capsule Profile for SCITT", Work in Progress, Internet-Draft, draft-mih-scitt-agent-action-capsule-05, , <https://datatracker.ietf.org/doc/draft-mih-scitt-agent-action-capsule/>.
[I-D.noa-scitt-ai-agent-receipt]
Toraman, T., "A SCITT Profile for AI-Agent Action Receipts", Work in Progress, Internet-Draft, draft-noa-scitt-ai-agent-receipt-01, , <https://datatracker.ietf.org/doc/draft-noa-scitt-ai-agent-receipt/>.
[OAR]
Open Action Record project, "Open Action Record (OAR) specification", , <https://github.com/openactionrecord/oar>.
[RFC3161]
Adams, C., Cain, P., Pinkas, D., and R. Zuccherato, "Internet X.509 Public Key Infrastructure Time-Stamp Protocol (TSP)", RFC 3161, DOI 10.17487/RFC3161, , <https://www.rfc-editor.org/info/rfc3161>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.
[RFC9396]
Lodderstedt, T., Richer, J., and B. Campbell, "OAuth 2.0 Rich Authorization Requests", RFC 9396, DOI 10.17487/RFC9396, , <https://www.rfc-editor.org/info/rfc9396>.
[RFC9701]
Lodderstedt, T., Ed. and V. Dzhuvinov, "JSON Web Token (JWT) Response for OAuth Token Introspection", RFC 9701, DOI 10.17487/RFC9701, , <https://www.rfc-editor.org/info/rfc9701>.

Mapping to Open Action Record

Table 1
This document OAR record field
Decision statement phase "decision", result allowed, held or denied
Authority set authorities (SPEC section 4.5)
Approval statement phase "decision", result approved, rejected or expired, with approval.binding, approval.display_commitment and approval.evidence (SPEC section 4.3.1)
Re-check at commit authority_check on phase "execution"; result refused
State commitments state_before_commitment, state_after_commitment, target_ref_commitment
Outcome confirmation phase "confirmation", result confirmed or not_confirmed
Reference to the previous statement decision_ref
Transparency Service receipt the sealing service's seal and signed checkpoints

Acknowledgments

The authority set and the re-check at commit respond to public discussion of how agent authorization and agent receipts join. The constructions build on the SCITT architecture and on the agent receipt profiles cited above.

Author's Address

Ravish Malhotra