A spinner can tell someone that an interface is still active. It cannot tell them whether an agent understood the objective, completed a consequential step, changed its plan, needs a decision or left part of the operation in an uncertain state. When software can continue working across tools and time, progress becomes part of the product contract.
A spinner answers the wrong question
Loading feedback was designed for a bounded transaction. The user asks the system to do something, the interface waits and a result appears. A short animation can reassure them that the request was received. For a predictable operation, a percentage or time estimate may help them decide whether to wait or do something else.
Agent work is different when it interprets an objective, chooses tools, revises a route or continues after the original interaction. The system may have completed some actions while reconsidering another. It may be waiting for a permission, missing information or a person with authority. It may have produced a useful intermediate artefact even if the full objective cannot be completed. Describing all of this as loading hides the decisions that now matter.
Nielsen Norman Group's guidance on long waits makes a useful conventional distinction. When a reliable percentage or duration is unavailable, show completed and remaining steps rather than an indefinite loop. Agentic products need to go further because the route itself may change. The product should communicate what is known about the work, not simulate certainty about how much remains.
Progress is a user-facing operating state
An agent's status changes what a person should do. If the system is working normally, they may leave it in the background. If it needs input, they must decide whether to supply it, narrow the objective or stop. If an action has already changed a customer record, a cancellation request has a different meaning from dismissing a message. If the task failed after partial execution, the user needs recovery rather than another attempt button.
Current technical systems already reflect this shift. OpenAI supports background responses that can continue asynchronously and be polled or streamed later. The Model Context Protocol distinguishes working, input required, completed, failed and cancelled tasks under one persistent task identity. These are implementation examples, not a universal interface taxonomy. They show that long-running work has a lifecycle beyond the connection that started it.
The product state must sit above the infrastructure state. A tool can report that a call completed while the customer's objective remains unresolved. A model can be generating while no useful progress is being made. Product teams should translate technical events into states that explain the work in terms of the user's objective, consequence and available action.
Use a small, meaningful state model
Do not expose every tool call as a new state. Begin with the decisions the user may need to make. A practical model usually needs to distinguish accepted, working, input required and terminal outcomes. Working can include a small number of meaningful milestones when they change the user's expectation. Terminal outcomes should separate completed, completed with exceptions, failed and cancelled where those differences affect what happens next.
Each visible state needs evidence. Accepted means the product has a durable task identity and can recover the request. Working means the system has observed activity that advances the objective, not merely a connection that remains open. Input required names the missing decision, why it matters and what safe state is preserved while the system waits. Completion identifies what changed and where the result can be inspected. Failure states explain the remaining effect and recovery route.
Plans are useful when they create orientation or control, but they should not be presented as promises. An agent may discover that a source is unavailable or that an apparently simple step contains several exceptions. Show the plan as current, distinguish completed evidence from proposed work and announce material changes. The user needs a dependable account of state, not the performance of unwavering confidence.
Show evidence, not process theatre
More detail does not automatically create more trust. A stream of confident commentary can make ordinary system activity appear thoughtful without helping the user assess the result. Raw traces may expose sensitive sources, tool parameters or implementation weaknesses. Internal reasoning is also the wrong object for product assurance. The user needs decision-relevant evidence about what the system did and what remains uncertain.
Microsoft Research's human-AI interaction guidelines provide a durable baseline: make capability and likely error clear, show information relevant to the current task, support correction and make an explanation available for behaviour after it occurs. Applied to progress, this means showing the current milestone, material evidence, changed assumption or blocked decision in language connected to the user's work.
Use progressive disclosure. The primary state might say that three records have been checked and one needs a policy decision. A detail view can identify the sources, actions and timestamps required for review. Operational logs can retain deeper technical evidence for support and audit. Different audiences need different resolution, but all should refer to the same underlying task state.
Design waiting and intervention together
A progress surface is also a control surface. It should tell the user whether they can leave, pause, cancel, change priority or provide input. Those controls need honest semantics. Closing a panel is not cancellation. A cancellation request may not reverse actions already completed. Editing the objective may create a new task rather than safely changing the existing one.
Place intervention where it can still change the outcome. Before a consequential action, show what is proposed, the basis for it and the consequence of confirmation. While the system is waiting, preserve the evidence and state needed for another authorised person to respond. After a partial failure, separate retryable work from changes that require compensation or manual repair.
Status must also be accessible. W3C's WCAG guidance covers messages about waiting, progress, success and errors and requires them to be programmatically available to assistive technologies without taking focus. Do not encode the current state through motion or colour alone. Announce meaningful changes, avoid noisy updates and let users inspect a stable history when several transitions matter.
The interface cannot invent the state
A well-written status message cannot repair an execution system that loses task identity, forgets completed actions or cannot distinguish waiting from failure. Product design, engineering and operations must share one state contract. The interface renders it. The orchestration layer maintains it. Tools report evidence into it. Telemetry records transitions. Support and recovery processes act on the same history.
Anthropic's research on long-running coding agents found that coherent work across sessions required incremental progress and clear artefacts, not context continuity alone. The specific harness is provider and coding evidence. The wider product implication is useful: if the system cannot leave durable evidence of what has been completed, the interface cannot truthfully tell the user where the task stands.
Define service expectations around meaningful transitions. How quickly should acceptance be confirmed? How long can a task wait for input? What makes a task stale? Which failure triggers escalation? When may completed task data be removed? These are operating decisions with customer, cost and risk consequences. They should not be left to animation timing or default infrastructure settings.
Use a progress contract for one consequential task
Apply the following decision aid before designing the progress component. Start with one task whose duration, consequence or need for intervention makes status material. The purpose is to align the experience with the work and the operating evidence behind it.
Test the contract with normal work, a changed plan, missing input, a partial tool failure, cancellation and completion with an exception. If the interface cannot distinguish those conditions, the product does not yet have a dependable progress model. If the underlying system cannot supply the evidence, the design has found an engineering or operating gap rather than a copy problem.
The right result may be modest. A short, reversible task may need only accepted, working and completed states. A consequential workflow may need milestones, evidence, authority checks and recovery history. The standard is not maximum visibility. It is enough truthful state for the user to decide whether to wait, intervene, inspect, recover or move on.
- Objective: What outcome did the user delegate, and which material limits were accepted with it?
- State: Which small set of states changes what the user should understand or do?
- Evidence: What observable event proves each transition, and what completed work must remain inspectable?
- Expectation: What can be said honestly about time, milestones, plan changes and the next meaningful event?
- Control: When can the user pause, redirect, supply input, cancel or escalate, and what does each action actually do?
- Outcome: How will completion, exception, failure and recovery explain what changed and what remains?
Sources and further reading
- Microsoft ResearchGuidelines for Human-AI Interaction
- W3C Web Accessibility InitiativeUnderstanding Success Criterion 4.1.3: Status Messages
- Nielsen Norman GroupDesigning for Long Waits and Interruptions
- OpenAINew tools and features in the Responses API
- Model Context ProtocolTasks
- AnthropicEffective harnesses for long-running agents