Skip to content

Stream event types

Every way of consuming a Strands stream yields the same set of events: async iterators and, in Python, callback handlers. They differ in their execution model, not in what they emit. This page is the reference for every event type the stream produces: lifecycle signals, model output, tool activity, and multi-agent coordination, plus how to serialize events when forwarding them over the wire.

Event Types

Section titled “Event Types”

Lifecycle Events

Section titled “Lifecycle Events”
  • init_event_loop: True at the start of agent invocation initializing
  • start_event_loop: True when the event loop is starting
  • event_loop_throttled_delay: Delay, in seconds, that the agent loop waited before retrying a model call after a retryable failure (by default only throttling, see Retry Strategies)
  • message: Present when a new message is created
  • event: Raw event from the model stream
  • force_stop: True if the event loop was forced to stop
    • force_stop_reason: Reason for forced stop
  • result: The final AgentResult

Model Stream Events

Section titled “Model Stream Events”
  • data: Text chunk from the model’s output
  • delta: Raw delta content from the model
  • reasoning: True for reasoning events
    • reasoningText: Text from reasoning process
    • reasoning_signature: Signature from reasoning process
    • redactedContent: Reasoning content redacted by the model

Tool Events

Section titled “Tool Events”
  • current_tool_use: Information about the current tool being used, including:
    • toolUseId: Unique ID for this tool use
    • name: Name of the tool
    • input: Tool input parameters (accumulated as streaming occurs)
  • tool_stream_event: Information about an event streamed from a tool, including:
    • tool_use: The ToolUse for the tool that streamed the event
    • data: The data streamed from the tool

Multi-Agent Events

Section titled “Multi-Agent Events”

Multi-agent systems (Graph and Swarm) emit additional coordination events:

  • multiagent_node_start: When a node begins execution
    • type: "multiagent_node_start"
    • node_id: Unique identifier for the node
    • node_type: Type of node ("agent", "swarm", "graph")
  • multiagent_node_stream: Forwarded events from agents/multi-agents with node context
    • type: "multiagent_node_stream"
    • node_id: Identifier of the node generating the event
    • event: The original agent event (nested)
  • multiagent_node_stop: When a node completes execution
    • type: "multiagent_node_stop"
    • node_id: Unique identifier for the node
    • node_result: Complete NodeResult with execution details, metrics, and status
  • multiagent_handoff: When control is handed off between agents (Swarm) or batch transitions (Graph)
    • type: "multiagent_handoff"
    • from_node_ids: List of node IDs completing execution
    • to_node_ids: List of node IDs beginning execution
    • message: Optional handoff message (typically used in Swarm)
  • multiagent_result: Final multi-agent result
    • type: "multiagent_result"
    • result: The final GraphResult or SwarmResult

See Graph streaming and Swarm streaming for usage examples.

Event Serialization

Section titled “Event Serialization”

Python streaming events are plain dictionaries. The SDK does not include a built-in serialization filter, so you control which events and fields to forward from your processes and servers.

When serving streamed responses (for example, over SSE or WebSockets), you can filter the yielded events to keep payloads compact:

import json


def filter_event(event: dict) -> dict | None:
    """Filter streaming events to only forward relevant data over the wire."""
    # Forward text deltas for real-time display
    if "data" in event:
        return {"type": "text", "data": event["data"]}


    # Forward tool usage for progress indicators
    if "current_tool_use" in event and event["current_tool_use"].get("name"):
        return {"type": "tool", "name": event["current_tool_use"]["name"]}


    # Forward the final result
    if "result" in event:
        return {"type": "result", "stop_reason": str(event["result"].stop_reason)}


    # Skip everything else (lifecycle signals, raw deltas, reasoning, etc.)
    return None




async for event in agent.stream_async("Hello"):
    filtered = filter_event(event)
    if filtered:
        await response.write(f"data: {json.dumps(filtered)}\n\n")

This approach lets you tailor the streamed output to your use case, for example forwarding only text deltas for a chat UI or including tool events for a progress dashboard.

Next Steps

Section titled “Next Steps”