ena pragma
·7 min read·ai-infrastructure · agentic-ux · protocols

AI agents are learning to build their own screens. Nobody agrees on how yet.

A cited look at the new protocols connecting AI agents to user interfaces: what's verified real, one overclaim corrected, and why no single standard has won.

Contents

Most people's experience of an AI agent is still a text box: you type, it types back. That is starting to change, and four different companies, including Google, OpenAI, and Microsoft, have each shipped a competing specification in the last year for how an AI agent should build and control an actual interface instead of just words. None of them has won yet. Here is what is verified, what one company overstated about its own role, and why "who's winning" is the wrong question to ask right now.

#The problem, in plain terms

A chat interface works because the pattern is simple: you ask, it answers. An AI agent doing real work breaks that pattern. It runs for minutes, not seconds. It needs to show you a form, a chart, a multi-step workflow, not just a paragraph. It might need you to approve something halfway through and then keep going. Text-only agents handle this by describing everything in words, which is why using one for anything complex can feel like reading a phone tree out loud.

The fix multiple companies converged on separately: standardize the connection between an agent's backend and whatever is rendering its output, the same way a handful of "model router" tools standardized how software talks to different AI models a couple of years earlier. Once that connection is standardized, an agent can hand a frontend a real, interactive component instead of a wall of text, and the frontend does not need custom code for every different agent that talks to it.

#What is actually real here, checked directly

The specific claim this piece traces back to a conference talk by Tyler Slaton of CopilotKit, a real company: a Seattle startup, co-founded in 2023, that announced $27 million in combined funding in May 2026, confirmed independently through GeekWire and TechCrunch rather than just the company's own announcement. GeekWire's own reporting breaks that figure down more precisely than a flat "$27M Series A": $20 million in new Series A capital plus a previously unannounced $7 million seed round. CopilotKit built AG-UI, an open-source protocol for exactly this agent-to-interface connection, real and independently verifiable at its own public repository (15,850 stars at the time of this check). GeekWire's own reporting, not CopilotKit's marketing, confirms that Google, Microsoft, Amazon, and Oracle have adopted the protocol, and names enterprise customers including Deutsche Telekom, Docusign, Cisco, and S&P Global.

Under the hood, AG-UI works by sending a small set of standardized events (a plain JSON stream of just what changed, not the whole screen every time) from an agent's backend to any frontend that knows how to read them. CopilotKit describes three levels of how much freedom an agent gets with that stream, all independently confirmed against the company's own documentation:

  • Controlled: the agent picks from a fixed set of components a developer already built. The safest option, and the least flexible.
  • Declarative: the agent assembles a structured description that maps onto a catalog of pre-approved building blocks. It decides what to show and how to arrange it, but it cannot invent a new kind of component on the fly.
  • Open: the agent generates the interface itself, live, inside a sandboxed environment with no pre-registered pieces.

One detail worth knowing if you have ever wondered how a chatbot inside Slack shows you something richer than text: for platforms with no native rich-interface support, one real fix in production is to quietly render the actual component in a headless browser and screenshot it into the channel. Clever, and also a real limit: what you get is a picture of an interactive thing, not the thing itself.

#The one claim that did not hold up, checked against the company's own words

The talk states, on camera, that CopilotKit "helped build" Google's separate agent-interface specification, A2UI, and that CopilotKit "owns the React portion of it." Checked directly against CopilotKit's own comparison page and Google's own developer blog, that overstates it. Google's blog credits A2UI as a Google-originated open project and says CopilotKit "worked with us to ensure day-zero compatibility." CopilotKit's own site describes itself as "a launch partner with Google," which built a specific tool and a reference implementation, not a co-creator of the underlying specification. That is a meaningfully narrower role than "helped build" and "own the React portion," and it is exactly the kind of claim that reads as settled fact if nobody checks the primary source before repeating it.

Separately, there is a real, unresolved number problem worth naming rather than smoothing over: Slaton states, on camera, "35,000 GitHub stars, 14,000 in AGUI," meaning 35,000 across CopilotKit's repositories with 14,000 of those specifically on the AG-UI repository. A GeekWire article from four months earlier already reported more than 40,000 for CopilotKit's open-source tools generally. A count like this should only go up over time, not down, so either GeekWire's figure and the talk's 35,000 are measuring different things, or one of them is simply imprecise. Nothing found in this research resolves which, so it is reported here as an open discrepancy rather than rounded to whichever figure sounds more current.

#The actual story is that nobody has won yet

The more interesting finding here is not any single protocol, it is that there are several competing ones. Google shipped A2UI. OpenAI has its own Apps SDK for building interactive components inside ChatGPT. A separate community specification, commonly called MCP-UI or MCP Apps, extends the existing Model Context Protocol with an iframe-based approach for embedding third-party app surfaces, authored by a group of independent contributors rather than any single company, with named adopters including Postman, HuggingFace, Shopify, and others. And CopilotKit's AG-UI positions itself as the neutral transport layer underneath any of them, capable of carrying other formats as a payload. At least four different approaches, from at least three different organizations plus an independent community effort, all active within roughly the same twelve-month window, and no evidence yet of any one of them consolidating the field.

That is a normal, healthy phase for a genuinely new category, and also a reason to be skeptical of any single company's talk, blog post, or press release that describes its own protocol as "the" answer. The honest read, checked against public sources rather than any one company's framing, is a land grab still in progress.

#Why this is worth knowing even if you never write a line of code

If you build software that talks to AI models, this affects a real, current decision: which of these specifications, if any, to build against today, knowing the landscape may look different in six months. If you are on the buying side of AI tools, the practical question is more mundane and more useful: does a vendor's AI assistant actually let you interrupt, correct, and continue a task in progress, or does it just produce a wall of text and hope you read all of it? That distinction, not the protocol underneath it, is what most people will actually feel.

And if you are skeptical of AI hype generally, this is a useful data point either way. A specification getting adopted by named Fortune 500 companies and independently confirmed by trade press is a real signal of momentum. A conference talk quietly overstating its own company's role in a rival's project, caught only by checking the primary sources directly, is a real reminder that momentum and marketing are not the same thing, and that the honest version of most stories in this space sits somewhere between the pitch deck and the dismissal.

We build agent infrastructure ourselves, and this is directly relevant to our own work, not just an interesting story from outside it: research from three months before this talk existed, done for our own internal tooling, had already flagged Google's A2UI project as worth studying, for reasons that turned out to match the same design questions this talk raises independently. We are not claiming to have called this trend or to be ahead of the companies named above; the overlap is a useful confirmation that the underlying problem is real, not a claim about who is winning.

#Sources

Keep reading