Action Receipts: Showing Users What an Agent Changed and Why
Action receipts make agentic work inspectable by recording what changed, where, when, with which tool, and how to verify or reverse the result without exposing hidden reasoning.
An action receipt closes the gap between conversation and reality
Agent systems can execute multiple tools across a run, so the final natural-language response is not always enough to reconstruct what happened. OpenAI’s agent observability guidance emphasizes traces that reveal tool calls, handoffs, and approvals across a workflow. [1] A user-facing action receipt is the product counterpart: a concise record of external changes caused by the agent. For motivational systems, this prevents the user from confusing a plan, an attempted action, and a confirmed outcome. A receipt says what changed in the world, not merely what the assistant claims it accomplished.
Receipts make progress auditable
A completion badge is more trustworthy when the user can inspect the event, task, message, or record that justifies it.
Receipts should explain causal inputs without inventing inner reasoning
Microsoft recommends making clear why an AI system did what it did while warning that explanation design can create over-trust. [2] An action receipt can stay grounded in observable facts: “You asked to protect Friday morning; I moved Task A to Monday using the project tool; the service confirmed the new due date.” This is better than a speculative chain-of-thought narrative. The useful explanation is the relationship among user instruction, relevant constraint, selected tool, and confirmed result.
A receipt needs target, action, result, and provenance
At minimum, receipts should identify the external system or account, the action taken, the object affected, the time, and the success state. For higher-stakes actions, include the key parameters and any approval that authorized them. The MCP tool specification recommends logging tool usage for audit purposes and describes structured tool results that clients can validate. [3] Those machine-level records can support a user-facing summary while the full trace remains available for debugging or compliance.
The user should not need a trace viewer
A receipt is a deliberately compressed view of the information needed to understand and recover from the action.
Receipts should distinguish full success from partial success
Agent workflows often span multiple tools. If the agent creates a calendar event but fails to update the task, “Done” is misleading. The receipt should list each step and its state, highlighting what still needs attention. This prevents false progress and gives the user an immediate recovery path. In gamified products, rewards should be based on the relevant confirmed outcome, not on the mere fact that the agent attempted a sequence.
Tracing is most useful when designed in from the first working run
OpenAI’s Agents SDK quickstart recommends inspecting traces early to see model calls, tool calls, handoffs, and guardrails before tuning. [4] The same principle should influence product architecture. If tool invocation IDs, timestamps, account identifiers, approvals, and structured results are not retained from the start, reliable receipts are hard to create later. Observability should be part of the action contract, not an afterthought added when a user disputes what the agent changed.
Build the evidence path before the trust problem appears
A system cannot produce credible receipts if it failed to record the underlying action state.
Receipts should offer direct correction where possible
A useful receipt is actionable: undo this change, open the external record, retry the failed step, change the standing permission, or report a problem. This turns transparency into control. A static history log may satisfy audit needs but still leave the user stranded. For motivation design, the correction path is especially important because an unwanted automated action can derail the user’s plan. Recovery should be available from the same surface that reports the change.
Privacy determines how much detail a receipt should expose
Receipts can themselves contain sensitive information: health goals, private messages, financial amounts, or workplace data. They should therefore be scoped to the viewer and avoid copying more external content than needed to identify the action. Anthropic’s trustworthy-agent framework includes transparency and privacy together, not as opposing afterthoughts. [5] The right receipt reveals enough to verify the action without turning logs into a secondary data leak.
Transparency should be selective, not indiscriminate
The goal is accountable action, not maximal exposure of every intermediate datum.
Action receipts make autonomous progress feel earned rather than magical
When an agent acts on a user’s behalf, the product should leave a trail that the user can understand. Receipts create continuity between intention, delegated execution, and confirmed outcome. They also improve debugging, disputes, correction, and permission review. In a gamified experience, this preserves the meaning of progress: points, streaks, and milestones can be connected to actual changes rather than conversational theater. The mature agent does not simply say “I handled it.” It shows what it handled, where the evidence lives, and what the user can do next. Receipts also create a valuable learning loop for the user. Over time, a history of actions can show which delegations save effort, which ones are frequently undone, and where the agent needs more explicit constraints. That history should be filterable and understandable rather than becoming an endless technical log. A weekly review might summarize “three events created, one rescheduled, one task update failed and was retried.” This turns observability into practical feedback about the collaboration itself, helping users refine how much authority they want to delegate.
Works Cited
- 01OpenAI Developers — Integrations and Observability developers.openai.com
- 02
- 03Model Context Protocol — Tools Specification modelcontextprotocol.io
- 04OpenAI Developers — Agents SDK Quickstart developers.openai.com
- 05Anthropic — Trustworthy Agents in Practice anthropic.com
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.