Protocols, Not Models, Will Decide Which AI Coding Tools Win
The Next War in AI Programming Is Over Protocols, Not Models
Over the past year, AI coding tool competition has taken a counterintuitive turn. Model capabilities are still growing, but whether a tool enters a team's workflow is increasingly determined not by the model but by whether it can connect to your existing tools, frontends, and skills. You switch to a smarter Agent, only to find it can't connect to your MCP server; you try to push execution progress to your existing frontend, only to discover every new client requires rewriting a state mapping; your team norms become useless when you switch tools. This is not a model problem. It's a protocol layer problem.
This article breaks down three layers: MCP, AG-UI, and Agent Skills, along with three specific projects: AG-UI, Chrome DevTools MCP, and stitch-skills. Each project addresses a different gap and exposes the current maturity of the protocol layer.
Let's start with the conclusion:
MCP standardizes how tools are invoked, AG-UI standardizes how processes are seen, and Agent Skills standardizes how capabilities are carried.
These three layers are not alternatives; they compose. Understanding this is more important than memorizing any project's API.
1. Why the Protocol Layer Suddenly Matters
1.1 An Institutional Signal
From the second half of 2025 to early 2026, the clearest signal came from the Linux Foundation. It established the Agentic AI Foundation, bringing Anthropic's MCP, OpenAI's AGENTS.md, and Block's goose under one neutral hosting platform. Its membership includes Amazon, Google, Microsoft, OpenAI, Anthropic, Cloudflare, and Salesforce. Competitors putting their standards on the same table signals that the protocol layer is no longer just a demo convention; it now has an institutional footing. Infrastructure-level standardization doesn't mean everyone agrees; it means nobody can easily flip the table. For developers, the practical implication is direct: investments built on these protocols carry a lower risk of being locked into a single vendor.
1.2 Three Layers, Don't Mix Them Up
Before dissecting projects, clarify the protocol stack's division of labor.
| Layer | Problem it solves | Typical standard | Failure mode |
|---|---|---|---|
| Tool | How an Agent calls external tools, data sources | MCP | Agent can only talk, can't connect to real systems |
| Collaboration | How Agents divide work | A2A | Multi-agent setups need custom RPC to connect |
| Interaction | How an Agent tells the user process in real time | AG-UI | Frontend only gets final result, intermediate state lost |
| Capability | How an Agent carries reusable knowing-how | Agent Skills | Team norms must be rewritten when switching tools |
In plain terms:
- MCP handles what tools to use;
- A2A handles who to work with;
- AG-UI handles how to tell the user in real time as work happens;
- Agent Skills handles what rules to follow for this task.
A complete Agent application can simultaneously use MCP to connect to a browser and database, AG-UI to stream execution progress to the frontend, A2A to dispatch sub-agents when tasks are split, and Agent Skills to carry team norms. The more crucial change is that each layer is now producing concrete, installable, reusable engineering components, not just spec documents.
2. AG-UI: Event Streams as the Contract for Frontends to Connect to Agents
2.1 What It Actually Solves
AG-UI was initiated by the CopilotKit team in May 2025, positioned as an event-driven transport layer between Agents and user interfaces. Its design is restrained: instead of cramming heterogeneous content like conversation state, tool calls, intermediate reasoning, and human interruptions into a single request/response, the Agent emits a typed, ordered stream of events, and the client is responsible for consuming and rendering them. The official SDK defines around 27 standard event types, each with a type, timestamp, and optional run_id, covering streaming tokens, tool lifecycle, shared state changes, interruptions and resumptions. The 1.0 spec is frozen, and JSON Schema generates TypeScript, Python, and .NET SDKs, backward compatible with 0.x.
2.2 What an Event Stream Looks Like
Below is an illustrative snippet; fields follow the official schema:
{"type":"RUN_STARTED","threadId":"thread_1","runId":"run_1","timestamp":1730000000000}
{"type":"TEXT_MESSAGE_CONTENT","messageId":"msg_1","delta":"Opening page..."}
{"type":"TOOL_CALL_START","toolCallId":"call_1","toolCallName":"navigate_page"}
{"type":"TOOL_CALL_END","toolCallId":"call_1"}
{"type":"STATE_DELTA","delta":[{"op":"replace","path":"/step","value":"check_console"}]}
{"type":"RUN_FINISHED","threadId":"thread_1","runId":"run_1"}
When the client consumes it, it doesn't need to know whether the Agent uses LangGraph, CrewAI, or a custom loop; it only updates the UI based on event types.
// Pseudocode: subscription syntax varies across SDKs
const agent = new HttpAgent({ url: "/api/agent" });
const { result } = agent.runAgent({
threadId: "thread_1",
runId: "run_1",
messages: [{ role: "user", content: "Check the console errors on the homepage" }],
});
for await (const event of result) {
switch (event.type) {
case "TEXT_MESSAGE_CONTENT":
appendText(event.delta);
break;
case "TOOL_CALL_START":
showToolStatus(event.toolCallName);
break;
case "STATE_DELTA":
applyStateDelta(event.delta);
break;
case "RUN_FINISHED":
finishRun();
break;
}
}
2.3 Engineering Value: Turning Frontend Glue into a Contract
Previously, if you used a LangGraph Agent for a web app and then wanted it to serve terminals or Slack, each client required its own integration logic: one for WebSocket, one for SSE, another for CLI, with each state mapping written separately. AG-UI's abstraction: the Agent side is just an HTTP endpoint that accepts RunAgentInput and streams back events; clients use HttpAgent to consume the event stream. The same Agent can feed Web, mobile, and terminal clients simultaneously. LangChain documentation now includes an AG-UI adapter that translates LangGraph execution into AG-UI events. GitHub stars were around 17,000 to 18,000 around November 2025, with over 1,600 added in a single week. It is becoming the de facto reference point for the Agent frontend layer. Not because it's the most complete, but because it turns how frontends connect to Agents from each team inventing its own solution into a comparable contract.
2.4 What It Doesn't Solve
AG-UI defines only how events flow, not what the UI looks like. Clients still render, manage state, and decide when to interrupt. The event stream is a transport layer, not a component library or design system. If you treat AG-UI as an Agent frontend framework, you'll be disappointed; treat it as an HTTP contract between frontend and Agent, and it fits just right.
3. Chrome DevTools MCP: Wiring Runtime Feedback into the Coding Loop
3.1 From Reading Static Code to Watching a Live Browser
An Agent can write code, but that doesn't mean it knows what the code looks like when running. Chrome DevTools MCP wraps Chrome DevTools Protocol capabilities as MCP tools, letting a coding Agent directly control and inspect a running Chrome:
| Capability | Typical tools | Use |
|---|---|---|
| Page navigation | navigate_page |
Open local pages, route navigation |
| Element interaction | click, fill |
Click buttons, fill forms |
| Page snapshot | take_snapshot |
Read accessibility tree, locate elements |
| Console | list_console_messages |
See errors, warnings, logs |
| Network | list_network_requests |
Check failed/slow requests |
| Performance | performance_start_trace / performance_stop_trace |
Record and analyze runtime performance |
| Audit | lighthouse_audit |
Run Lighthouse |
Tool names are per the current version; the table illustrates capability boundaries.
3.2 Difference from Playwright: Debugging vs Testing
Playwright is for running a script to verify a flow: open page, click button, assert result, exit. Chrome DevTools MCP is for the Agent after making code changes: open the browser, see actual rendering, read Console errors, locate the issue, then go back and fix. This is a completely different loop. Without this layer, an Agent can only read static code, like a person editing UI with eyes closed; with it, the Agent can at least see what it changed. Antigravity 2.0 already bundles Chrome DevTools MCP into the product; developers can use it via the /browser command or a sub-agent.
3.3 A Minimal Configuration Example
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": ["-y", "chrome-devtools-mcp@latest"]
}
}
}
After configuration, the Agent sees a set of MCP tools. It issues a tools/call, the MCP server translates it into a CDP command, and returns the result.
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "navigate_page",
"arguments": { "url": "http://localhost:3000" }
}
}
3.4 Real Engineering Pain Points
Protocol design isn't the hardest part; real browser state plus long sessions is. GitHub issues contain user reports:
- In long-running coding Agent sessions, under
--autoConnectmode, the MCP-to-Chrome connection becomes unstable, and reconnects repeatedly trigger Chrome's remote debugging authorization prompt. - When using
--autoConnectthrough MCPProxy's stdio transport, after initialization succeeds, subsequent tool calls may hang until timeout.
This isn't something you can dismiss with 'the protocol is immature'. It's more like browser automation's long-standing problems amplified by long Agent sessions: page state changes, connections drop, authorizations expire, processes hang. From another angle, the fact that these issues are publicly discussed, tracked, and fixed is itself a sign that protocol layer projects are maturing. On GitHub Trending, November 18, 2026, Chrome DevTools MCP gained 717 stars in a single day; reports put its star count at 39K+.
3.5 It Fills the Runtime Feedback Gap
The ideal Agent coding loop looks like this:
read code -> change code -> run -> see rendering/Console/network -> locate -> change again
Most Agents only do the first two steps. Chrome DevTools MCP fills in the last three. That's also what makes it more valuable than yet another code search tool: it lets an Agent take responsibility for the running page, not for code that merely looks correct.
4. stitch-skills: The Skills Layer, Turning How-To into Portable Assets
4.1 It's Not a Code Generator
stitch-skills is an open-source Agent Skills library from Google Labs, following the Agent Skills open standard and used with the Stitch MCP server. It works with Codex, Antigravity, Gemini CLI, Claude Code, Cursor, and OpenCode. It's not a code generator; it's a set of skill files describing design constraints: how to use design tokens, how component specs should be implemented, how prompts can be improved, and how design systems can be auto-generated. More precisely, it extracts doing good UI from the Agent's implicit abilities and turns it into an explicit, installable, versionable, cross-Agent portable skill. After installation, the UI an Agent produces isn't just works; it fits an existing design system.
4.2 What a Skill Package Looks Like
Below is an illustrative structure, not the actual stitch-skills repository:
design-review/
├── SKILL.md
├── references/
│ ├── tokens.md
│ └── components.md
└── scripts/
└── check-contrast.ts
SKILL.md describes when to use, what steps to follow, and what to output:
---
name: design-review
description: Review a page against the team design system, output token and component deviations
---
1. Read design/tokens.json and component list
2. Check whether colors, spacing, and font sizes hit tokens
3. Check interaction, focus, and disabled states
4. Output an issue list, ranked P0/P1/P2
The point isn't the file format; it's that capability becomes explicit. These rules used to live scattered across chat logs, oral tradition, and one person's muscle memory; now they're a folder that can be installed, versioned, and read by different Agents.
4.3 Cross-Agent Portable, but the Pipeline Still Has Seams
Cross-Agent portability is stitch-skills' most critical aspect, and it's also where the protocol layer's current state is most honestly exposed. A DEV Community analysis notes stitch-skills has about 8.7K stars and shows real cross-Agent portability, but the pipeline itself still has seams. These seams are concrete: OpenCode requires manually copying the skill folder and enforces kebab-case naming. The standard's last mile isn't fully smoothed out. But the direction is clear: skills are starting to detach from specific products and become portable assets.
4.4 Protocols Move Data, Skills Move Judgment
This is why I think stitch-skills deserves its own section. MCP and AG-UI standardize how data flows: tool-call parameters, events, state. They don't care what design specs you follow or what your code review checklist is. Agent Skills standardize how judgment is applied: what qualifies, what to check first, when to stop. The former lets an Agent connect to systems; the latter lets an Agent work like a team. Only when both are solved can an Agent truly enter production workflows.
5. Composing the Three Layers: A Complete Agent Pipeline
Putting the four layers together, a fairly complete pipeline looks like this:
User
│
▼
AG-UI (event stream: text, tool status, state deltas)
│
▼
Agent Runtime (LangGraph / custom loop / other frameworks)
│ │
│ ├── MCP Client ──> MCP Server ──> browser / database / internal systems
│ │
│ └── Agent Skills ──> design specs / review checklists / domain knowledge
│
▼
A2A (optional: sub-task delegation to other Agents)
Mapping to responsibilities:
| Layer | Standard/Component | Problem it solves | Typical failure mode |
|---|---|---|---|
| Interaction | AG-UI | Process visible to user, interruptible, resumable | Each frontend writes its own adapter, states don't match |
| Tool | MCP | Agent can call real systems | Tools locked into a product's plugin |
| Collaboration | A2A | Multi-Agent division of labor | Custom RPC, can't work across vendors |
| Capability | Agent Skills | Team norms are portable | Rewrite prompts when switching tools |
The key to this combination is not adopting everything, but letting each layer do only its own job. AG-UI shouldn't handle tool calls, MCP shouldn't render UI, Agent Skills shouldn't transport state. Mixing layers makes the system look feature-rich but leaves every layer non-replaceable.
6. Engineering Practice: Three Pitfalls, Three Recommendations
6.1 Three Pitfalls
| Pitfall | Symptom | Mitigation |
|---|---|---|
| Long-session connection instability | Browser MCP repeatedly prompts for auth, tool calls hang | Add timeouts, reconnect, health checks; make critical steps idempotent |
| Event stream state desync | Frontend receives events but local state is corrupted | Trust server-side STATE_SNAPSHOT; treat deltas as optimizations |
| Skills portability becomes copy-paste | Switching Agents requires manually moving folders | Fix directory conventions, version numbers, install scripts |
The first pitfall is already documented in Chrome DevTools MCP issues: real browser plus long session, the complexity is not in the protocol but in state. The second pitfall is easy to overlook in AG-UI integrations: an event stream isn't just message push; it contains state changes. Clients must handle snapshot plus delta, or state will diverge after reconnects. The third pitfall is the current state of skill libraries like stitch-skills: the cross-Agent direction is right, but the grunt work of installation, naming, and versioning isn't fully standardized.
6.2 Three Recommendations
First, package internal capabilities as MCP servers instead of hardcoding them in scripts. A bit of encapsulation cost today saves a rewrite when you switch tools tomorrow. MCP's value isn't one more protocol; it decouples capabilities from being a plugin of one product.
Second, when hooking a frontend to an Agent, prefer an event stream over hardcoding adapters for a particular model. Today you're integrating LangGraph, tomorrow it might be another framework; the event stream contract outlives any framework's lifecycle. When choosing, ask: can it express tool state, text deltas, state changes, and interruption recovery?
Third, encode team norms as Agent Skills instead of leaving them scattered in chat logs. Design tokens, component constraints, code style, review checklists; the earlier this how-to knowledge is made explicit, the easier it is for different Agents to reuse.
7. How to Evaluate an AI Coding Tool
Going forward, start evaluating an AI coding tool against this table:
| Dimension | Question to ask | Why it matters |
|---|---|---|
| Tool integration | Can it connect to my existing MCP servers? | Determines whether it can use your real systems |
| Interaction integration | Can it push state to my existing frontend via AG-UI? | Determines whether it can embed in your product |
| Skill portability | Can it load Agent Skills standard skills? | Determines whether your team norms carry over |
| Runtime feedback | Can it see browser, console, network, performance? | Determines whether it can locate problems itself |
| Observability | Are events, tool calls, errors traceable? | Determines whether you can debug when things go wrong |
| Replaceability | Does the protocol layer still hold if you change models/frameworks? | Determines whether your investment is locked in |
Which models are supported is still important, but it's no longer the first question. Models set the ceiling; protocols determine whether a tool can enter your workflow.
8. Cheat Sheet
| Project | Positioning | Layer it solves | Key data/features |
|---|---|---|---|
| MCP | Tool-calling standard | Tool | 10K+ active public servers, 97M+ monthly SDK downloads |
| A2A | Agent collaboration standard | Collaboration | Multi-Agent division of labor, cross-vendor |
| AG-UI | Agent-UI event stream | Interaction | ~27 event types, 1.0 spec frozen, TS/Python/.NET SDKs |
| Chrome DevTools MCP | Browser runtime MCP | Tool (runtime) | Wraps CDP, debugging-oriented, reported 39K+ stars |
| stitch-skills | Agent skill library | Capability | Design tokens/component specs, 8.7K stars, cross-Agent portable |
Finally, to sum up:
The protocol layer won't write good code by itself, but it's making the way good code is produced no longer locked into any single product.
It sounds abstract, but it's very concrete in engineering: the MCP server you package today, the event contract you define, and the skill files you write will save you one rewrite the next time you switch tools.
References (in order of appearance)
- Linux Foundation Agentic AI Foundation announcements
- AG-UI official docs and GitHub repo
- Chrome DevTools MCP official docs and GitHub issues
- stitch-skills official repo and DEV Community analysis
- Public MCP ecosystem data (as of Nov 2026)
All numbers in this article come from public sources; code blocks are illustrative, and actual fields and tool names follow the current documentation of each project.
Top 1 of 2 from juejin.cn, machine-translated. The original thread is authoritative.
Juejin doesn't even have an article reward mechanism anymore, it's all this AI-flavored content, sigh (ε=(´ο`*)))唉)
You're really an AI [smug]