WorkflowAgent streaming returns large chunks instead of token-level events. Please help 🙏 🙏 🙏 🙏

[kmoyya]

Issue

When using workflow.as_agent().run(stream=True), workflow agents buffer responses into large text chunks instead of streaming individual tokens like single agents.

Code Comparison

Single Agent (✅ Token-level streaming works)

from agent_framework import Agent

agent = Agent(
    name="single_streaming_agent",
    client=AnthropicClient(api_key="...", base_url="..."),
    instructions="You are a creative copywriter."
)

async for event in agent.run("Write a short tagline for electric bike.", stream=True):
    if event.contents:
        print(f"AgentResponseUpdate: '{event.contents[0].text}' ({len(event.contents[0].text)} chars)")

Workflow Agent (❌ Buffering issue)

  from agent_framework import SequentialBuilder

  workflow = SequentialBuilder().add_agent(agent).build()
  workflow_agent = workflow.as_agent()

  async for event in workflow_agent.run("Write a short tagline for electric bike.", stream=True):
      if event.contents:
          print(f"AgentResponseUpdate: '{event.contents[0].text}' ({len(event.contents[0].text)} chars)")

Comparison

Single Agent :

  AgentResponseUpdate: '"' (1 char)
  AgentResponseUpdate: 'Ride' (4 chars)
  AgentResponseUpdate: ' sm' (3 chars)
  AgentResponseUpdate: 'arter, spen' (11 chars)
  AgentResponseUpdate: 'd less,' (7 chars)
  AgentResponseUpdate: ' arrive happy' (13 chars)
  AgentResponseUpdate: '."' (2 chars)

Workflow Agent (Current Issue):

  AgentResponseUpdate: 'Write a short tagline for a budget-friendly electric bike targeting urban commuters.' (84 chars)
  AgentResponseUpdate: '**"City Miles, Penny Smiles."**\n\n---\n\nAlternative options:\n\n- "Commute Smart. Spend Less. Ride
  Happy."\n- "Your City. Your Ride. Your Budget."' (180 chars)

Question

The workflow loses token-level granularity essential for real time streaming UIs (For AGUI)

How can we preserve token-by-token streaming when using workflow.as_agent().run(stream=True)? 🙏

[Evan Mattson (moonbox3)]

Thanks for raising this! The good news is that AG-UI now natively supports MAF workflows, so you no longer need to wrap your workflow with .as_agent() to integrate with AG-UI. This preserves token-level streaming granularity.

Use AgentFrameworkWorkflow and add_agent_framework_fastapi_endpoint to expose your workflow directly:

from agent_framework.ag_ui import AgentFrameworkWorkflow, add_agent_framework_fastapi_endpoint
from fastapi import FastAPI

app = FastAPI()

demo_workflow = AgentFrameworkWorkflow(
    workflow_factory=lambda _thread_id: workflow,  # your built workflow
    name="my_workflow",
    description="Streaming workflow demo",
)

add_agent_framework_fastapi_endpoint(
    app=app,
    agent=demo_workflow,
    path="/my-endpoint",
)

The .as_agent() wrapper was designed for composability (embedding a workflow inside another agent), not for streaming fidelity — so the buffering behavior you observed is expected in that path.

For a full working example, check out the AG-UI Workflow Handoff demo.

[Raj (rajshukla09)]

One thing I’ve found useful with multi-agent workflows is keeping the UI protocol separate from the orchestration model.

The workflow should own coordination and participant transitions, while AG-UI should ideally just expose the resulting events consistently to the client.

This becomes especially noticeable once you introduce dynamic orchestration or remote agents, because you don’t want UI concerns influencing how the agents themselves coordinate.

I’ve been experimenting with multi-agent orchestration and A2A patterns in .NET here:
https://github.com/rajshukla09/building-ai-agents-with-dotnet-part-2

I’m also interested in how others are handling event correlation when multiple agents are producing streamed output in the same workflow.

[Raj (rajshukla09)]

I’ve run into a similar architectural question around WorkflowAgent streaming.

From an application perspective, I’d ideally want the workflow boundary to preserve incremental updates rather than effectively turning a multi-step execution into a small number of large aggregated chunks.

That becomes particularly important for UI responsiveness, observability and long-running multi-agent workflows.

I’ve been working on workflow, OpenTelemetry and multi-agent patterns in .NET here:
https://github.com/rajshukla09/building-ai-agents-with-dotnet-part-2

I’d be interested in whether the intended model is for WorkflowAgent to expose fine-grained underlying workflow events, or whether consumers are expected to observe those through the workflow execution layer separately.