CrewAI is now fully AG-UI compatible

We just released the latest AG-UI integration for CrewAI

Here's the TL;DR

ag-ui-crewai 0.3.0 is out. CrewAI Flows now stream the full AG-UI event surface — reasoning, multimodal input, human-in-the-loop interrupts, multi-agent attribution, thread persistence and generative UI — so any AG-UI client can render a crew without hand-rolling a transport.

• Install it — pip install ag-ui-crewai (PyPI)
• Scaffold a project — npx copilotkit@latest init --framework crewai-crews
• See it running — the CrewAI integration showcase
• Read the full source — the competitor-analysis crew demo, a four-agent crew with a walkthrough video

What it does

Build a CrewAI crew, then try to put a real interface in front of it, and the UI has to fake everything the terminal gave you for free. Reasoning arrives as one block at the end, if at all. An approval step means hand-rolling pause-and-resume. A crew nested in a flow collapses into one undifferentiated stream of text.

ag-ui-crewai is the AG-UI protocol implemented for CrewAI. It turns a Flow into a streaming HTTP endpoint any AG-UI client can render: reasoning, tool calls, state, interrupts and generated UI arrive as typed events rather than a blob of text, so the frontend stays the same frontend no matter which framework is underneath it.

0.3.0 is the release where that surface is complete, with regular Flows and Conversational Flows both at full showcase parity.

The setup

from crewai.flow.flow import Flow, start
from ag_ui_crewai import add_crewai_flow_fastapi_endpoint
from fastapi import FastAPI

app = FastAPI()
add_crewai_flow_fastapi_endpoint(app, MyFlow(), "/flow")

That's the integration! Your Flow doesn't change — it gains an endpoint that streams AG-UI events.

What you get out of the box

• Flows first — regular Flows and Conversational Flows are the supported paths, both at full parity. A bare Crew runs through the ChatWithCrewFlow wrapper; broader Crew support is separate work.
• FastAPI endpoint creation — HTTP endpoints with proper event streaming, generated for you
• Predictive state updates — state synchronized between backend and frontend as the run happens
• Streaming tool calls — LLM responses and tool execution stream to the UI live
• Backend tool rendering — tools bound to a CrewAI Agent or Crew run server-side and surface to the client as a tool call plus a result event, so the UI renders them without executing the tool. Needs crewai 1.6+, and a tool returning structured data should return a JSON string.

What's new in 0.3.0

• Conversational Flows — CrewAI's native turn-based Flows, wired through the same event translator, state sync, tools, reasoning, interrupts and generative UI as regular Flows
• Full event parity — reasoning and thinking streams, multimodal input, backend tool execution results, and MCP tool call visibility
• Human-in-the-loop — a real interrupt and resume flow, so an agent can pause mid-run for user input and continue instead of losing its place
• Thread persistence and checkpointing — conversation and run state can persist across requests, opt-in behind CREWAI_CHECKPOINT
• Multi-agent visibility — crews and agents nest under the flow method that opened them, with depth and parent ids carried on the step events, so a multi-agent run is traceable instead of one undifferentiated stream
• Generative UI (A2UI) — full compatibility with our generative UI protocol and the A2UI declarative schema
• Shared-state streaming — live state snapshots streamed to the frontend
• Bug fixes — crew-run output handling was silently dropping text and tool output, and a memory leak let conversation state bleed across chat threads. Both fixed.

Conversational Flows, specifically

Conversational Flows are CrewAI's session-aware, turn-based Flows, entered through stream_turn rather than kickoff. They get the same treatment as regular Flows: the same event translation, state synchronization, tools, reasoning, multimodal content, interrupts and generative UI support. Opt the Flow into CrewAI's public conversation API, then register the endpoint with conversational=True:

add_crewai_flow_fastapi_endpoint(app, MyConversationalFlow(), "/conversational-flow", conversational=True)

Detection is capability-based, not version-gated: the bridge needs the StreamFrame transport plus that public turn API. If the installed runtime can't provide both, the endpoint emits a correlated RUN_ERROR rather than quietly falling back to regular kickoff semantics, so a misconfiguration fails where you can see it.

One caveat worth knowing before you hit it: CrewAI builds a Flow's graph from the attributes defined directly on the subclass, so a subclass that only sets conversational = True inherits none of the base Flow's @start and @listen methods and runs an empty graph, which means your steps silently never fire. Re-copy the base's flow methods onto the conversational type.

Try it live

Every capability above is running in a browser right now, no install required: the CrewAI Flows showcase hosts 38 live demos built against the real integration.

That includes the ones this release made possible — reasoning rendered both by the built-in chat and through a custom message slot, human-in-the-loop in-chat, in-app and headless, multimodal image and PDF attachments, sub-agent delegation with a live delegation log, per-token state streaming and bidirectional shared state, and A2UI generative UI in dynamic-schema, fixed-schema and error-recovery variants.

To run the same starter locally:

npx copilotkit@latest init --framework crewai-crews

One footgun, if you wire up interrupts

Pass the interrupt-outcome flag when you register the endpoint:

add_crewai_flow_fastapi_endpoint(app, MyFlow(), "/interrupt", emit_interrupt_outcome=True)

On CopilotKit 1.61.2 and newer, resume only works through the structured outcome. The legacy channel renders the interrupt fine, but its resolve sends nothing back, so the run kicks off again and re-pauses — an infinite loop. Unit tests and curl won't catch it; it only surfaces through the runtime.

Which version you need

The floor is crewai>=1.0,<2. The bridge probes for capabilities at runtime rather than gating on version strings, so an older install gets a working bridge with fewer features instead of a crash. What each feature actually needs:

• MCP tool calls — 1.4+
• The StreamFrame transport, and backend tool rendering with it — 1.6+
• Human-in-the-loop — 1.8+, with stable request ids from 1.12.2
• Multimodal file input — 1.9+
• Checkpointing — 1.14+
• Conversational Flows — 1.15+; the showcase and docs pin 1.15.11
• Reasoning — any 1.x, since it reads LiteLLM deltas rather than a CrewAI event

Multimodality is honest about its edges. Images and PDFs are validated end to end; audio, video and documents currently route through the same image channel and may be rejected by strict providers. Native per-type mapping is a known gap rather than a shipped feature.

Getting started

• Install — pip install ag-ui-crewai
• Docs — docs.copilotkit.ai/crewai-flows
• PyPI — pypi.org/project/ag-ui-crewai
• Source — github.com/ag-ui-protocol/ag-ui (please star!)

MIT-licensed, open source, from the team at CopilotKit. If you're building on CrewAI and you want it in front of real users, this is the layer that gets it there.

Want to bring CopilotKit into your stack? Talk to our engineers and we'll help you set it up.

Follow CopilotKit on Twitter for updates. If you get stuck, reach out in the CopilotKit or AG-UI communities.