Getting started with AG-UI — the agent-user interaction protocol AG-UI, an event-driven protocol that standardizes how AI agents connect to user-facing applications, is the subject of a new getting-started guide, positioned as the sixth major agent protocol alongside MCP for tools, A2A for agent-to-agent communication, UCP for commerce, AP2 for payments and A2UI for UI composition. AG-UI grew out of CopilotKit's initial partnership with LangChain and CrewAI and now supports most major agent frameworks, addressing the "last-mile problem" of displaying what an agent is doing and letting users act on it without each team building its own plumbing. The guide notes that MCP, originally developed at Anthropic and released to the Agentic AI Foundation under the Linux Foundation, is convenient for small local projects but not efficient or secure at internet scale, while A2A was proposed by Google in April 2025 and joined the Agentic AI Foundation in August 2026, using JSON-RPC 2.0 over HTTPS. While AI agents, which can perform long-running work autonomously, have supplanted simple chats for serious work with large and small language models, agents have a last-mile problem: How do you display what an agent is doing in front of a user and let the user act on it, without forcing every team to build its own plumbing? One answer is AG-UI https://github.com/ag-ui-protocol/ag-ui , which is intended to standardize how AI agents connect to user-facing applications. AG-UI was developed based on real-world requirements and practical experience. It grew out of CopilotKit’s initial partnership with LangChain and CrewAI, but has grown to support most of the major agent frameworks. An AI agent is like a self-driving car for computers—it’s a software system that uses artificial intelligence to think, make plans, and do several things in a row to get what it wants. Unlike a typical chatbot that responds to a single question, an AI agent can engage in a continuous cycle of thinking, utilizing tools, analyzing outcomes, and refining its approach for the next iteration. AI agents have a brain usually a large language model, LLM ; hands tools that can access web browsers, APIs, or code execution ; memory short-term context in RAM, and long-term context in a database, typically a vector database ; and an orchestrator a manager for the workflow, loops, and communication between steps . Agent frameworks are software toolkits that help you to build agents. Some of the most important agent frameworks are shown in the table below. An AI agent framework is a collection of software tools, libraries, and architectural building blocks that assist developers in designing, orchestrating, and executing autonomous AI systems. An agent framework offers the infrastructure for an LLM to reason, plan, utilize tools, retain past interactions, and execute multi-step workflows, rather than simply prompting it to generate text in a single turn. The first two widely-supported standard protocols used by agent frameworks, one to allow agents to talk to tools MCP , and one to allow agents to talk to other agents A2A , seemed like big deals when they were introduced, and still are, but they aren’t the end of the story. Additional protocols for agents support commerce UCP , payments AP2 , and UI composition A2UI . A sixth protocol to support streamed agent-user interaction AG-UI is the subject of this article. MCP Model Context Protocol https://modelcontextprotocol.io/docs/2026-07-28/getting-started/intro is an open-source standard framework for connecting AI applications to external systems. It was originally developed at Anthropic https://www.anthropic.com/news/model-context-protocol and then released to https://modelcontextprotocol.io/docs/2026-07-28/getting-started/intro the Agentic AI Foundation AAIF , under the umbrella of the Linux Foundation. MCP reduces development time and complexity when integrating an agent with data sources, tools and apps. It’s very convenient for small local projects. It’s not the most efficient or secure protocol in the world and it doesn’t really perform well at internet scale, however. If you want an efficient production integration, you’ll have to bite the bullet and use the enterprise APIs of your data sources, tools, and apps. The Agent2Agent A2A protocol https://github.com/a2aproject/a2a is an open standard for communication and collaboration between AI agents. It was proposed by Google in April 2025, and joined the Agentic AI Foundation AAIF in August 2026. A2A complements MCP, and does not replace it. With A2A, agents can discover each other’s capabilities, negotiate interaction modalities text, forms, media , collaborate securely on long-running tasks, and operate without exposing their internal state, memory, or tools. A2A uses JSON-RPC 2.0 over HTTPS. AG-UI https://github.com/ag-ui-protocol/ag-ui is a simple, event-driven protocol to help AI agents connect to user-facing apps. It’s designed to be straightforward and adaptable, so it makes it easy for AI agents to work with the user’s interface. During agent executions, agent back ends emit events compatible with one of AG-UI’s 16 standard event types. Agent back ends can accept one of a few simple AG-UI–compatible inputs as arguments. AG-UI includes a flexible middleware layer that ensures compatibility across diverse environments. It also ships with a reference HTTP implementation and default connector. The first time I looked at the AG-UI tools and demos https://dojo.ag-ui.com/ in the AG-UI Dojo, I found four of them see screenshot below . A week or so later, there were more than 30 — but the Haiku generator I had picked was no longer among them. You should have a look at the AG-UI Dojo yourself. You can do that on the web; there’s no need to install https://docs.ag-ui.com/quickstart/applications automatic-setup anything until you want to start building. Nevertheless, I want to show you the old Haiku generator demo. Unlike any of the current demos, it has some well, a little documentation, uses images, and has some CSS styles. Foundry Most of the other demos are much simpler and easier to understand, albeit less attractive. AI agents are moving beyond simple chatbots to become increasingly autonomous systems capable of planning, using tools, and executing complex workflows. But autonomy alone isn’t enough. Agents also need effective ways to communicate their progress, present results, and interact with users. That’s the gap AG-UI aims to fill. AG-UI complements two other important agent protocols: MCP, which connects agents to tools and data sources, and A2A, which enables communication between agents. By standardizing event-driven communication between agent back ends and user-facing applications, AG-UI reduces the need for custom integration code while supporting a wide variety of agent frameworks. The AG-UI architecture is relatively straightforward, with a single event stream, 16 standard event types, middleware for compatibility, and a reference HTTP implementation. The AG-UI Dojo demonstrates how these pieces work together. Its examples range from simple interactions to more elaborate applications. AG-UI won’t make your agents smarter, and it won’t replace your favorite agent framework. What it can do is make agents easier to integrate into interactive applications, potentially saving developers considerable effort. As agentic AI matures, that kind of interoperability will become increasingly important. The AG-UI Dojo is a good place to start exploring it.