AG-UI Update Empowers AI Agents to Guide Workflows and Collaborate on the Front-End

AI agents often power the hidden processes behind modern applications, handling tasks on servers without giving users a way to interact in real time. Teams aiming to add chat-like or task-guiding features typically build their own messaging layers, event handlers, and state sync logic. That work can feel repetitive, since many of those communication needs overlap across projects.

The first version of AG-UI appeared in May 2025 as an open-source demo of inline agent-user communication. It relied on a single-stream model—usually an HTTP POST request paired with Server-Sent Events (SSE)—and defined a basic set of JSON event types such as TEXT_MESSAGE_CONTENT, TOOL_CALL_START, and STATE_DELTA. Those pieces let developers handle streaming replies, invoke external tools, keep agent and UI in sync, and process events in a uniform way. Early adopters praised the foundation but asked for clearer event definitions, a versioning scheme, and support for popular frameworks to make AG-UI ready for production.

The newest update to AG-UI takes a different tack. Rather than shipping another toolkit or UI library, it offers a lean protocol focused on the back-and-forth between agents and front ends. The aim is to raise event clarity and extend compatibility with real-world agent systems, all while keeping the core layer independent of any one tech stack.

Key features in this release include:

• A formalized set of roughly sixteen event types that cover every stage of an agent’s operation—from streaming output to tool calls, state synchronization, user prompts, error signals, and completion notices.
• Streamlined JSON schemas for each event type. Clients and agents can now advertise which capabilities they support, negotiate protocol versions, and detect mismatches at runtime.
• Dual integration modes. Teams can build agents that natively emit AG-UI events or wrap existing systems with an adapter that intercepts standard outputs and converts them automatically.
• Better documentation, sample code, and language-specific SDKs that transform AG-UI from a research experiment into a practical choice for production projects.

Many teams still see AI agents as black boxes that only return a final result. To bring them into interactive apps, four key challenges must be addressed:

• Streaming replies: Delivering partial outputs or status updates as soon as they’re ready instead of sending one big payload at the end.
• Shared state: Keeping variables or task progress in sync between the UI and the agent, so that each side reflects the latest context.
• Tool orchestration: Letting the agent trigger external services (APIs, databases, or human inputs) via a clear, structured call-and-response system.
• Bidirectional chat: Enabling users to send messages or choices back to the agent and guide its next actions.
• Safety controls: Marking cancellations, errors, or unauthorized requests explicitly so front ends can manage retries or user alerts.

Without a uniform protocol, each team reinvents these elements. AG-UI tackles that by modeling each interaction as a typed event in a continuous stream. Agents emit events as they go, and clients subscribe to that feed, handle each event, and send their own events when a user steps in.

Under the hood, every event is a JSON object that carries a type field, a version tag, and other required properties. This versioning scheme means agents and UIs can gradually adopt new features without breaking older integrations. Error objects and control signals use their own event types, letting front ends pause or shut down an agent run in midstream.

The core taxonomy of AG-UI events looks like this:

• message: A piece of text or status update from the agent.
• function_call: A request to run a tool or server function.
• tool_result: The outcome of a previously requested function call.
• state_update: A sync message that carries updated task variables, progress bars, or other context data.
• input_request: A prompt asking the user for a value, choice, or confirmation.
• error: A signal indicating that something went wrong in the agent’s logic or a tool invocation.
• control: Commands such as cancel, pause, or complete that affect the agent’s runtime.

These and other event types cover the full lifecycle of a session. Clients can filter, batch, or rebroadcast events as needed. Every schema lists required fields, allowed relationships, and guides for extending with custom metadata.

Integration breaks down into two main patterns:

Native integration: An agent framework is enhanced to emit AG-UI events at key points in its pipeline. The framework’s internal hooks map directly to JSON events without external transformation.
Adapter layer: A translation module takes standard agent outputs—plain text, logs, or function calls—and converts them into AG-UI events. This lets teams retrofit existing agents without changing their core code.

On the front end, applications typically open a persistent channel via WebSocket or SSE, subscribe to the AG-UI event stream, and drive UI updates in response. Incoming events might render a chat bubble, launch a progress bar, prompt a dialog, or call a local helper function. User actions map back into AG-UI events that flow upstream to the agent.

The transport layer is pluggable. While SSE and WebSocket are the most common options for real-time needs, the protocol itself does not mandate a single method. This makes it easy to support mobile apps, desktop clients, or even email-based workflows.

Since its debut, AG-UI has attracted a growing community. Its event-driven approach has been baked into major agent orchestration projects, speeding up integration work for teams that once had to build custom APIs and socket handlers.

Projects that already support AG-UI or are working toward it include:

• LangChain, CrewAI, Mastra, AG2, Agno, LlamaIndex: Orchestration layers can now surface agent progress, tool calls, and chat prompts in interactive UIs.
• AWS AI services, A2A, ADK, AgentOps: Cloud monitoring, deployment pipelines, and operation dashboards integrate agent streams for live metrics.
• Human Layer (Slack integration): Agents appear as team members in messaging channels, asking questions, sharing updates, and accepting commands.

On GitHub, the protocol has more than 3,500 stars and powers a variety of commercial and open-source agent-driven products. It saves developers from rewriting the same socket code and event logic each time.

To reduce setup time, an official CLI tool—npx create-ag-ui-app—bootstraps a new project with dependencies, boilerplate code, environment setups, and sample integrations. The process takes minutes, giving teams a drop-in starter that works with popular front-end frameworks.

Schema documentation lives in a public repo and includes:

• Versioned JSON definitions for each event type.
• Sequence diagrams showing typical flows: chat session, tool invocation, error handling, user prompt, and clean shutdown.
• Examples in JavaScript, Python, and Java for both agent back ends and client implementations.
• A migration guide for teams moving from the first AG-UI release to the current protocol.

Common scenarios enabled by AG-UI:

• Embedded copilots: Agents that surface inline in text editors or design tools, offering suggestions and code snippets as users type.
• Conversational dashboards: Chat interfaces that maintain long-running sessions, let agents call analysis or search tools, and adapt their responses over multiple turns.
• Workflow orchestrators: Multi-step pipelines that blend automated tasks with human reviews, sending prompts when approval or manual input is needed.

With these pieces in place, teams can focus on high-level logic—training models, authoring prompts, designing UI experiences—rather than rebuilding low-level communication channels. The AG-UI protocol abstracts away much of the complexity in agent-user sync, streaming, and state tracking. Projects that adopt it report faster prototyping cycles, clearer event flows, and fewer edge-case bugs tied to manual event handling.