[FEATURE] Steering Support for Bidirectional (BiDi) Agents

[dbschmigelski]

Problem Statement

The current steering system (steer_before_tool() and steer_after_model()) was designed for unidirectional agent execution flows. With the introduction of bidirectional streaming agents (Python 3.12+), there is no clear path for how steering handlers should intercept and guide agent behavior in a bidirectional context.

As noted in PR #1429, "steering on bidi agents is currently uncertain" and this needs to be resolved before the steering feature can exit experimental status. The existing implementation focuses exclusively on unidirectional agents, leaving bidirectional support as undefined future work requiring architectural decisions.

Proposed Solution

Design and implement steering support for bidirectional agents that addresses:

1. Event Interception Points: Define where in the bidirectional streaming flow steering handlers can intercept events (e.g., during streaming chunks, at message boundaries, or at turn completion)

2. Action Semantics: Clarify how Proceed, Guide, and Interrupt actions behave in a streaming context:

   • Can a Guide action be issued mid-stream to redirect the model?
   • How does Interrupt interact with an active bidirectional stream?
   • Should there be new action types specific to streaming scenarios?

3. Handler Interface: Extend or adapt the SteeringHandler protocol for bidi agents:

   async def steer_bidi_stream(
       self, agent: Agent, stream_event: StreamEvent, **kwargs
   ) -> BiDiSteeringAction

Proposed Solution

No response

Use Case

Steer bidi agents in the same manner as uni agents

Alternatives Solutions

No response

Additional Context

No response

[strands-agent]

🦆 Strands-Coder Analysis: BiDi Steering

Hi @dbschmigelski! Thanks for creating this feature request - this is an important architectural consideration as bidirectional streaming becomes more widely used.

My Analysis

I've reviewed the current steering implementation and the bidi agent architecture. Here's what I've found:

Current Architecture

Unidirectional Steering (src/strands/agent/steering.py):

• steer_before_tool() - intercepts before tool execution
• steer_after_model() - intercepts after model call via AfterModelCallEvent
• Returns SteeringAction: Proceed, Guide, or Interrupt

BiDi Architecture (src/strands/agent/agent_bidi.py):

• Uses BidiEvent stream for real-time communication
• Events include: audio_delta, tool_call_start, turn_end, etc.
• Runs in an async context with streaming chunks

Key Design Challenges

1. Event Granularity: BiDi events are finer-grained (audio chunks, partial tool calls) vs unidirectional (complete model responses)

2. Stream Interruption: A Guide or Interrupt action mid-stream could cause:

   • Incomplete audio playback
   • Orphaned tool calls
   • Inconsistent conversation state

3. Timing: When should steering be invoked?

   • Per-chunk? (High overhead)
   • At turn boundaries? (May miss real-time guidance needs)
   • On specific event types only?

Suggested Approach

I'd propose event-boundary steering that aligns with natural conversation flow:

class BiDiSteeringHandler(Protocol):
    async def steer_on_turn_end(
        self, 
        agent: BidiAgent, 
        turn: TurnSummary,
        **kwargs
    ) -> BiDiSteeringAction:
        """Steer at the end of each conversational turn."""
        ...
    
    async def steer_on_tool_call(
        self,
        agent: BidiAgent,
        tool_call: ToolCallEvent,
        **kwargs  
    ) -> BiDiSteeringAction:
        """Steer when a tool call is about to execute."""
        ...

This:

• Avoids mid-stream interruption complexities
• Aligns with existing steer_before_tool() semantics for tool calls
• Provides clear action points for Guide (inject system message for next turn)

Questions for Discussion

1. Should Interrupt in BiDi stop the current stream immediately, or wait for a natural pause?
2. Is there a need for "soft" vs "hard" interrupts?
3. Should steering have access to the raw audio stream, or only transcribed text?

I'd be happy to contribute to the implementation once the design direction is settled. This is a great opportunity to extend the steering system thoughtfully! 🎯

---

🤖 This is an experimental AI agent response from the Strands team, powered by Strands Agents. We're exploring how AI agents can help with community support and development. Your feedback helps us improve! If you'd prefer human assistance, please let us know.