Contents
  1. Directing uncertain behavior
    1. The interface is a control contract
      1. Five questions every task surface should answer
    2. Expose the intent the task requires
      1. What interaction forms expose
    3. Match the interaction pattern to the work
      1. Pattern selection
  2. Shared-control traditions
    1. How initiative became shared
      1. Must-know developments
  3. Making behavior legible
    1. Separate receipt, progress, and outcome
    2. Communicate uncertainty for the decision
      1. Cause and interface response
    3. Layer explanation, evidence, and diagnostics
      1. Three disclosure depths
  4. Control while work continues
    1. Define interruption and cancellation honestly
    2. Keep persistent delegation inspectable
      1. Persistent-control responsibilities
  5. Review, correction, and recovery
    1. Review before consequential commitment
      1. Choose review granularity
    2. Repair the smallest affected boundary
  6. From design claim to working interface
    1. Prototype the uncertain interaction
      1. What prototypes can establish
    2. Implement explicit task states
      1. A reducer rejects stale state before rendering it
  7. Testing the human workflow
    1. Evaluate use, reliance, and recovery
      1. Claims and evidence
    2. Accessibility is interaction behavior
      1. The same task across access modes
  8. Choosing controls
    1. Choose controls for the actual task
      1. A practical design review
      2. One task, conflicting constraints
  9. Check understanding
  10. Open questions
  11. Selected talks
  12. References
  13. Talk library
← All topics

AI interface design

An AI interface is how a person gives direction, understands what the system is doing and changes course. As AI moves from suggesting answers to taking actions, design must make scope, progress, review and intervention understandable. Good interaction design connects flexible model behavior to controls people can predict and use. This chapter follows the experience from expressing intent through inspecting results, correcting mistakes and deciding how much work to delegate.

Part I — Directing uncertain behavior

The interface is a control contract

A conventional function call suggests a compact contract: supply arguments, receive a result, and handle an error. An AI product usually contains more boundaries. The person expresses an intended outcome; the application assembles inputs; a model interprets them; the system may propose an artifact or action; some actor authorizes an effect; and a separate check may establish what happened. The interface must preserve these distinctions because success at one boundary does not establish success at the next.

Feedback is information returned in response to an action. Useful feedback tells the person what the system received, inferred, changed, or could not establish. User control is the practical ability to direct, inspect, interrupt, correct, or limit that work. Neither is satisfied by a polished completion message. A coding agent can say it is finished while an independent check still fails; similarly, a generated email is only a draft until an authorized send occurs, and a send response is not necessarily proof of delivery.

Five questions every task surface should answer

  • Intent — What outcome does the person want, and which constraints matter?
  • Interpretation — What did the system understand from the request and available context?
  • Proposal — What artifact, decision, or action is being suggested?
  • Authority — Who may commit which effects, against which exact proposal?
  • Outcome — What authoritative evidence shows that the useful work was completed?

From intent to verified outcome

A proposal, an authorized effect, and evidence of completion are different objects.

Expressed intentGoal, constraints, source material, output form, and requested authority.
System interpretationThe application’s current understanding of the request.
ProposalA draft artifact or description of a prospective action.
AuthorizationA control decision bound to the inspected proposal.
External effectA state change outside the generated proposal.
Outcome evidenceAuthoritative state used to establish the result.
Generation produces a proposal. Authorization permits an attempted effect; authoritative observation establishes the outcome.
Read the diagram as text
  • Expressed intent. Goal, constraints, source material, output form, and requested authority.
  • System interpretation. The application’s current understanding of the request.
  • Proposal. A draft artifact or description of a prospective action.
  • Authorization. A control decision bound to the inspected proposal.
  • External effect. A state change outside the generated proposal.
  • Outcome evidence. Authoritative state used to establish the result.
  • Expressed intent → System interpretation: input data.
  • System interpretation → Proposal: generated proposal.
  • Proposal → Authorization: review data.
  • Authorization → External effect: permission to attempt.
  • External effect → Outcome evidence: authoritative observation.

The relevant unit of quality is therefore the complete human-and-software system, including its effects and recovery path—not the model response alone. What an evaluation establishes develops that evidence boundary.

Expose the intent the task requires

Intent is rarely one undivided sentence. It includes a goal, constraints, source material, desired output form, and authority to act. An interface should make the consequential parts explicit while leaving language available for nuance. A travel assistant might accept an open-ended goal in conversation, constrain dates and budget with fields, let the person select an itinerary directly, and require separate authorization before purchase.

An affordance is an action possible for a particular actor; a signifier is a perceivable cue that helps the actor discover or interpret that possibility. A visible “Apply changes” button is a signifier. Whether the current user actually has permission to apply them is part of the affordance. Good AI interfaces do not let a cue imply authority or reversibility that the underlying system lacks.

What interaction forms expose

FormMakes explicitOften leaves implicitBest use
Blank conversationGoal in the user’s own languageValid values, selected objects, action authorityExploration and underspecified work
Structured formFields, ranges, required choicesNuance outside the schemaRepeated operations with known parameters
Inline editorTarget object and local changeBroader downstream consequencesBounded rewriting or code modification
Direct manipulationSelected objects and visible effectsUnseen dependencies and permissionsSpatial or precisely editable state

The Excalidraw integration described by Christopher Chedeau illustrates the difference between output and editable product state. A model generated a constrained diagram description, deterministic software translated it into native Excalidraw objects, and users could then move, recolor, and revise those objects. The structured intermediate representation reduced rendering ambiguity; native editability let the person correct the result without restating the whole request.

Match the interaction pattern to the work

Choose an interaction pattern from the work, not from the presence of a model. Conversation is strong when the goal is exploratory and the next useful question depends on the answer. It is weak as the only interface for repeated structured operations, spatial editing, comparison, monitoring, or bulk review. Those tasks benefit from persistent objects, stable controls, and state that does not scroll out of view.

Pattern selection

Task propertyUseful patternMaterial tradeoff
High ambiguityConversation with targeted clarificationFlexible, but important constraints can remain hidden
Frequent, structured operationCommand or formFast and predictable, but limited to anticipated parameters
Local optional assistanceInline suggestionLow context switching, but rejected suggestions still impose verification cost
Evolving document, code, or designPersistent workspace beside conversationKeeps the artifact inspectable, but requires conflict and version handling
Spatial or precisely editable stateDirect manipulationVisible incremental correction, but representations can imply unavailable actions
Bounded recurring workBackground automation with review and exception routesReduces routine interaction, but makes status and intervention design essential

Patterns can be combined across stages. A research assistant may begin in conversation, maintain sources and a draft in a persistent workspace, use direct selection for bounded edits, and run document preparation in the background. The design question is not “chat or no chat?” It is which surface best supports each decision, object, and commitment.

Part II — Shared-control traditions

How initiative became shared

Generative interfaces recombine older approaches to human-computer interaction. Their history is useful because each tradition addressed a different coordination problem; none universally replaced the others.

Must-know developments

DateDevelopmentContribution
1983Direct manipulationBen Shneiderman described continuously visible objects and rapid, incremental, reversible operations with visible effects. He also warned that graphical representations can mislead or consume excessive space.
1985Percent-done indicatorsBrad Myers distinguished measurable completion against an estimated whole from activity displays that only show continued processing.
1986Execution and evaluation gulfsDon Norman separated the difficulty of translating goals into available actions from the difficulty of interpreting system state against those goals.
1999Mixed-initiative interfacesEric Horvitz combined automated assistance with direct invocation, termination, clarification, and manual completion under uncertainty and interruption cost.
2010sInteractive machine learningResearchers emphasized incremental cycles in which people supply input, inspect changed behavior, and direct corrections.
2024Side-by-side artifactsAnthropic described a workspace beside conversation for inspecting generated documents, code, graphics, and previews as persistent work products.

The allocation of initiative changed, but the old requirements remained. A model may suggest a next action, yet visible objects still help people inspect its target. Background work may choose steps dynamically, yet progress still needs meaningful state. Conversation may express intent flexibly, yet reversible local controls remain cheaper than repeatedly regenerating an almost-correct artifact.

Part III — Making behavior legible

Separate receipt, progress, and outcome

After a person initiates work, the interface can truthfully make several different claims: the request was received; the system interpreted it in a stated way; work was accepted; a stage is running; a provisional artifact exists; validation passed; an external effect occurred; or the resulting resource is usable. Collapsing these into “Done” creates false confidence and weak recovery.

Determinate progress reports completed work relative to a meaningful total. If the total is unknown or changes as an agent explores, a percentage is not justified. Show honest indeterminate activity, named stages, completed artifacts, pending dependencies, or a range estimate instead. Alma’s nutrition workflow, for example, exposed a recognized food item before later database matching completed. That partial result made waiting more useful, provided the interface did not mislabel it as finalized nutrition data.

Progressive disclosure initially presents the important, frequently needed information and makes specialized detail available on request. It differs from staged disclosure, where every user proceeds through successive task steps. In an AI interface, the primary status might say “Waiting for approval,” while an expandable view contains tool logs and timing. Internal diagnostic telemetry belongs in Observability; user-facing progress should answer what the person can understand or do next.

Terminal states need equal precision. Verified completion differs from partial completion, blocked work, cancellation, failure, and an unknown external outcome. Decide whether to continue develops the corresponding execution dispositions.

Communicate uncertainty for the decision

Uncertainty communication should name the uncertain claim and the decision it affects. “I may have misunderstood which account you meant” calls for clarification. “Two sources disagree about the amount” calls for comparison. “This prediction is uncertain” may justify a calibrated probability or range. “The external system did not confirm the write” calls for an unknown-outcome state, not a confident retry.

Cause and interface response

Source of uncertaintyUseful responseDo not substitute
Ambiguous intentAsk a targeted question or show candidate interpretationsGeneric warning text
Missing informationName the gap and request or retrieve the needed inputInvented completion
Conflicting sourcesShow the conflicting claims and provenanceCitation count
Predictive uncertaintyShow a calibrated probability, range, or task-relevant review cue when validatedRaw generation probability
Unacceptable residual riskDefer, abstain, or require qualified reviewCautious tone alone
Unverified effectKeep the outcome unknown and inspect authoritative stateAutomatic retry that may duplicate the effect

Presentation changes reliance but does not guarantee good judgment. In one medical-information experiment, first-person uncertainty wording reduced agreement with deliberately fallible answers and improved participant accuracy, but also reduced willingness to use the system. Another experiment found that calibrated-frequency displays changed confidence adjustments in some cases yet did not prevent incorrect reliance. The design must therefore evaluate the decision people make, not merely whether uncertainty is visible. Interpret probability forecasts covers calibration; Evaluate deferral as a policy covers abstention, coverage, and selective risk.

Layer explanation, evidence, and diagnostics

Four supporting objects serve different purposes. An explanation describes general system behavior or a particular output. Evidence supports a claim. Provenance records origins and transformations. Diagnostics expose execution details useful for investigation. A generated rationale can help a reviewer find a bad criterion, but it is not independent proof that a score is correct or that the rationale faithfully reveals hidden computation.

Three disclosure depths

  • Decision — Show the affected values, material qualification, and action choices needed now.
  • Verification — Reveal sources, assumptions, alternatives, and derivation history needed to inspect the claim.
  • Diagnosis — Reveal model, tool, timing, trace, and error detail needed to investigate execution.

More disclosure is not automatically better. Research on AI-assisted decisions found that tested explanations did not significantly outperform a simpler confidence-only condition, and explanations could increase agreement when the AI was wrong. Citations can likewise raise reported trust even when they are irrelevant. The primary surface should therefore expose what the current decision requires, while deeper material remains reachable and inspectable.

Part IV — Control while work continues

Define interruption and cancellation honestly

Interruption changes the current interaction. Steering supplies new direction. Pause retains state intended for later resumption. Cancellation requests that remaining work stop. A cancellation acknowledgment confirms that the runtime handled the request; quiescence means no covered work remains active. None of these terms implies that completed effects were reversed.

Cancellation is asynchronous. A client may immediately display “Canceling,” but a tool can complete or emit another update before the runtime returns a canceled outcome. Agent Client Protocol guidance explicitly permits updates during that interval. Cloud Speech-to-Text similarly documents cancellation as best-effort and requires clients to inspect the eventual operation state. A provisional label is useful feedback; it is not execution proof.

Cancellation is a protocol

A cancellation request can race with late updates and already completed effects.

User
Client UIShows a provisional canceling state.
Agent runtimeCoordinates model and tool work.
In-flight toolMay not stop synchronously.
External systemMay already contain a committed effect.
Runtime resolves the raceAccounts for the tool result, late updates, and any effect already committed.
Client shows canceled outcomeAcknowledged terminal disposition for covered work.
The user asks the client to cancel. The runtime receives the request while a tool may already have produced an external effect or late update. Only the final acknowledgment establishes the covered execution’s terminal disposition; it does not undo the effect.
Read the diagram as text
  • User.
  • Client UI. Shows a provisional canceling state.
  • Agent runtime. Coordinates model and tool work.
  • In-flight tool. May not stop synchronously.
  • External system. May already contain a committed effect.
  • Runtime resolves the race. Accounts for the tool result, late updates, and any effect already committed.
  • Client shows canceled outcome. Acknowledged terminal disposition for covered work.
  • User → Client UI: control: cancel.
  • Client UI → Agent runtime: cancel request.
  • Agent runtime → In-flight tool: abort request.
  • In-flight tool → External system: possible prior effect.
  • In-flight tool → Runtime resolves the race: abort result or late update.
  • External system → Runtime resolves the race: effect evidence.
  • Runtime resolves the race → Client shows canceled outcome: canceled acknowledgment.

Late data must also be attached to the right request and version. If a person corrects an artifact while an older generation remains in flight, the old response must not overwrite the correction. Ignoring stale presentation data is distinct from aborting server work, just as cancellation is distinct from undo. Preserve useful partial artifacts according to an explicit policy, and describe stronger checkpoint or resume guarantees as properties of the chosen runtime rather than universal interface semantics.

Keep persistent delegation inspectable

Persistent assistance changes a one-turn request into an ongoing relationship. The interface should keep visible the represented subject, accountable owner, delegated capabilities, current tasks, notification policy, checkpoints, expiry or renewal rule, and revocation path. A ticket or prompt can describe the delegation context, but it should not replace the identity of the person or service on whose behalf the agent acts.

Persistent-control responsibilities

MomentPerson needs to seeSystem responsibility
GrantScope, subject, resources, duration, confirmation rulesBind authority outside model-controlled text
OperationActive tasks, status, pending decisionsSurface artifacts and consolidate attention requests
CheckpointCompleted effects and proposed next scopeRenew consent when risk or scope materially changes
RevocationWhat will stop and what already happenedStop remaining authorized work and preserve an inspectable record

Notifications should re-enter the person only when attention is useful, not require continuous monitoring. Proactive suggestions should remain optional and reversible where possible. Because no universal interruption frequency or delegation duration fits every task, products must state these policies explicitly and test them in use. Personal Agents develops memory, preferences, privacy, and long-term usefulness.

Part V — Review, correction, and recovery

Review before consequential commitment

A review boundary belongs before an action whose consequences, irreversibility, uncertainty, or delegated authority justify the interruption. Human intervention can supply missing intent, permission to act, or responsibility for work the system cannot complete; these are different requests and should be presented differently. Request the right human decision develops that distinction.

Authorization must be bound to the proposal the person inspected. Show the affected object, concrete values, relevant evidence, and expected effect. If the proposal changes, invalidate the approval or restart review. n8n’s demonstrated email and calendar gates follow the important structural pattern: the agent invokes the ordinary tool, while an execution-layer interceptor blocks it until review. The calendar example also shows why raw parameters need readable presentation; an opaque timestamp weakens the decision even when technically complete.

Version-bound review before execution

Example

Approval must authorize the exact proposal inspected, not a moving summary.

Proposal v3Affected object, concrete values, evidence, and expected effect.
Human reviewThe reviewer inspects the proposed action.
Clarify or editIntent or values require change.
DeniedExecution is not authorized.
EscalatedResponsibility moves to a qualified decision-maker.
Final version checkConfirms that execution still targets proposal v3.
Execute actionThe authorized external effect is attempted.
Re-review requiredProposal data changed after inspection.
A readable, versioned proposal can be clarified, edited, denied, escalated, or approved. Approval passes through a final version check; a mismatch exits to re-review instead of executing changed parameters.
Read the diagram as text
  • Proposal v3. Affected object, concrete values, evidence, and expected effect.
  • Human review. The reviewer inspects the proposed action.
  • Clarify or edit. Intent or values require change.
  • Denied. Execution is not authorized.
  • Escalated. Responsibility moves to a qualified decision-maker.
  • Final version check. Confirms that execution still targets proposal v3.
  • Execute action. The authorized external effect is attempted.
  • Re-review required. Proposal data changed after inspection.
  • Proposal v3 → Human review: review data.
  • Human review → Clarify or edit: missing or wrong intent.
  • Human review → Denied: permission denied.
  • Human review → Escalated: responsibility transfer.
  • Human review → Final version check: approved v3.
  • Final version check → Execute action: if version matches.
  • Final version check → Re-review required: if version changed.

A dialog alone does not guarantee attention. Repeated confirmations can produce habituation, and a human gate can amplify automation bias. In the When Machines Mislead studies, fabricated copy-typing alerts were inserted into legitimate historical exam sessions. Proctors initially rejected only half of those fabricated alerts. Revised instructions required independent video evidence before upholding a flag; model-estimated rejection rose to 71%, though the studies used different sessions and periods rather than simultaneous randomized assignment.

Choose review granularity

  • Per item — Appropriate when each effect can differ materially; expensive for frequent routine work.
  • Batch — Efficient when comparable items can be inspected together; risks hiding local differences.
  • Exception only — Reduces burden when the exception detector is validated and ordinary effects remain bounded.
  • Explicit confirmation — Fits rare commitments whose exact parameters must be acknowledged; repetition can weaken inspection.

Repair the smallest affected boundary

Correction mechanisms should match where the error entered. Edit a proposal when its content is wrong but no effect occurred. Correct a source fact when the proposal faithfully reflects bad input. Regenerate a bounded region when only one portion needs another attempt. Reject a candidate when an alternative is better. Undo an applied change only when the application retains a supported prior state. Compensation is different: it performs a new domain-specific action to address an effect that already happened.

A compensation may fail, conflict with concurrent work, or leave residual consequences. Canceling a booked flight may incur a fee; retracting a sent message cannot guarantee that nobody read it. The recovery record should preserve the source version, AI proposal, user correction, committed effect, compensation attempt, and current disposition rather than rewriting history to imply the error never occurred.

Correction preserves history

Example

Undo and compensation change state in different ways; neither should erase provenance.

1 / 4 · Proposal created

The source and derived proposal remain separately addressable.

New this stepSource S1Versioned source material.
New this stepProposal P1Derived from source S1.
In this example, compensation K1 is a new action addressing E1 and may leave residual consequences. Other cases may support undo or require escalation; the source, proposal, correction, and committed effect remain separate records.
Read the diagram as text
  • Source S1. Versioned source material.
  • Proposal P1. Derived from source S1.
  • Correction C1. A user-authored bounded change.
  • External effect E1. Committed downstream state.
  • Disputed. The committed effect is later challenged.
  • Compensation K1. A new action addressing E1; it may not restore the original state.
  • Resolved with residue. Current disposition records remaining consequences.
  • Source S1 → Proposal P1: supports.
  • Proposal P1 → Correction C1: is corrected by.
  • Correction C1 → External effect E1: authorizes committed value.
  • External effect E1 → Disputed: has status.
  • External effect E1 → Compensation K1: addressed by.
  • Compensation K1 → Resolved with residue: produces disposition.
  1. Proposal created. The source and derived proposal remain separately addressable. Active: Source S1, Proposal P1. New: Source S1, Proposal P1.
  2. Bounded correction. The correction is added without replacing source or proposal history. Active: Source S1, Proposal P1, Correction C1. New: Correction C1.
  3. Effect committed and disputed. The external effect persists as a stable record with a disputed status. Active: Source S1, Proposal P1, Correction C1, External effect E1, Disputed. New: External effect E1, Disputed.
  4. Compensating recovery. A new corrective action and honest residual disposition are recorded. Active: Source S1, Proposal P1, Correction C1, External effect E1, Compensation K1, Resolved with residue. New: Compensation K1, Resolved with residue.

Source-linked review makes the disputed boundary concrete. In Recover incomplete and disputed results, a useful record includes the source version, page and region, surrounding context, candidate values, and referral reason. An editable field linked to its source location lets the reviewer correct the extraction without reconstructing the whole document. Conditional version checks can then prevent an accepted correction from silently overwriting newer work.

Part VI — From design claim to working interface

Prototype the uncertain interaction

Prototype the riskiest interaction claim, not the most photogenic screen. Role concerns whether the product is useful in the workflow; look and feel concerns the experience of interacting; implementation concerns how it works. Model behavior, integration, latency, consequences, and accessibility add independent fidelity dimensions. A prototype can be realistic on one dimension and entirely simulated on another.

What prototypes can establish

PrototypeUseful forCannot establish alone
Static mockupHierarchy, copy, layout, task framingTiming, model variability, cancellation, real effects
Scripted interactionKnown state changes, errors, review, recoveryUnscripted model behavior
Wizard of OzInteraction with a human simulating missing automationDeployed accuracy, latency, reliability, or scale
Model-backed prototypeReal output variability and prompt behaviorProduction integrations or operational safety
Production-shaped working sliceOne narrow task through real boundaries and observable outcomeCoverage of the broader workload

Include delayed responses, malformed output, interruption, denial, correction, stale updates, and accessible operation. A controlled delayed-error fixture can keep transient states visible for inspection. A working slice should be narrow but complete through integration, operator interaction, and observable result; Testing a complete working slice develops that method.

Implement explicit task states

A state model turns asynchronous behavior into enforceable rules. A state records the current condition relevant to permitted behavior. An event reports something that happened. A transition moves to another state when an event matches and any guard condition holds. These ideas do not make the model deterministic; they make the application’s response to model and tool events explicit.

Give each task, attempt, proposal, artifact, and external effect a stable identity. Keep durable task state separate from ephemeral streamed presentation. An incoming event should carry the request or version it concerns; otherwise, an old response can overwrite a newer correction. Repeated cancel, approve, or retry actions also need defined semantics. Idempotency can make repetition safe for a specific operation, but it is a contract, not a property inferred from the button label.

Guarded transitions for one task attempt

Example

Identity and version guards keep obsolete events from becoming current state, while verified completion requires authoritative outcome evidence.

Identity guardsTask T-42, attempt A-3, proposal P-9, and effect E-1 identify the state and events they concern.
AcceptedAttempt A-3 is registered for task T-42.
RunningWork is active for this attempt.
Provisional artifact P-9An inspectable artifact exists but no external effect is verified.
Awaiting review of P-9Authorization must remain bound to this proposal version.
Executing effect E-1The authorized external operation is in flight.
Verified completeAuthoritative evidence establishes the required postcondition.
Event rejectedAn unrelated task ID or older version cannot mutate the current attempt.
CancelingA cancellation request is pending while covered work settles.
CanceledThe runtime acknowledged that remaining covered work stopped.
Re-review requiredProposal data changed after inspection, invalidating prior authorization.
New attempt A-4A retry receives a new attempt identity instead of silently looping A-3.
External outcome unknownThe response cannot establish whether effect E-1 occurred.
One identified attempt follows the central path. Unrelated or stale events are rejected without changing current state; cancellation becomes terminal only after acknowledgment; a changed proposal requires a new review; and an unconfirmed external effect remains unknown rather than becoming a false success.
Read the diagram as text
  • Identity guards. Task T-42, attempt A-3, proposal P-9, and effect E-1 identify the state and events they concern.
  • Accepted. Attempt A-3 is registered for task T-42.
  • Running. Work is active for this attempt.
  • Provisional artifact P-9. An inspectable artifact exists but no external effect is verified.
  • Awaiting review of P-9. Authorization must remain bound to this proposal version.
  • Executing effect E-1. The authorized external operation is in flight.
  • Verified complete. Authoritative evidence establishes the required postcondition.
  • Event rejected. An unrelated task ID or older version cannot mutate the current attempt.
  • Canceling. A cancellation request is pending while covered work settles.
  • Canceled. The runtime acknowledged that remaining covered work stopped.
  • Re-review required. Proposal data changed after inspection, invalidating prior authorization.
  • New attempt A-4. A retry receives a new attempt identity instead of silently looping A-3.
  • External outcome unknown. The response cannot establish whether effect E-1 occurred.
  • Identity guards → Accepted: matching task and attempt.
  • Accepted → Running: start event.
  • Running → Provisional artifact P-9: artifact P-9 emitted.
  • Provisional artifact P-9 → Awaiting review of P-9: review required.
  • Awaiting review of P-9 → Executing effect E-1: P-9 approved and unchanged.
  • Executing effect E-1 → Verified complete: postcondition verified.
  • Identity guards → Event rejected: unrelated or stale event.
  • Running → Canceling: cancel requested.
  • Canceling → Canceled: cancellation acknowledged.
  • Awaiting review of P-9 → Re-review required: proposal version changed.
  • Re-review required → New attempt A-4: new attempt created.
  • Executing effect E-1 → External outcome unknown: outcome evidence unavailable.

A reducer rejects stale state before rendering it

Illustrative pseudocode

Python-like pseudocode
def reduce(state, event):
    if event.task_id != state.task_id:
        return state  # unrelated task

    if event.version < state.version:
        return state  # stale update

    if event.type == "cancel_requested" and state.can_cancel:
        return state.with_status("canceling")

    if event.type == "external_effect_confirmed":
        return state.record_effect(event.effect_id)

    if event.type == "canceled_ack":
        return state.with_status("canceled")

    return apply_permitted_transition(state, event)

The user-facing projection should remain concise: “Waiting for approval” is usually more useful than a stream of internal span names. Keep traces and metrics available for diagnosis through Observability, while the task surface presents state, evidence, and permitted next actions.

Part VII — Testing the human workflow

Evaluate use, reliance, and recovery

Evaluate representative people performing representative tasks against a credible prior or non-AI workflow. The outcome is useful completed work, including review, correction, waiting, exceptions, and downstream repair. Component accuracy and model quality remain inputs, but they do not measure whether the interface improved the job.

Claims and evidence

Design claimObserveMeasureComparison
People complete the taskAttempts through the entire workflowCorrect completed outcomes and unresolved casesPrior or non-AI workflow
Status is understoodInterpretations and next actions at key statesComprehension errors and recovery choicesAlternative status presentation
Review improves decisionsAcceptance and rejection of correct and seeded erroneous adviceAppropriate reliance, review time, downstream correctionImmediate advice or independent-first judgment
Correction is usableAttempts to repair realistic errorsTime, interactions, residual error, abandoned repairsRestart or manual workflow
Interruptions are proportionateTask activity around suggestions and approvalsVerification cost, delay, dismissal, missed interventionsDifferent trigger or review policy

Use moderated task testing to observe what participants understand and expect; use heuristic inspection as a separate method for expert analysis against established principles. Neither substitutes for the other. Seeded-error studies are especially useful for oversight because counting approvals alone cannot show whether reviewers resist wrong assistance.

Production signals are selectively observed. An accepted suggestion may later be corrected; silence may mean success, unnoticed failure, or abandonment; only escalated cases may receive expert labels. Account for incomplete feedback explains this measurement problem, while Making everyday use workable covers checking time, exception routes, confidence, and responsibility in sustained use.

Accessibility is interaction behavior

Accessibility means designing and developing technologies so people with disabilities can perceive, understand, navigate, interact, and contribute. For AI products, that obligation covers the complete process: entering intent, reading generated content, tracking progress, handling interruptions, reviewing proposals, correcting errors, and recognizing completion.

The same task across access modes

RequirementVisual and pointerKeyboard or switchScreen readerReduced motion and reflow
IntentLabeled controls and selected objectsLogical focus order and non-drag alternativesNames, roles, states, instructionsControls remain visible and usable when enlarged
Streaming statusVisible contextual updateFocus stays on the current controlGrouped polite live-region announcementNo motion-only cue; layout does not jump
ProgressText plus visual indicatorOperable details disclosureContext such as “3 of 5 files processed”Non-color meaning and stable reflow
Review and correctionVisible source and changed valuesEvery action reachable without precise pointingSource, proposal, and error relationships announcedNo two-dimensional scrolling unless meaning requires it
Cancellation and completionDistinct canceling and canceled statesCancel remains reachable and focus is restored logicallyCompletion or failure announced without stealing focusReduced animation and adjustable timing

Generated content also needs semantic headings, lists, tables, labels, reading order, accessible code and math, text alternatives for meaningful images, and operable embedded controls. Token-by-token announcements can overwhelm assistive technology; ARIA live regions and aria-busy support batching changes into meaningful updates rather than treating every fragment as urgent.

Automated tools assist accessibility evaluation but cannot establish conformance or usability alone. Combine standards inspection with task testing involving disabled participants, while stating participant characteristics and limits of generalization. A few users can reveal severe barriers without representing every disability or assistive-technology configuration.

Part VIII — Choosing controls

Choose controls for the actual task

The final design is a set of connected decisions, not a generic checklist score. Begin with useful completed work and permitted authority. Choose interaction patterns from task structure. Expose interpretation, state, and decision-relevant uncertainty. Define interruption and terminal semantics. Place version-bound review before consequential commitment. Preserve bounded correction and honest recovery. Implement explicit states, then test the complete accessible workflow.

A practical design review

  • Work — What observable result makes the task useful, including checking and correction?
  • Intent — Which goals, constraints, sources, output form, and authority must be explicit?
  • Pattern — Which stages need conversation, structure, persistent artifacts, direct manipulation, or automation?
  • Legibility — What interpretation, progress, uncertainty, and evidence does the next decision require?
  • Control — What do pause, cancel, deny, retry, and revoke mean operationally?
  • Commitment — Which effects require version-bound review or independent verification?
  • Recovery — What can be edited, undone, compensated, or only escalated?
  • Access — Can every important action and state be perceived and operated through supported access modes?
  • Evidence — Which task outcomes, burdens, failures, and unresolved cases will establish whether the design helps?

One task, conflicting constraints

Consider a frequent background workflow that prepares outbound notices. Frequency favors automation and low interruption; ambiguous recipients favor targeted clarification; ordinary drafts favor direct editing; irreversible sending favors readable, version-bound authorization; delayed delivery confirmation requires a distinct pending outcome; screen-reader users need grouped contextual announcements; and a failed send may permit retry while an already delivered mistake requires a corrective follow-up. Convenience in one stage can therefore require stronger boundaries elsewhere.

The governing principle is simple: give people enough structure to express intent, enough visibility to understand state, and enough authority to intervene before uncertainty becomes an irreversible effect. The exact controls remain task-specific because ambiguity, latency, review cost, accessibility, consequence, and reversibility interact.

Open questions

  1. How can interfaces communicate calibrated uncertainty without increasing inappropriate reliance, especially when task-relevant uncertainty differs from model probability? Progress would include replicated studies on real workflows that measure comprehension, correct acceptance and rejection, review time, and downstream outcomes across expertise levels.

  2. What portable pause-and-resume contract can preserve partial artifacts while invalidating stale assumptions, in-flight effects, and obsolete checkpoints? Progress would look like explicit cross-runtime semantics for safe points, version compatibility, retained state, cancellation races, and user-visible recovery.

  3. How should persistent delegation expire, renew, and request fresh consent as tasks and applications change? The hard part is balancing useful continuity against silent authority expansion. Progress would include enforceable scope records, understandable renewal interfaces, tested notification policies, and clear revocation outcomes.

  4. How can teams measure correction burden and irreversible-effect rates consistently enough to guide interface choices? Progress would require task-specific denominators, longitudinal links between proposals and later repairs, and comparisons with credible prior workflows rather than universal benchmark numbers.

  5. How should streamed AI interaction behave across screen readers, switch access, keyboard-only use, reduced motion, zoom, and narrow reflow? Progress would combine standards-conformant implementations with controlled task studies involving disabled participants, including interruption, review, correction, and error recovery rather than final-answer reading alone.

Follow the curated reading path through the speakers and demonstrations behind this entry.

Explore more talks

The rest of the library, beyond the curated path. Cited talks support this entry; reviewed transcripts were processed in full. Metadata candidates have not been reviewed as sources or verified as topic members.

72 matching talks

TalkSpeakerEventYear
Greg BensonAI Engineer World's Fair 20252025
Codex, Behind the Harness

Transcript reviewed

Dominik KundelAI Engineer World's Fair 20262026
Jeremy Silva, Chris HernandezAI Engineer World's Fair 20252025
Michael HablichAI Engineer Europe 20262026
Sarah Sachs, Carlos Esteban, Doug GuthrieAI Engineer World's Fair 20252025
Anita KirkovskaAI Engineer Summit 20252025
Arthur ObjartelAI Engineer Summit 20252025
How to Kill the Code Review

Transcript reviewed

Ankit JainAI Engineer World's Fair 20262026
Eno ReyesAI Engineer World's Fair 20252025
Rami AlhamadAI Engineer World's Fair 20252025
Rafal Wilinski, Vitor BaloccoAI Engineer World's Fair 20252025
Ahmad AwaisAI Engineer Code 20252025
Michal CichraAI Engineer Europe 20262026
Sumaiya ShrabonyAI Engineer World's Fair 20262026
Beyang LiuAI Engineer World's Fair 20252025
Jun Yu TanAI Engineer World's Fair 20252025
Peter WielanderAI Engineer Code 20252025
KP Sawhney, Ian BallantyneAI Engineer Europe 20262026
OpenLLMetry is all you need

Transcript reviewed

Nir GazitAI Engineer Summit 20252025
Mike ChristensenAI Engineer Europe 20262026
Bennet FennerAI Engineer Europe 20262026
Chintan Agrawal, Daniel WirjoAI Engineer World's Fair 20262026
Vinoth GovindarajanAI Engineer World's Fair 20262026
Harald KirschnerAI Engineer World's Fair 20252025
Sandipan BhaumikAI Engineer Europe 20262026
John PhamAI Engineer World's Fair 20252025
Shafik Quoraishee, Joanne SongAI Engineer World's Fair 20262026
Omar KhattabAI Engineer World's Fair 20252025
Alex LissAI Engineer World's Fair 20252025
Maximillian PirasAI Engineer World's Fair 20252025
Defying Gravity

Cited in this entry

Kevin HouAI Engineer Code 20252025
Adam TerlsonAI Engineer Summit 20252025
Matt PocockAI Engineer Europe 20262026
Jerry LiuAI Engineer World's Fair 20252025
Kwindla Kramer, Shrestha Basu MallickAI Engineer World's Fair 20252025
Talha SheikhAI Engineer Europe 20262026
Akele Reed, Dave Revere, Doug KellerAI Engineer World's Fair 20262026
Evaling Video Slop

Transcript reviewed

Maor BrilAI Engineer World's Fair 20262026
Vinoo GaneshAI Engineer World's Fair 20262026
Daniel ChalefAI Engineer World's Fair 20262026
Carlos Esteban, DougAI Engineer World's Fair 20252025
Kam LasaterAI Engineer Summit 20252025
Aditya BhargavaAI Engineer World's Fair 20262026
Corey CooperAI Engineer World's Fair 20252025
Jared JoselowitzAI Engineer World's Fair 20262026
Sarthak AggarwalAI Engineer World's Fair 20262026
Nishant GuptaAI Engineer World's Fair 20262026
Why MLX

Transcript reviewed

AI Engineer Europe 20262026
Travis FrisingerAI Engineer World's Fair 20252025
Alex HancockEvent unknownUnknown
Dustin MihalikEvent unknownUnknown
Noyan TokgozogluEvent unknownUnknown
Vincent WendyEvent unknownUnknown
Max DrakeEvent unknownUnknown
Hariprasad SudharshanAI Engineer NYC 2026 Online Talks2026
Jesse LumarieAI Engineer World's Fair 20262026
Kent C. DoddsEvent unknownUnknown
Cyrus ClarkeEvent unknownUnknown
Charlie GuoEvent unknownUnknown
Jesse HallAI Engineer World's Fair 20262026
Nina Žižakić, Eleonora DrykinaAI Engineer NYC 2026 Online Talks2026
Joseph KimEvent unknownUnknown
Nidhi Kaushik VyasEvent unknownUnknown
Zach LloydEvent unknownUnknown
Liad YosefAI Engineer World's Fair 20262026
Jonathan GordonEvent unknownUnknown
Amit DesaiEvent unknownUnknown
Midam KimEvent unknownUnknown
Paul BakausEvent unknownUnknown
Ido SalomonAI Engineer World's Fair 20262026
Gus IwanagaEvent unknownUnknown
Thais Castello BrancoEvent unknownUnknown

References

Coverage and source review
Processed transcripts
54 processed in full · 5 in the curated path
Automated source review
Passed
Metadata candidates
23 unreviewed; not verified topic membership
Corpus version
1bd8e407b26a07b33815594e1b2db5f41827119a2b3cb6fbf240f9fc571fc767

Automated review checks source support; it is not publication approval.

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

  1. NIST Handbook 161: Usability Handbook for Public Safety Communications

    https://nvlpubs.nist.gov/nistpubs/hb/2017/NIST.HB.161.pdf

  2. Cognitive Engineering

    https://cel.cs.brown.edu/pdf/norman-cognitive-engineering.pdf

  3. Your coding agent doesn't always follow your rules

    https://www.youtube.com/watch?v=MpZzWMdmQCE&t=77

  4. Building Multi-agent Systems with Finite State Machines

    https://www.youtube.com/watch?v=OD13PiXw60o&t=506

  5. Guidelines for Human-AI Interaction

    https://www.microsoft.com/en-us/research/wp-content/uploads/2019/01/Guidelines-for-Human-AI-Interaction-camera-ready.pdf

  6. Principles of Mixed-Initiative User Interfaces

    https://erichorvitz.com/chi99horvitz.pdf

  7. Signifiers, not affordances

    https://jnd.org/signifiers-not-affordances/

  8. Direct Manipulation: A Step Beyond Programming Languages

    https://www.cs.umd.edu/~ben/papers/Shneiderman1983Direct.pdf

  9. Figma: Rewrite, translate, and shorten text with AI

    https://help.figma.com/hc/en-us/articles/24004868368919-Rewrite-translate-and-shorten-text-with-AI

  10. AI and Human Whiteboarding Partnership

    https://www.youtube.com/watch?v=aopgVJBQC0o&t=574

  11. AI and Human Whiteboarding Partnership

    https://www.youtube.com/watch?v=aopgVJBQC0o&t=704

  12. The era of unbounded products: Designing for Multimodal I/O

    https://www.youtube.com/watch?v=5nOLb27hQ5w&t=724

  13. Collaborate with Claude on Projects

    https://www.anthropic.com/news/projects

  14. When to Show a Suggestion? Integrating Human Feedback in AI-Assisted Programming

    https://ojs.aaai.org/index.php/AAAI/article/download/28878/29669

  15. Building AI Agents that actually automate Knowledge Work

    https://www.youtube.com/watch?v=jVGCulhBRZI&t=696

  16. Magentic-UI, an experimental human-centered web agent

    https://www.microsoft.com/en-us/research/blog/magentic-ui-an-experimental-human-centered-web-agent/

  17. The Importance of Percent-Done Progress Indicators for Computer-Human Interfaces

    https://www.cs.cmu.edu/~bam/papers/percentdoneCHI85.pdf

  18. Power to the People: The Role of Humans in Interactive Machine Learning

    https://homes.cs.washington.edu/~mcakmak/pdfs/2015/amershi2015aimag.pdf

  19. AIP-151: Long-running operations

    https://google.aip.dev/151

  20. Vercel AI SDK: useChat reference source

    https://raw.githubusercontent.com/vercel/ai/main/content/docs/07-reference/02-ai-sdk-ui/01-use-chat.mdx

  21. HTML Standard: The progress element

    https://html.spec.whatwg.org/multipage/form-elements.html#the-progress-element

  22. My AI Thinks I'm Eating My Feelings (and Other Nutritional Insights)

    https://www.youtube.com/watch?v=Ghc-qalQFLw&t=227

  23. Progressive Disclosure

    https://www.nngroup.com/articles/progressive-disclosure/

  24. Understanding Success Criterion 4.1.3: Status Messages

    https://www.w3.org/WAI/WCAG22/Understanding/status-messages.html

  25. People + AI Guidebook: Explainability + Trust

    https://pair.withgoogle.com/guidebook-v2/chapter/explainability-trust/

  26. Citations and Trust in LLM Generated Answers

    https://arxiv.org/html/2501.01303v1

  27. Designing for Appropriate Reliance: The Roles of AI Uncertainty Presentation, Initial User Decision, and User Demographics in AI-Assisted Decision-Making

    https://arxiv.org/abs/2401.05612

  28. Generation Probabilities Are Not Enough: Uncertainty Highlighting in AI Code Completions

    https://arxiv.org/abs/2302.07248

  29. “I'm Not Sure, But…”: Examining the Impact of Large Language Models' Uncertainty Expression on User Reliance and Trust

    https://arxiv.org/html/2405.00623v1

  30. Cloud Speech-to-Text: operations.cancel

    https://docs.cloud.google.com/speech-to-text/docs/reference/rest/v1/operations/cancel

  31. [Evals Workshop] Mastering AI Evaluation: From Playground to Production

    https://www.youtube.com/watch?v=9iN-cPnp7xg&t=2641

  32. Progressive Disclosure: Designing for Effective Transparency

    https://arxiv.org/abs/1811.02164

  33. How Kepler Built Verifiable AI for Financial Services

    https://www.youtube.com/watch?v=Tt2kX2sgQio&t=362

  34. How Kepler Built Verifiable AI for Financial Services

    https://www.youtube.com/watch?v=Tt2kX2sgQio&t=858

  35. Does the Whole Exceed its Parts? The Effect of AI Explanations on Complementary Team Performance

    https://www.microsoft.com/en-us/research/uploads/prod/2021/02/does_the_whole_exceed_its_parts-chi21.pdf

  36. Agent Client Protocol: Prompt Turn

    https://agentclientprotocol.com/protocol/v1/prompt-turn

  37. UX Design Principles for (Semi) Autonomous Multi-Agent Systems

    https://www.youtube.com/watch?v=fmZWvE7yDZo&t=884

  38. React: Synchronizing with Effects

    https://react.dev/learn/synchronizing-with-effects

  39. OpenRefine User Manual: Running OpenRefine

    https://openrefine.org/docs/manual/running/

  40. IT Admin for the AI Workforce — Sarthak Aggarwal, Decawork

    https://www.youtube.com/watch?v=q-WOjZhOMCA&t=151

  41. Defying Gravity

    https://www.youtube.com/watch?v=HN-F-OQe6j0&t=287

  42. IT Admin for the AI Workforce — Sarthak Aggarwal, Decawork

    https://www.youtube.com/watch?v=q-WOjZhOMCA&t=105

  43. Don't just slap on a chatbot: building AI that works before you ask

    https://www.youtube.com/watch?v=2cEGQEllBGc&t=186

  44. OWASP Transaction Authorization Cheat Sheet

    https://cheatsheetseries.owasp.org/cheatsheets/Transaction_Authorization_Cheat_Sheet.html

  45. Building Your Own Secure AI Workflows: Human-in-the-Loop Automation with n8n

    https://www.youtube.com/watch?v=tDArkCqjA-c&t=3045

  46. Building Your Own Secure AI Workflows: Human-in-the-Loop Automation with n8n

    https://www.youtube.com/watch?v=tDArkCqjA-c&t=3336

  47. Harder to Ignore? Revisiting Pop-Up Fatigue and Approaches to Prevent It

    https://www.usenix.org/system/files/soups14-paper-bravo-lillo.pdf

  48. When Machines Mislead: Human Review of Erroneous AI Cheating Signals

    https://aclanthology.org/2025.aimecon-wip.11.pdf

  49. Build AI Systems for Discernment, Not Approval - Angel Ortmann Lee, Duolingo

    https://www.youtube.com/watch?v=CDqzWpwkSls&t=359

  50. Compensating Transaction pattern

    https://learn.microsoft.com/en-us/azure/architecture/patterns/compensating-transaction

  51. From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work — Sandipan Bhaumik

    https://www.youtube.com/watch?v=2czYyrTzILg&t=1138

  52. RFC 9110: HTTP Semantics

    https://www.rfc-editor.org/rfc/rfc9110.html

  53. What Do Prototypes Prototype?

    https://creativetech.mat.ucsb.edu/readings/Prototypes_prototype.pdf

  54. Storybook: Mocking network requests

    https://storybook.js.org/docs/writing-stories/mocking-data-and-modules/mocking-network-requests

  55. Wizard of Oz Experimentation for Language Technology Applications: Challenges and Tools

    https://arxiv.org/html/2402.14563v1

  56. Full Walkthrough: Workflow for AI Coding — Matt Pocock

    https://www.youtube.com/watch?v=-QFHIoCo-Ko&t=2714

  57. State Chart XML: State Machine Notation for Control Abstraction

    https://www.w3.org/TR/scxml/

  58. Building Multi-agent Systems with Finite State Machines

    https://www.youtube.com/watch?v=OD13PiXw60o&t=204

  59. Your Agent Didn’t Fail. Your Harness Did.

    https://www.youtube.com/watch?v=BInpv7lGp1o&t=318

  60. GOV.UK Service Manual: Using moderated usability testing

    https://www.gov.uk/service-manual/user-research/using-moderated-usability-testing

  61. Production Evals For Agentic AI Systems

    https://www.youtube.com/watch?v=vljxQZfJ9wY&t=163

  62. Psychological Factors Influencing Appropriate Reliance on AI-enabled Clinical Decision Support Systems: Experimental Web-Based Study Among Dermatologists

    https://pmc.ncbi.nlm.nih.gov/articles/PMC12008695/

  63. The Theory Behind Heuristic Evaluations

    https://www.nngroup.com/articles/how-to-conduct-a-heuristic-evaluation/theory-heuristic-evaluations/

  64. Build AI Systems for Discernment, Not Approval - Angel Ortmann Lee, Duolingo

    https://www.youtube.com/watch?v=CDqzWpwkSls&t=563

  65. W3C WAI: Introduction to Web Accessibility

    https://www.w3.org/WAI/fundamentals/accessibility-intro/

  66. Web Content Accessibility Guidelines 2.2

    https://www.w3.org/TR/WCAG22/

  67. W3C WAI: What's New in WCAG 2.2

    https://www.w3.org/WAI/standards-guidelines/wcag/new-in-22/

  68. Accessible Rich Internet Applications 1.2

    https://www.w3.org/TR/wai-aria-1.2/

  69. WAI-ARIA Authoring Practices: Developing a Keyboard Interface

    https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/

  70. Understanding Success Criterion 1.4.1: Use of Color

    https://www.w3.org/WAI/WCAG22/Understanding/use-of-color.html

  71. Understanding Success Criterion 1.4.10: Reflow

    https://www.w3.org/WAI/WCAG22/Understanding/reflow.html

  72. Evaluating Web Accessibility Overview

    https://www.w3.org/WAI/test-evaluate/

  73. Involving Users in Evaluating Web Accessibility

    https://www.w3.org/WAI/test-evaluate/involving-users/

  74. NIST AI RMF Core

    https://airc.nist.gov/airmf-resources/airmf/5-sec-core/

  75. Citation Needed: Provenance for LLM-Built Knowledge Graphs

    https://www.youtube.com/watch?v=H7puB0RwJMM&t=316

  76. Breaking the Chain: Agent Continuations for Resumable AI Workflows

    https://www.youtube.com/watch?v=ZB7l4uxW3Yo&t=144

  77. LangSmith: Feedback data format

    https://docs.langchain.com/langsmith/feedback-data-format

  78. The era of unbounded products: Designing for Multimodal I/O

    https://www.youtube.com/watch?v=5nOLb27hQ5w&t=150

  79. Build AI Systems for Discernment, Not Approval - Angel Ortmann Lee, Duolingo

    https://www.youtube.com/watch?v=CDqzWpwkSls&t=480

  80. UX Design Principles for (Semi) Autonomous Multi-Agent Systems

    https://www.youtube.com/watch?v=fmZWvE7yDZo&t=563

  81. UX Design Principles for (Semi) Autonomous Multi-Agent Systems

    https://www.youtube.com/watch?v=fmZWvE7yDZo&t=909