Streaming

Streaming is how ACP exposes live work. Instead of waiting for a final answer, you can consume event streams for status changes, working logs, assistant deltas, and execution milestones while a thread is running.

Use ACP event streams to render execution as it happens.

Stream execution events

ACP can emit incremental events during execution so applications can render work in progress rather than polling for a final result. This makes thread execution feel operational instead of opaque.

Render working logs and status changes as they happen.

Expose assistant deltas for a more fluid user experience.

Build monitoring and UX around event streams instead of only terminal output.

Render model reasoning separately from tool progress

ACP reasoning events represent thinking summaries produced by the model. Generic tool progress such as file reads, shell command labels, or status text should be rendered as execution logs, not as reasoning.

Use response.item.completed events with item.type === "reasoning" for model-produced thinking summaries.

Expect reasoning content as a string on current clients; older clients may receive content.text.

Keep tool calls, file changes, and shell output visually separate from reasoning logs.

Handle reasoning events

Handle permission requests while a thread is running

A running thread can pause in permission_asked state when the runtime needs approval for an action. The SDK exposes pending requests and decision endpoints so your product can approve or deny without polling unrelated state.

List pending permission requests for the thread that is paused.

Approve only the specific request ID that the user reviewed.

Use deny decisions with a reason when the agent should continue with a safer plan.

Approve a pending permission request

Build responsive interfaces

Streaming lets ACP-powered products surface activity without blocking. It is especially valuable when agents are working against persistent computers, browsing, or changing files over a longer period of time.

Use streams to show progress during long-running work.

Separate visible status from final output rendering.

Treat streaming as core infrastructure for perceived latency.

Operationalize long-running runs

Streaming becomes more important as ACP runs grow longer and more stateful. It gives developers a consistent way to monitor work, detect stalls, and understand what is happening inside a run before it finishes.

Instrument UX and monitoring around event flow.

Use streams to expose real-time system feedback.

Keep users informed while ACP performs stateful work in the background.