The Pain: Your agent is capable — querying data, writing reports, sending emails. But it lives in a chat box: you ask, it answers; you stop, it stops. Users can't see its process, only wait for results. The experience is still "chatbot."
What You'll Learn: AG-UI (Agent User Interface) — the last of 2026's three agent-interconnect protocols, and why the interaction layer determines whether an agent can be commercialized.
Three-Protocol Recap: Where We Are
We covered MCP and A2A in previous articles. Now the trio is complete:
| Protocol | Solves | Article |
|---|---|---|
| MCP | Agent ↔ Tool (USB) | D1 ✅ |
| A2A | Agent ↔ Agent (Phone) | D2 ✅ |
| AG-UI | Agent ↔ Human (Screen) | D3 🔜 this one |
Why is AG-UI the "final piece"?
Because the first two protocols solve "how agents work internally," while AG-UI solves "how agents deal with humans" — and humans are the ones who pay.
An agent can use tools perfectly and collaborate flawlessly, but if human users can't understand or operate it comfortably, it still can't be commercialized.
Same capability: a "tool" in a chat box, a "product" on an interface.
The Problem: The Chat Box Isn't the Final Form of Agents
For two years we've gotten used to "agent = chat box."
User: analyze this month's logistics costs
Agent: OK, analyzing...
Agent: This month's logistics cost is 128K, up 23% MoM, mainly due to...
(the end)
What's wrong with this interaction?
- Process invisible: users don't know what data the agent queried or what steps it skipped — they blindly trust the result
- Low information density: 128K, 23%, main reasons... all crammed into text, users must "read" it themselves
- Not operable: user sees abnormal data, wants to drill down — impossible, must re-ask
- Not interruptible: agent goes off-track mid-analysis, user can't stop it or redirect
Core insight: the chat box is the most inefficient agent interface. It flattens multi-dimensional information into linear text and throws away both "process" and "operations."
What Is AG-UI: The Agent's "Display + Interaction" Standard
AG-UI (Agent User Interface) defines the standard for how agents present information to humans, receive instructions, and show process.
It focuses on three layers:
| Layer | Solves | Analogy |
|---|---|---|
| Display | how agents present process/results | dashboard |
| Interaction | how humans instruct, correct, drill down | remote control |
| State | what the agent is doing, how far along | progress bar |
Key shift: agent interaction evolves from "pure text conversation" to "structured interface" — data as charts, process as progress, operations as buttons.
Display / Interaction / State — the three layers of agent-human interface.
My Practice: From "Chat Box" to "Lightweight Interface"
I haven't adopted the AG-UI SDK (scale not reached), but I applied its core ideas to how I interact with agents — giving them three "interfaces."
Process Visualization: The Agent's "Progress Board"
Before, agents were black boxes. Now they report progress at every step:
# Agent proactively reports status (mimics AG-UI's State layer)
class AgentUI:
def __init__(self):
self.steps = []
def report(self, step: str, status: str, detail: str = ""):
"""Report each step to the UI"""
self.steps.append({
"step": step,
"status": status, # running / done / failed
"detail": detail,
"time": datetime.now().isoformat(),
})
self.render() # update the board
# Usage: users see each step as it completes
ui = AgentUI()
ui.report("check rate", "running", "querying SH→NY 100kg")
ui.report("check rate", "done", "result: $3.5/kg")
ui.report("generate quote", "done", "quote generated")
Users no longer "wait blindly" — they see what the agent is doing at every step. Trust changes completely.
Data Visualization: Results Are "Seen," Not "Read"
Before, reports were a blob of text. Now output is structured data users can view directly:
# Structured output (mimics AG-UI's Display layer)
result = {
"type": "report",
"title": "Monthly Logistics Cost Analysis",
"summary": "128K, +23% MoM",
"metrics": [
{"name": "Sea", "value": 62, "unit": "K", "trend": "up", "pct": 15},
{"name": "Air", "value": 41, "unit": "K", "trend": "up", "pct": 38},
{"name": "Land", "value": 25, "unit": "K", "trend": "down", "pct": -8},
],
"actions": [
{"label": "View sea details", "action": "drilldown", "target": "shipping"},
{"label": "Export full report", "action": "export"},
],
}
Users see not "128K, 23%, sea 62K, air 41K..." linear text, but a structured card they can drill down and operate on.
Interruptibility: When the Agent Goes Off-Track, Humans Can Stop It
# Pause / redirect interface (mimics AG-UI's Interaction layer)
class AgentSession:
def pause(self): ... # user stops
def redirect(self, instruction: str): ... # user corrects direction
def resume(self): ... # continue
Mid-way through a long task, if the user sees the direction is wrong, they "redirect" — instead of waiting for it to finish.
The Payoff: From "Chat" to "Interface"
| Dimension | Chat Box | Lightweight Interface |
|---|---|---|
| Process visibility | ✗ black box | ✓ step-by-step |
| Information density | low (linear text) | high (structured charts) |
| Operability | ✗ ask only | ✓ drill down / export |
| Interruptibility | ✗ wait only | ✓ pause / redirect |
| Trust | low (blind) | high (transparent) |
Practical conclusion: the interaction layer determines an agent's "commercial feel." With the same capability, it's a "tool" in a chat box and a "product" on an interface.
The same agent capability, two levels of commercial readiness.
When to Move to Real AG-UI
If the agent is just for your own use, the "interface thinking" above is enough. Real AG-UI is for:
- End-user products — your agent sold to customers; customers need "understandable, usable"
- Long complex workflows — users need to know progress and intervene anytime
- Multi-agent aggregate display — a team of agents working; users need one unified view
Where You Are Now
You've now completed the journey through 2026's three agent-interconnect protocols:
- MCP: agents use tools (D1)
- A2A: agents collaborate (D2)
- AG-UI: agents interact with humans (D3)
Together, they form a complete cognitive foundation for agent infrastructure.
Remember: tools are the agent's hands, collaboration is its team, and interface is its face. With all three, an agent can truly stand before users.
About the author: Wu Ji (无记) — AI & digitalization practitioner focused on Agent engineering, Loop Engineering, and digital transformation. Practical, hands-on tutorials — follow along and it just works.
Top comments (0)