Keeping users oriented during long-running agent tasks

• Live progress beats a working state: the end-user should see progress updates and partial responses as the task runs, not one big reveal at the end.
• Streaming is not just for chat — any long agent run can push what it has so far instead of hiding it until completion.
• Partial output is honest progress; a spinner is a promise.

“Streaming lets you subscribe to updates of the agent run as it proceeds. This can be useful for showing the end-user progress updates and partial responses.”

Source: OpenAI — Agents SDK: Streaming ↗

• The interface should update automatically as new messages and results arrive — the user never refreshes, never polls, never asks.
• Arrival-driven updates are the difference between an agent that feels alive and one that feels stuck.
• Because updates are incremental, the last change is always visible proof the task is moving.

“It enables the streaming of chat messages from your AI provider, manages the chat state, and updates the UI automatically as new messages are received.”

Source: Vercel AI SDK — useChat reference ↗

• Long tasks decompose into steps; surface them as discrete, numbered units that complete one by one rather than one amorphous wait.
• A step indicator that ticks — “Step 3 of 7”, each finished step checked — reads as progress the way a spinner cannot.
• Only render the steps you know about: when the protocol says a step completed, mark it, and don’t fake progress you don’t have.

“A part indicating that a step (i.e., one LLM API call in the backend) has been completed.”

Source: Vercel AI SDK — Stream Protocols ↗

• A long-running agent must be interruptible mid-turn — the user can redirect without waiting for completion or starting over.
• Esc stops the running work and returns control; the interface waits for the next instruction instead of continuing on its own.
• Interrupting is steering, not abandoning — the context survives the interruption.

“You can redirect Claude at any point without waiting for the turn to finish or starting over: Press Esc to stop Claude immediately. The running tool call is canceled and Claude waits for your next instruction.”

Source: Claude Code docs — How Claude Code works ↗

• Even when the agent works through a multi-step loop autonomously, the human stays part of the loop and can interrupt at any point to steer.
• Present the task as guided by the user, not running away from them — control never leaves the human’s hands.
• Status UI should read as “working, but ready to be steered”, not “busy, wait”.

“You’re part of this loop too. You can interrupt at any point to steer Claude in a different direction, provide additional context, or ask it to try a different approach. Claude works autonomously but stays responsive to your input.”

Source: Claude Code docs — How Claude Code works ↗

• Restarting long work from scratch is expensive and frustrating — design so partial progress survives errors and interruptions.
• Keep what the agent produced and the state it needs; give users a resume path instead of a redo.
• When a step fails, show what completed, what failed and what will be retried — never a blank slate.

“When errors occur, we can't just restart from the beginning: restarts are expensive and frustrating for users.”

Source: Anthropic Engineering — How we built our multi-agent research system ↗

import json, urllib.request

with urllib.request.urlopen("https://api.example.com/sources") as r:
    data = json.load(r)
print(f"collected {len(data["items"])} sources")
print(sorted(s["domain"] for s in data["items"]))

collected 7 sources

• If a task runs longer than a couple of seconds, stream real progress: what it is doing, what step it is on, what it has produced so far.
• Keep users in control at every moment — interruptible, steerable, resumable — and never force a full restart.
• Progress you can see builds trust; a spinner you can’t tell apart from a hang builds anxiety.