Design Interruption, Activity Logs and Undo

Workflow area: Agent UX · Tier: Advanced · Hands-on time: ~45 minutes

An agent working for minutes across multiple tools creates a new UX problem: the user is neither driving nor absent — they're supervising. Supervision needs three capabilities the industry keeps shipping late: the ability to intervene without destroying work in progress, a trustworthy record of what actually happened, and a way back from actions that shouldn't have happened. Shape of AI catalogs these as governance patterns; every agent post-mortem you'll ever read features at least one of them missing. This playbook designs all three as one system, because they only work together — undo without a log is unfindable, a log without undo is a confession.

When to use — and when not to

• Use it the moment any action runs unattendedthe first auto-tier action (pb-45) is the moment the log, undo and interruption stop being optional.
• Use it when agent sessions exceed ~30 secondsbeyond that, users will want to redirect mid-flight; without designed interruption they'll kill the run and lose everything.
• Use it after any trust incidentif users started asking "what did it do?", the honest answer must be a surface, not a support ticket.
• Skip full mid-run controls for atomic operationsa single quick action needs undo and a log entry, not a pause button for a two-second task.
• Skip building your own undo where platform undo existsif the agent works inside a document with native history, integrate with it; a second competing undo stack confuses everyone.

The recipe

1. 1.

   Design the four interruption verbs. Mid-run control is not one stop button; spec each verb separately:

   • •
     Pause — freeze after the current atomic action completes; state preserved; resume available. Never pause mid-write to an external system.
   • •
     Redirect — the user adds instruction mid-run ("skip the pricing section"); the agent revises the remaining plan, shows the diff, continues on confirm.
   • •
     Edit the plan — reopen the pb-45 plan view mid-run; completed steps locked, pending steps editable or removable.
   • •
     Stop and summarize — abort remaining work, keep everything completed, emit a summary: did, didn't do, was about to do, plus any cleanup needed. Stopping must never punish the user by discarding finished work.
2. 2.

   Spec the activity log as evidence, not narrative. Every action the agent takes writes one entry at completion time, containing: timestamp, action verb and object ("Sent email to Priya R."), the tier it ran at (auto or approved — and who approved), provenance (what caused it: the plan step, the user instruction, or a triggering event), the input it acted on, and a link to the artifact produced. The log is append-only and survives the session. Then generate your edge cases:

   Copy

   You are designing an agent activity log. Here is my entry schema:
   [PASTE SCHEMA]
   Agent actions: [PASTE ACTION LIST from the autonomy map]
   
   1. For each action, write a realistic log entry a non-technical
      user can read in under 5 seconds.
   2. List 10 edge cases the schema must handle: partial failures,
      retries, actions rolled back by undo, actions taken then
      superseded, bulk operations (50 files), external-system
      failures after the agent reported success.
   3. For each edge case, show the log entry (or entries) that make
      the truth reconstructable.
   Plain language, no internal jargon in user-facing strings.
   

   The bulk-operation and retry cases are where naive schemas collapse — one user-visible entry summarizing fifty file renames, expandable to the fifty, beats both extremes.

3. 3.

   Classify every action into an undo class — and label it in the UI. Three classes: true undo (the system can restore prior state exactly — file edits, created events), compensating action (can't unsend, but can send a correction; can't un-notify, but can retract), and irreversible (money moved, message read). Each log entry displays its class as an affordance: an Undo button, a "Send correction…" action, or an honest "Can't be undone" label. Never render an Undo button that performs a compensation — users must know which one they're getting before they rely on it.

4. 4.

   Wire undo to demotion. Every undo is a signal the tier map was wrong for that user: one undo prompts "Want me to ask first next time?"; repeated undos of the same action demote it automatically (pb-45's ratchet). Spec this linkage explicitly — undo data that doesn't feed autonomy calibration is wasted trust telemetry.

5. 5.

   Prototype the supervision surface in Figma Make. One live view: current plan with progress, the interruption verbs, and the log accumulating beneath. Test with a scenario script: mid-run, ask a participant to make the agent skip a step, then undo something it already did. If they can't do both in under 30 seconds without help, the surface failed.

Make it yours

• Claude as post-mortem simulator: paste your log schema and ask it to roleplay an angry user demanding "what did your agent do to my calendar last Tuesday?" — if the log entries can't answer every question in the transcript, extend the schema.
• Shape of AI pattern audit: compare your interruption and log design against how Claude Code, Cursor and a workflow tool like Zapier surface agent activity — steal the best affordance from each (inline diffs, run history, per-step retry).
• Multi-agent products: add an actor column — which agent did what — and design the log's filter-by-agent view; undo semantics get sharper too, since one agent may depend on another's output.

Quality check

• Stop never discards completed workstop-and-summarize preserves and reports; only pending work is cancelled.
• Every log entry answers who, what, when, why, at-what-tierprovenance included; an entry that can't say why the action happened is a liability, not a record.
• Undo classes are visually distincttrue undo, compensation and irreversible are impossible to confuse at a glance.
• The log survives the sessiona user can answer "what happened last Tuesday" without having been present.
• Bulk operations summarize then expandfifty actions read as one line first, fifty on demand.
• Undo feeds the autonomy ratchetrepeated undos demote the action's tier without the user visiting settings.
• The 30-second supervision test passeda fresh user redirected the agent and undid an action without coaching.