Incident sheet · /enterprise-ai

Filed
Read
4 min · 767 words
Severity
Routine

AG-UI standardizes the last-mile between agents and users

AG-UI defines 16 event types for streamed agent-user interaction, with middleware, an HTTP reference implementation and a Dojo that grew from 4 demos to more than 30.

Getting started with AG-UI — the agent-user interaction protocol
FeedGetting started with AG-UI — the agent-user interaction protocol — Pexels / pixabay

Event log

  1. AG-UI defines 16 standard event types over a single event stream.
  2. Google proposed A2A in April 2025; it joined AAIF in August 2026 and uses JSON-RPC 2.0 over HTTPS.
  3. MCP was developed by Anthropic and released to AAIF under the Linux Foundation.
  4. The AG-UI Dojo grew from 4 demos to more than 30 in about a week.
  5. The old Haiku demo used gpt-4o or an environment-configured OpenAI model, with code details on lines 89–93 and 100–104.

AG-UI defines 16 standard event types for streamed agent-user interaction, with compatibility middleware, a reference HTTP implementation and a default connector.

The protocol grew out of CopilotKit’s initial partnership with LangChain and CrewAI. It now supports most major agent frameworks, targeting production integration rather than another layer of framework-specific plumbing. Developers shaped it from real-world requirements and practical experience.

The last-mile integration gap

AI agents have supplanted simple chats for serious work with large and small language models. Their “last-mile problem” is showing what an agent is doing and letting the user act, without every team building its own interface plumbing.

AG-UI standardizes the connection between agent back ends and user-facing applications. It does not make an agent reason better; it makes the running agent visible and actionable.

An AI agent thinks, plans and performs several actions in sequence. Unlike a chatbot answering one prompt, it runs a cycle of reasoning, tool use, outcome analysis and adjustment.

An agent generally has four standard components. Together, they turn a model into a working system.

  • Brain: usually a large language model that supplies reasoning.
  • Hands: tools that reach browsers, APIs or code execution.
  • Memory: short-term context in RAM and long-term context in a database, typically a vector database.
  • Orchestrator: workflow management covering loops and communication between steps.

Agent frameworks package the tools, libraries and architectural components for designing, orchestrating and executing these systems. They supply infrastructure for planning, tool use, retained interaction history and multi-step execution, rather than a single-turn text prompt.

How AG-UI fits the protocol stack

The protocol stack now assigns different jobs to six standards. AG-UI occupies the interface layer left by the others.

  • MCP: connects agents to tools and data sources.
  • A2A: connects agents to other agents.
  • UCP: supports commerce.
  • AP2: supports payments.
  • A2UI: supports UI composition.
  • AG-UI: supports streamed agent-user interaction.

MCP is an open-source standard framework for connecting AI applications to external systems. Anthropic developed it before releasing it to the Agentic AI Foundation under the Linux Foundation. The protocol cuts integration time and complexity across data sources, tools and applications.

The guidance on MCP remains blunt: it suits small local projects, but it is neither the most efficient nor the most secure protocol available. It also performs poorly at internet scale, so production teams should use enterprise APIs for their data sources, tools and applications.

Google proposed A2A in April 2025, and the protocol joined the Agentic AI Foundation in August 2026. The open standard complements MCP rather than replacing it.

Agents can discover each other’s capabilities, negotiate text, forms or media, and collaborate securely on long-running tasks without exposing internal state, memory or tools. A2A uses JSON-RPC 2.0 over HTTPS.

AG-UI adds the user-facing link through one event-driven stream designed to be straightforward and adaptable. Back ends emit events matching its 16 standard types and accept one of several simple AG-UI-compatible inputs as arguments. A flexible middleware layer handles compatibility across environments, while the reference HTTP implementation and default connector provide a working baseline.

What does AG-UI change for enterprise teams?

Autonomy alone does not make an agent usable. Teams still need agents to report progress, present results and accept user intervention, while AG-UI seeks to remove repeated integration code across otherwise different frameworks.

The first look at the AG-UI Dojo found four demos. About a week later, its catalogue contained more than 30, and the selected haiku generator had disappeared. The web demos require no installation; developers can defer setup until they start building.

The old Haiku generator had something the newer examples lacked: some documentation, images and CSS styling. Its prompt was “autumn haiku”. Its Python code used gpt-4o, or whichever OpenAI model the environment specified, through OpenAiCompatibleConfig on lines 89–93; the system prompt occupied lines 100–104.

Most other Dojo examples were simpler and easier to understand, if less attractive. They ranged from basic interactions to more elaborate applications, which made the catalogue a practical test bed rather than a polished product suite.

AG-UI will not make agents smarter or replace a preferred agent framework. It offers a reusable event model and less custom code when connecting back ends to interactive applications. As agentic AI matures, that interoperability matters, and the Dojo provides the sensible place to test it.

The protocol can save considerable developer effort, but it supplies no deployment count, benchmark or cost figure. Its business case therefore remains architectural rather than financial.

via infoworld.com/feed/ (Source)

Filed under

  • ag-ui
  • ai-agents
  • agent-interoperability
  • streamed-events
  • agent-frameworks
Share this article:

More from Tom Whitfield

Tom Whitfield

Show full bio

Market editor covering people, launches and day-to-day practice in enterprise information technology and the leaders who run at CIO Monitor.

183 articles

The newsroom digest

One email a day with the stories that matter. No noise.

By subscribing you agree to the privacy policy.

Cross-references

‹ Previous articleNext article ›