跪拜 Guibai
← Back to the summary

Protocols, Not Models, Will Decide Which AI Coding Tools Win

The Next War in AI Programming Is Over Protocols, Not Models

cover-ai-protocol-stack-juejin.jpg

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:

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:

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)

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.

Comments

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]