Skip to content

Govern

Agent Action Transparency

What actions is the AI agent taking?

Makes an autonomous agent's actions visible before, during, and after it runs, so oversight stays possible.

  • Evidence: research-based (Amershi et al. 2019, Endsley 1995)
  • Tested: concept only, mock data

Overview

Why it matters

You gave it one sentence. It made twenty decisions you never saw.

An AI agent sends an email, books a meeting, changes a file, makes a purchase. By the time you notice, it's done. Logs may exist, but nobody designed the experience of watching an agent act.

Human-in-the-Loop assumes review before action. Audit Trail & Logging serves review afterwards. This pattern covers the part in between: making autonomous action readable for the person who asked for it.

What does it look like?

Task authorization and execution review
  1. User asks agent to "find all invoices from last quarter and create a summary report."
  2. Agent shows pre-execution plan: "I'll search your email for invoices, download attachments, extract totals, and create a Google Doc. I will not send or share anything."
  3. User confirms.
  4. Agent executes with a live step view.
  5. Agent completes and shows action log: 4 emails found, 4 attachments downloaded, totals extracted, report created at [link].
  6. User reviews and shares the report manually.

Deviation alert
  1. User asks agent to "schedule a meeting with the Berlin team next week."
  2. Agent searches calendar, finds no availability with all team members.
  3. Agent pauses: "I couldn't find a time when all 4 members are available. I found a slot with 3 of 4 members on Wednesday at 2pm. Should I proceed with that, or suggest alternatives?"
  4. User chooses an option. Agent proceeds only with explicit direction.

Scope review
  1. User wants to understand what the agent can access.
  2. User opens the scope panel from the agent interface.
  3. User sees: "Read access to inbox, calendar, and Drive. Can create and modify drafts. Cannot send, delete, or make purchases."
  4. User adjusts scope before assigning the next task.

Undo
  1. Agent completes a task and sends a meeting invite.
  2. User reviews the action log and notices the invite went to the wrong Lisa.
  3. User clicks "Undo" on that action.
  4. System cancels the invite and shows the corrected state.

When does it fit?

Use it when

  • The system acts on someone's behalf: sends, books, changes, deletes, pays
  • It runs multi-step tasks without confirming each step
  • Actions can't be undone or affect sensitive resources

Skip it when

  • The system only writes text or recommendations
  • Every step is already confirmed by the user
  • All actions are low-stakes and fully reversible

Design

How do I apply it?

  • Make the plan a real screen.

    For multi-step or high-stakes tasks, the plan is where people stay in control. A dismissible toast is not enough.

  • Write the log for people.

    "Created a meeting with Lisa for Tuesday at 3pm", not an API call.

  • Show the scope by default.

    What the agent may do belongs in its main view, not in settings.

  • Pause on surprises.

    When something unexpected happens, ask first. Silent adaptation erodes trust, even when it was right.

  • Separate "you asked" from "it decided".

    Instructed actions and autonomous ones should look different.

  • Treat irreversible actions differently.

    Sending, deleting and paying need explicit confirmation, even in an autonomous flow.

For your technical team

Live step views require the agent to expose its internal state as it runs. Design this into the architecture from the start; it is hard to add a live view afterwards. Classify actions by reversibility and stakes so confirmation thresholds can be set per action type.

How can I show it?

Less effort More effort
Inline Signal / Indicator

Scope indicator

What the agent can and can't do right now.
Content Block / Summary

Authorization boundary summary

What it was allowed to do, next to what it did.
Content Block / Feed

Action log / activity feed

A readable list of everything it has done.
Content Block / List

Pre-execution plan view

The planned steps, to review before it starts.
Contextual Overlay / Alert

Deviation alert

A pause and a question when something unexpected happens.
Contextual Overlay / Progress View

Step-by-step progress view

What it's doing right now, not just a spinner.
Interactive Control / Button

Undo / rollback action

A visible way to take back the last action.

What does it cost?

Autonomy vs. oversight

Every confirmation makes the agent less useful. Set thresholds by stakes and reversibility.

Transparency vs. complexity

Logs of complex tasks get long. Summary first, full log on demand.

Control vs. interruption

Too many pauses defeat the purpose. Define what counts as a deviation.

Connections

Which patterns work with it?

Human-in-the-Loop

Who can review or override this decision?

HITL assumes a human reviews before action. Agent Action Transparency addresses ongoing and post-hoc visibility when the agent acts autonomously. Both are needed in agentic systems.

Audit Trail & Logging

What is the complete record of this decision?

Audit trails are for retrospective review by operators and auditors. The action log in this pattern is for the delegating user in real time. Different audiences, different design requirements.

Model Scope & Limits

What can this system reliably do?

Scope defines what the AI system is authorized and designed to do. This pattern makes what it actually did visible. The two work together: scope sets the authorization boundary, action transparency tracks whether the agent stayed within it.

Contestability & Appeal

How can I challenge this decision?

Users need to be able to challenge or undo agent actions. This pattern must provide the information that makes contestability possible.

AI Presence Disclosure

Am I interacting with an AI?

Disclosure establishes that AI is involved. Action transparency goes further: it establishes what the AI did.

Sources (4)

Turing (1950) — Computing Machinery and Intelligence

proposes the imitation game and asks the foundational question: can machines think? While not an XAI paper, it anchors the long philosophical history of the question this pattern addresses at its most practical level: what is a machine doing, and can the person it acts for understand and evaluate it?

Amershi et al. (2019) — Guidelines for Human-AI Interaction

includes guidelines specifically for AI that takes actions (G7: support efficient dismissal of unintended AI behaviors; G8: support efficient correction). These guidelines are the design specification this pattern implements

Endsley (1995) — Toward a Theory of Situation Awareness in Dynamic Systems

coins the three-level model of situation awareness: perception of environmental elements, comprehension of their meaning, and projection of future states. The pre-execution plan, live progress view, and action log together constitute the situation awareness interface this theory demands for human oversight of autonomous systems

Logg, Minson & Moore (2019) — Algorithm appreciation: People prefer algorithmic to human judgment

demonstrates that users systematically over-weight algorithmically generated recommendations relative to human ones: an effect called "algorithm appreciation." Provides the empirical basis for why agent action transparency is not optional: without visibility into what an agent did and why, users systematically extend more trust than warranted

Sounds familiar?

You moved from AI suggestions to AI agents. Your users can't see what the agent did.

Copilots, workflow automation, email assistants. That's where this pattern starts. Let's look at your interface together.

Work with me

Previous pattern

← Actionable Recourse

Next pattern

AI Presence Disclosure →