跪拜 Guibai
← Back to the summary

Harness Over Model: How AI Agents Evolved From Chat to Work in Five Stages

From “Being Able to Chat” to “Getting Work Done”: The Five-Level Evolution of AI Agents, Core Concept Anatomy, and Industry Landscape

By 西安小哥 (Xi’an Xiao Ge)

Preface: A Judgment Up Front

The most noteworthy thing in 2026 is not that a few more powerful models appeared, but that the main battleground of industry competition has shifted.

OpenAI’s open-sourcing of Codex’s Rust execution engine (harness) on August 20, 2026 offers the most persuasive data: purely through harness-level optimization, GPT-5.6 Sol’s score on ARC-AGI-3 rose from 13.3% to 38.3%, while token consumption dropped to one-sixth. The model did not improve by a single point; agent capability tripled.

This is not marketing talk. It reveals the core structure of agent evolution in 2026:

         Model (brain)  ×  Harness (body)  ×  Ecosystem connections (hands and senses)  =  Agent

Model capability sets the ceiling, the harness determines the actual realization ratio, and the ecosystem determines how much of the real world it can touch. The three multiply together; if any one term is zero, the result is zero.

Over the past two years, market narrative concentrated almost entirely on the first term: parameters, leaderboards, prices. What actually separates competitors in 2026 is the second and third terms.

This article proceeds along four lines:

  1. Evolution line: the five stages of agent development, and the artifacts and scenarios of each stage;
  2. Concept line: agent, loop, harness, MCP, skill — how to distinguish them, and what each era’s artifact is;
  3. Industry line: AI’s impact on traditional industries; a comparison of five tools: Codex / WorkBuddy / TRAE / DeepSeek Harness / Doubao; the strengths, weaknesses, and bottlenecks of eight models;
  4. Trend line: six directions worth betting on in the next two to three years.

Chapter 1: The Five Stages of Evolution

1.0 Overview

Stage Time Core proposition Landmark artifacts Main battlefield
① Componentization 2020–2022 Break a single Q&A into reusable parts Prompt templates, ReAct, Function Calling Content generation, customer service Q&A
② Engineering 2022–2023 Assemble parts into deployable systems LangChain, vector databases, LangGraph, RAG architectures Enterprise knowledge bases, retrieval Q&A
③ Code programming assistants 2023–2024 Give LLMs their first “hands” GitHub Copilot, Cursor, Continue Completion, explanation, single-file refactoring
④ Conversational agents 2024–2025 From “completing one line” to “completing a sequence” Claude Code, Devin, Manus, Computer Use End-to-end tasks, web operations, deep research
⑤ AI agents 2025–2026 Harness becomes a first-class citizen; agents can be deployed and traded Codex harness, DeepSeek Harness, Agent Skills, Agent Plugins, MCP 2026-07-28 Digital employees, always-on agents, industry agent platforms

1.1 Stage One: Componentization (2020–2022)

Background. LLM APIs had just opened up, and people discovered that the same model performed wildly differently under different prompt wrappings. So the first wave of engineering effort was not “making the model smarter” but making the act of calling the model controllable and reusable.

Forms.

Artifacts.

Scenarios.

What this step actually solved: turning the LLM from a “toy” into a “predictable interface.” It did not solve “how long a task runs” — all interactions remained in single-turn or manually orchestrated fixed pipelines.

Legacy problems (which determined the arrival of Stage Two): componentization is “semi-automatic.” Each additional link in the chain adds error; developers are forced to hand-write orchestration logic, and once the flow grows complex it becomes unmaintainable.

1.2 Stage Two: Engineering (2022–2023)

Background. Manual orchestration of components hit a wall. What enterprises needed was not “parts that can call APIs” but “systems that don’t crash after launch and that someone can maintain.”

Forms.

Artifacts.

Scenarios.

What this step actually solved: turning “effectiveness” from superstition into an engineering problem that is measurable, regression-testable, and deployable. This is the watershed where agents went from “demo” to “production.”

Legacy problems: systems were still passive. The user asks, it answers. Complex work spanning multiple systems and requiring repeated trial and error was beyond it. RAG can look things up, but after looking it cannot act.

1.3 Stage Three: Code Programming Assistants (2023–2024)

Background. After ChatGPT, the biggest demand explosion across the industry was writing code. And code has a natural advantage no other domain has: there are compilers, tests, and Git — objective feedback signals. This gave LLMs their first closed loop of self-verification.

Forms.

Artifacts.

Scenarios.

What this step actually solved: proving that LLMs can iterate autonomously in domains with validators. This was the first successful landing of agent thinking — “write code → run tests → see errors → fix code” is the most basic loop.

Legacy problems: still a “human-in-the-loop” assistant. Humans must watch it fix every file correctly; a task spanning 20 files means the human follows along 20 times. The human is the bottleneck in the loop.

1.4 Stage Four: Conversational Agents (2024–2025)

Background. From late 2024 to early 2025, Claude Code, Devin, Manus, and OpenAI’s Computer Use appeared almost simultaneously. Together they marked a paradigm shift: agents moved from the “editor box” into the “terminal / desktop / browser.”

Claude Code (early 2025) delivered the biggest cognitive shock: a CLI in the terminal that could read a repository, modify files, run tests, and submit PRs on its own. Manus (March 2025) proved another form — cloud sandbox + browser operations + deliverable output, where users don’t even need to watch the process, only the result.

Forms.

Artifacts.

Scenarios.

What this step actually solved: agents finally had their own work surface (terminal / browser / desktop) and their own feedback loop (execution results fed back in).

Legacy problems:

  1. Every product was a closed black box — how the loop ran, how context was compacted, how sandboxes started: invisible from outside and unmodifiable;
  2. Capabilities could not be reused or traded — your good prompts and flows were locked inside one client;
  3. Costs were uncontrollable — long contexts drove token costs up exponentially; in DeepSeek Harness testing, a trivial “reply PONG” task burned about 13,467 input tokens on the first request, because system prompts, tool schemas, repository rules, and skill summaries all hitched a ride.

These three legacy problems defined Stage Five.

1.5 Stage Five: AI Agents (2025–2026)

Background. From late 2025 through 2026, the industry’s center of gravity shifted from “building a better agent” to “building an agent runtime environment that everyone can modify, reuse, and trade.”

Three things happened simultaneously.

First, the harness was pulled out as an independent product.

Second, protocol and packaging standards landed.

Third, agents went from “software” to “tradable units of productivity.”

Artifact list.

Scenarios.

What this step actually solved: agent capabilities were broken into composable, tradable, auditable parts. You no longer build an Agent from scratch — you buy a harness, skills, and connectors from the market and install them into your own business scenario.

New problems: assembly quality sets the ceiling. In August 2026, AWS, Cloudflare, Microsoft Foundry, Manufact, and Google Cloud voiced support for the new MCP spec with strikingly consistent reasoning — “the stateless core lets us scale from dozens of integrations to thousands without maintaining a pile of session-state glue.” The ecosystem’s next battleground is “how to stay reliable while remaining composable.”

1.6 A One-Sentence Summary of the Five-Stage Progression

Componentization: making calls controllable
   ↓
Engineering: making systems deployable
   ↓
Programming assistants: giving models hands (with validators)
   ↓
Conversational agents: giving agents their own work surface and loop
   ↓
AI agents: making the agent itself a disassemblable, reusable, tradable commodity

One main thread runs throughout: each leap moves the “human” one slot further back in the loop. In the completion era, humans write code; in the assistant era, humans approve diffs; in the conversational-agent era, humans define goals and acceptance criteria; in the agent era, humans define business boundaries, compliance red lines, and “what counts as done.”

Chapter 2: Five Core Concepts: Agent, Loop, Harness, MCP, Skill

This chapter is the foundation of the entire article. These five words are the most abused by the industry, but they actually sit at completely different layers.

2.0 A Layered Diagram

┌──────────────────────────────────────────────────────────┐
│  Layer 5  Scenarios / Deliverables                       │
│  Industry agents, digital employees, always-on agents,   │
│  research reports, code PRs                              │
├──────────────────────────────────────────────────────────┤
│  Layer 4  Skills / Plugins / Experts                     │
│  “by what method” — SKILL.md, plugin.json, expert packs  │
├──────────────────────────────────────────────────────────┤
│  Layer 3  Connections MCP / Connector                    │
│  “connected to where” — tools, resources, prompts,       │
│  async tasks                                             │
├──────────────────────────────────────────────────────────┤
│  Layer 2  Harness (runtime)                              │
│  “how it runs” — loop, tool dispatch, context management,│
│  sandbox, permissions, memory                            │
├──────────────────────────────────────────────────────────┤
│  Layer 1  Loop                                           │
│  “how it thinks” — perceive → reason → act → observe →   │
│  reflect → repeat                                        │
├──────────────────────────────────────────────────────────┤
│  Layer 0  Model                                          │
│  “what it can think of” — weights, reasoning, emergence  │
└──────────────────────────────────────────────────────────┘

One-sentence distinctions:

Concept One-sentence definition Key question
Agent A system that can act autonomously in an environment to achieve a goal What is it?
Loop The cycle in which an agent repeatedly “thinks—does—sees—rethinks” How does it operate?
Harness The runtime and engineering shell that carries the loop Who runs this loop?
MCP The standard interface protocol between agents and external systems What can it touch?
Skill An on-demand operation manual and method package By what method does it work?

A memory anchor: the model is the brain, the harness is the body, MCP is the nervous system, the skill is the instruction manual, and the loop is the instinctive reflex. The agent is the person who can work, made up of all five.

2.1 What Is an Agent

Definition

An agent is a software system with goal-driven capability that can autonomously select and call tools, adjust strategy based on execution feedback, and keep advancing in its environment until it achieves its goal.

Broken into six necessary elements, none of which can be missing:

Element Description Consequence of absence
Goal Clear task and completion criteria No direction
Reasoner The core handling reasoning and decisions Cannot handle surprises
Tools Read/write files, run commands, call APIs, access databases Can only “talk,” not “do”
Memory Conversation history + long-term memory + workspace state Amnesia every round
Loop Perceive → reason → act → observe → reflect One-shot output
Guardrails Permissions, sandbox, approvals, cost limits Uncontrollable, unusable

Agents vs. Four Things That “Look Like Agents”

  1. Not an agent: a one-off LLM call. No tools, no loop, no state.
  2. Not an agent: a fixed pipeline. Steps are hard-coded; it stops when it hits an unknown branch. Most Stage-2 RAG applications fall into this category.
  3. Not an agent: pure tool calling. The model only decides which function to call, with arguments fully supplied by the user. Function calling ≠ agent.
  4. Is an agent (weak form): has a loop but limited capability — e.g., can answer questions but cannot execute.
  5. Is an agent (strong form): goal + autonomous tool selection + feedback adaptation + sustained progress.

Criteria

Ask three questions; only “yes” to all three makes it an agent:

Era artifacts

2.2 What Is a Loop

Definition

A loop is the agent’s minimal unit of autonomy: a closed cycle of “perceive environment → generate decision → execute action → observe result → update state → return to perceiving.”

        ┌─────────────────────────────────────┐
        │                                     │
        ▼                                     │
   [Perceive]  environment state / tool returns / user input
        │
        ▼
   [Reason]    model generates “what to do next”
        │
        ▼
   [Act]       call tool / write file / run command
        │
        ▼
   [Observe]   read back execution result, judge success/failure
        │
        ▼
   [Reflect]   revise plan / write to memory / decide whether to continue
        │
        └─────────────────────────────────────┘
                    (continue looping until completion condition met)

The Key Is the “Closed Loop,” Not the Model

A model’s output quality is open-loop: it gives an answer and ends. A loop turns that answer into a verifiable hypothesis, corrected by environmental feedback.

This is why code was the earliest agent battleground — tests provide a natural verifier. In domains without a verifier, the loop degrades into “repeated blind guessing.”

Loop Engineering Difficulties (also the value of the harness)

Difficulty Naive solution Engineering solution
Context explosion Stuff everything into the prompt Context compaction: automatic summarization, pruning, segmented archiving
Repetitive work Re-read files every round Tool search + caching + state reuse
Going off track Run to the end no matter what Plan confirmation, checkpoints, loop caps, budget circuit breakers
Error accumulation Continue silently Structured error feedback, reflection prompts, self-repair
Not observable Print logs Trajectory: append-only full session traces, replayable, forkable, searchable
Not parallelizable Serial execution Subagent delegation + worktree isolation + concurrent scheduling

Era artifacts

2.3 What Is a Harness (Runtime / Skeleton)

Definition

A harness is “everything except the model itself that is needed to turn a language model into a working agent.”

If the model is the brain, the harness is: the spinal cord, nerves, muscles, work clothes, tool belt, safety rope, recorder, and operation manual.

The saying circulating in the Anthropic community, “Model + Harness = Agent,” and DeepSeek’s official “the model is the brain, the Harness does everything else,” both say the same thing.

The Nine Components of a Harness

# Component Problem it solves Without it
1 System prompt assembly Combines identity, rules, repository conventions, user preferences into one request Explaining who you are from scratch every time
2 Tool registration and dispatch Tool schema loading, selection, argument validation The model “wants to call” but cannot reach
3 Context management Compression, summarization, segmentation, externalization Token costs rise exponentially; attention diluted
4 Sandbox and execution environment Isolates file writes, command execution, network access One mistake destroys the workspace
5 Permissions and approvals Which operations auto-pass, which require human confirmation Either afraid to use it, or afraid to grant it permissions
6 Memory Session state, long-term preferences, project knowledge Re-introducing yourself every round
7 Task planning and delegation Decomposition, dispatch to subagents, aggregation Complex tasks stuck on a single thread
8 Trajectory and observability Recording, retrieval, replay, forking Errors cannot be attributed; processes cannot be audited
9 Cost and budget control Token budgets, rate limits, loop caps One task burns a month’s quota

The Key 2026 Realization: Harness Design Affects Results More Than Model Upgrades

This is the most important engineering turn of this cycle, backed by hard data:

The Separation of Harness and Compute

The most important architectural convergence of 2026: harness (trusted side) handles the reasoning loop, tool dispatch, and memory; compute (untrusted side) handles actual execution.

Direct benefits:

Era artifacts

Time Artifact
2024 LangChain / LangGraph (engineering prototypes)
2025 Claude Code, Cursor Agent, Windsurf (productized harnesses)
2026-04 OpenAI Agents SDK + model-native harness + Manifest + 7 sandbox providers
2026-08-13 DeepSeek Harness (dsh), MIT, Cordis “everything is a plugin,” 49 packages / 100+ plugins / 4 presets / Trajectory
2026-08-20 OpenAI Codex harness, Rust, Apache-2.0 open source, codex exec + SDK + app-server trio
2026 WorkBuddy (Expert / Skill / Connector + Ask/Plan/Craft three modes)

2.4 What Is MCP (Model Context Protocol)

Definition

MCP is the open standard protocol for communication between agents and external systems. Anthropic’s official analogy is “the USB-C port of AI applications”: previously every AI application needed a custom integration for every data source; MCP makes it plug-and-play.

The protocol is based on JSON-RPC 2.0, with a three-layer architecture:

Host (e.g., Claude Code / Codex / WorkBuddy)
  └─ Client (client connector) ── connects via stdio or Streamable HTTP ── Server

Four Directions of Capability

Server → Client (what the server provides):

Client → Server (what the client can demand):

Four Key Changes in the 2026-07-28 Specification

  1. Stateless core — the biggest and hardest change. The base protocol becomes stateless, self-contained requests; each request independently completes capability negotiation. The motivation is extremely pragmatic: Microsoft Foundry, precisely because of this, scaled from “dozens of integrations” to “thousands of integrations” with a single toolbox endpoint; Manufact says removing session state ended the extensive infrastructure workarounds built to handle production traffic; AWS put Tasks into Amazon Bedrock AgentCore to run long-lived agent work without managing sessions; Cloudflare’s Agents SDK supported the spec from day one, letting servers run in Workers without transport-layer session overhead.
  2. Tasks extension — asynchronous execution of long-running operations, supporting polling, in-flight input, and persistent handles.
  3. Skills over MCP — structured workflow instructions discovered and consumed via MCP, letting “skills” be reused across transport layers.
  4. MCP Apps — inline rendering of interactive UIs in conversation (charts, forms, video players).

Security Principles (not enforceable at the protocol layer, but implementers SHOULD follow)

Ecosystem Scale

Era artifacts

2.5 What Is a Skill

Definition

A skill is “an operation manual + scripts + resource package that an agent reads on demand,” telling it “how this kind of task should be done.”

It is not code, not a plugin, not a protocol — it is knowledge. In format it is a folder, with SKILL.md at its core:

my-skill/
├── SKILL.md          # required: YAML frontmatter + body
├── scripts/          # optional: executable scripts
├── references/       # optional: reference documents
└── assets/           # optional: templates, materials

Required frontmatter fields:

Optional fields include license, compatibility, metadata, and an experimental allowed-tools.

Progressive Disclosure — the key design that saves tokens in skills

Stage Content loaded Cost scale
At startup Only each skill’s name + description about 100 tokens / entry
On task match Full SKILL.md body pulled in on demand
When work requires Only then read files under scripts/, references/ on demand

This explains why skills do not crush the context in long sessions: 50 resident skills cost only about 5,000 tokens; bodies enter the window only when actually needed.

The Division of Labor Between Skills and MCP (the most confusing point)

This was the most debated question in the developer community in 2026 (“MCP vs Skills” became a real search term), and the 2026-07-28 spec’s answer is: they are not on the same layer, and they do not compete.

Agent Skills MCP
What it defines The format of an instruction folder The protocol between an agent and a running server
Distribution unit A skill directory A server process or HTTP endpoint
Where it runs On disk, loaded by the client Via stdio subprocess or Streamable HTTP
Core question “which skill to use, when, how” “which tool to call, when”
Cost profile Only context cost, no invocation latency Tool schemas occupy context at connection time; every call crosses process/network
Portability Very high: any client with filesystem + shell + network can use it Medium: requires transport, auth, config files
Determinism Instructive — the model interprets it Deterministic — same input runs the same code path

A formulation from LlamaIndex fits best: “for an agent, the challenge with MCP tools is only deciding which to call and when; the challenge with skills is deciding which skill to use, when, and how.”

Two frequently cited practical recommendations:

Another repeatedly raised practical issue: tool schemas are “loaded at connection time.” The official GitHub MCP server is widely noted to “consume tens of thousands of tokens of context on its own.” So skills can subtract on the server side, while MCP servers are the main source of context cost.

Skills over MCP and Agent Plugins: How the Three Layers Combine

The final 2026 landscape is three-layer collaboration:

Agent Plugins 1.0.0          ← packaging and distribution (plugin.json + skills/ + mcp.json)
      ├── Agent Skills        ← instruction manual (teaches the agent how)
      └── MCP Server          ← connector (gives the agent actual capability)

One directory carries both the “how-to manual” and the “where it connects,” and a single install completes everything. This is the fastest-growing but still smallest form.

Note the history of the two standards: Claude Code Plugins were released a week before Skills (2025-10-09 vs 10-16) and are host-specific; Agent Skills is a cross-host standard (46 products support it). For portability, publish a Skill; for team standardization, package it as a Plugin.

Era artifacts

2.6 How the Five Concepts Relate: A Concrete Example

Suppose the task is “analyze this quarter’s sales data and produce a PPT with charts”:

Layer Who is at work Concrete action
Model Qwen / Claude / GPT Understands the requirement, generates analysis logic and PPT outline
Loop the loop inside the harness read Excel → write Python analysis → run charts → check whether the chart matches the description → fix if not → run again
Harness Codex / WorkBuddy / DeepSeek Harness sandboxed Python execution, caching intermediate results, context compaction, approving file-write actions, recording trajectories
MCP filesystem server + database server lets it actually read the t_sales table and local xlsx
Skill ppt-generation/SKILL.md tells it “where the company PPT template lives, title font sizes, color spec, chart type preferences”
Agent all of them together returns a directly usable PPT file

What happens if you remove any layer: remove the Skill and the PPT won’t match your spec; remove MCP and it can’t read the data; remove the harness’s sandbox and it might break your environment; remove the loop and it computes once then stops; remove the model and it can’t reason at all.

Chapter 3: AI’s Evolving Impact on Traditional Industries

3.1 A Main Judgment

The judgment of Wang Yingbo, a digital economy scholar at the Shanghai Academy of Social Sciences, is worth using as the epigraph for this section: “In the past, AI office work was more of a Copilot model ‘helping you write’; now Agents pursue ‘doing it all for you’... office software is transforming from tools operated by people into executive subjects that actively do work, with the value center shifting from individual point-efficiency to team collaborative efficiency. Traditional office software retreats to the background, reduced to capability modules called by AI.”

This sentence condenses the same thing happening across all industries: software’s role changes from “being operated” to “being called.”

3.2 Five Structural Changes Underway

Change One: Demand-Side Textualization, Deliverable Definition

In the past, delivering a report meant the requester described “what I want it to look like”; now the requester describes “what the acceptance criteria are.”

Change Two: Software Retreats to the Background, Capabilities Become API-ified

Change Three: Individual Job Positions Are Broken Into “Tasks,” and Tasks Are Reassigned to Agents

A typical case: in a software company, the small-requirements pipeline of “PM defines requirements → architect designs and decomposes tasks → engineers implement in bulk → QA verifies” can now be completed internally by multiple expert agents.

Change Four: Data Goes From “Asset” to “Fuel,” and Consumption Explodes

Huatai Securities’ research report judgment: the core increment from Agent penetration is not the number of user requests itself, but the combined growth of per-task token consumption, tool call counts, and parallel execution width.

Change Five: Enterprise Procurement and Compliance Become First-Class Constraints

3.3 Industry Impact at a Glance

Industry Concrete form of agent penetration Representative cases Key constraints
Software development End-to-end feature development, PR review, migration refactoring Codex harness (Cisco / Thrive / Crete in production), Claude Code Code ownership and liability
Enterprise office Digital employees, cross-app operations WorkBuddy, Coze, HiAgent 3.0 (17.8% share), Doubao Work Permission boundaries, audit
Finance Intelligent advisory, tax processing, risk control CICC advisory Agent; Codex harness processing 7,000 tax returns Regulation, audit trails
Manufacturing/energy Quality inspection, scheduling, safety watch PetroChina AI safety watch (10x efficiency) OT security, real-time
Healthcare/law/education Vertical agent workbenches WorkBuddy open platform covering 20+ domains Professional liability, hallucination
Content and creative Integrated audio-visual generation, brand content Seedance 2.0 / 2.5, Seedream 5.0, Kimi document generation Copyright (US film companies have sued over Hailuo AI)
Government/public welfare Scenario capsules + multi-agent “Public Welfare Buddy”: 11 scenario capsules, 42 scenario capabilities, 15 collaborating agents Authenticity, privacy
Education Feynman-method evaluation tools, personalized tutoring Qianwen Office, WorkBuddy education edition Minor protection
Hardware/endpoints Glasses/watches as perception entry points WorkBuddy smart glasses form factor Edge compute, battery life

3.4 Three Practical Impacts on Organizations

  1. “Asking well” becomes a core professional skill. Context engineering, task decomposition, and acceptance-criteria writing — these three things in 2026 are already worth more than “being good at writing prompts.”
  2. Process before tools. Standardize business processes before introducing agents; the payoff is far greater than adopting tools directly. This is an old lesson validated since the Stage-2 RAG era, amplified in the agent era.
  3. Human roles move up: from executors to responsibility bearers. Agents can write code, but humans sign; agents can produce reports, but the right to interpret conclusions belongs to humans. Responsibility cannot be automated; this is the hard constraint on organizational design in the agent era.

Chapter 4: Five Agent Tools Compared: Codex / WorkBuddy / TRAE / DeepSeek Harness / Doubao

4.0 Overview Table

Codex WorkBuddy TRAE DeepSeek Harness Doubao
Vendor OpenAI Tencent ByteDance DeepSeek ByteDance
Form CLI / IDE extension / desktop / Cloud Desktop + Web + IM + mini-program IDE + SOLO + TRAE Work Desktop app + Web UI C-end App + Volcano Engine MaaS
Core positioning General software engineering agent All-scenario AI workbench AI IDE / intelligent work assistant Open-source agent runtime All-modal consumer assistant + enterprise API
Pricing Included in ChatGPT subscription (Free→Enterprise) Subscription + open-platform revenue share Free / $3 / $10 / $30 / $100 Free open source, model billed per token Subscription + token billing (low price)
Openness Harness open-sourced (Rust, Apache-2.0) Skill / Expert / Connector three-layer open MCP access + custom agent marketplace Fully open source (MIT), everything is a plugin Plugin ecosystem + Coze platform
Strongest Code depth, PR review, cloud async Multi-expert collaboration, cross-device, full office scenarios Chinese-language context, frontend generation, cost Controllability, reproducibility, cost All-modal real-time interaction, C-end experience
Weakest Heavily dependent on OpenAI ecosystem and account Steep learning curve, high token consumption Telemetry and data governance need evaluation Young ecosystem, you fill the potholes yourself Weak on hardcore research and very long documents

4.1 Codex (OpenAI)

What it is. The Codex of today is no longer the completion model of 2021, but a complete product suite: Codex CLI (terminal), IDE extension (VS Code family), desktop app (macOS/Windows), Codex Cloud (async agents in managed sandboxes), and the Codex entry point in the ChatGPT web version. All share the same ChatGPT account and the same agent loop — a task started in the editor can continue in the terminal or be tossed to the cloud.

Key 2026 actions:

Strengths

Bottlenecks

Best fit

Not suited for: compliance environments fully isolated from the OpenAI ecosystem; purely low-cost routine small edits.

4.2 WorkBuddy (Tencent)

What it is. An all-scenario AI workbench: “one person directs, all-industry experts execute.” 100+ domain experts form a virtual team, with multi-expert parallel collaboration covering the full pipeline from strategy to deliverables; supports desktop / mainstream IM / mini-program across endpoints.

Three-layer open capabilities (the key to understanding WorkBuddy):

Layer What problem it solves What it is
Expert who does it Vertical agents tuned with roles and methodologies, divided into Agent-type and Team-type (the latter with multiple experts collaborating on long-chain tasks)
Skill by what method Reusable method or tool packages, encapsulating scripts and workflows; Wind opened 1600+ Skills
Connector connected to where Supports both MCP and CLI, can connect Tencent Docs, Tencent Meeting, QQ Mail, WeCom, Feishu, DingTalk, Tianyancha, Ctrip, Baidu Netdisk, etc.

Three working modes (permissions from low to high): Ask (read-only, pure Q&A) → Plan (read-only, produces a plan) → Craft (writable, executable).

Open platform (launched 2026-09): first batch of 100+ partners, covering 20+ domains including finance, SaaS, law, healthcare, education, public welfare, and design; the Expert marketplace covers Agent-type and Team-type; Connector supports MCP and CLI; the “Buddy App” entry lets partners build branded industry AI workbenches (e.g., “Public Welfare Buddy”: 11 scenario capsules, 42 scenario capabilities, 15 collaborating agents).

Strengths

Bottlenecks

Best fit

Not suited for: single-person minimal Q&A; workloads sensitive to data cross-border where compliance boundaries cannot be configured.

4.3 TRAE (ByteDance)

What it is. A VS Code-based AI IDE with dual development modes: IDE mode preserves the original workflow with stronger control; SOLO mode lets AI lead the task and advance automatically. 2026 added TRAE Work (desktop / web / mobile) as an intelligent work assistant.

Token billing revision effective 2026-02-24:

Tier Monthly fee Base usage Concurrent cloud tasks SOLO Early models
Free $0 5,000 completions + limited 2 limited —
Lite $3 $5 + rewards 2 limited —
Pro $10 $20 + rewards 10 included —
Pro+ $30 $90 + rewards 15 included —
Ultra $100 $400 + rewards 20 included yes

Context: regular mode up to 272K, Max mode up to 1M (depending on model); up to 200 tool calls per session; context management and compression summaries enabled in all modes. Pro users with Gemini-3-Pro (200K context) get roughly 3x the SOLO-mode conversation count compared to before the revision.

Strengths

Bottlenecks

Best fit

Not suited for: enterprise repositories with hard data-residency requirements; hyper-scale concurrent usage needing predictable monthly bills.

4.4 DeepSeek Harness

What it is. A developer preview released on the same day as the official DeepSeek-V4-Pro-0813 (2026-08-13), open source under MIT, positioned against Codex and Claude Code, targeting programming and office scenarios. GitHub stars passed 50,000 within 12 hours; media called it “one of the fastest-growing projects in history.”

Design philosophy: everything is a plugin. Based on the Cordis framework from the paper “A Programming Paradigm for Spatiotemporal Composability” (a collaboration between Peking University and DeepSeek) — a small kernel responsible for loading/unloading plugins and managing inter-plugin dependencies; every registration is a rollback-able effect. Model adapters, tool registries, agent loops, session storage, sandboxes, scheduling, even the Web UI — all are plugins. Developers can independently select, replace, or extend any capability without touching the main code. 49 packages (core / llm / mcp / sandbox / context / plan / goal, etc.), 100+ first-party plugins.

Four presets:

Preset What it loads Best for
Standard Full coding agent: file editing, shell, retrieval, skills, planning, goals, subagents, workflows Daily driver
Code (PTC) Standard + Code Mode SDK; model can write TypeScript programs chaining multi-step tool calls Complex orchestration (watch for side effects and call multiplication)
Minimal Persistent bash + str_replace_editor Reproducing benchmarks (V4 Flash’s Terminal-Bench 2.1 = 82.7 was achieved in this mode)
Creator (cordis) Standard + runtime inspection, in-memory plugin experiments, preset authoring Writing and debugging plugins

Trajectory: append-only session logs, zstd-compressed JSONL, recording system prompts, reasoning, tool calls and results, and subagent scheduling; any run can be inspected, resumed, forked, searched, and replayed.

Strengths

Bottlenecks

Best fit

Not suited for: ordinary users wanting out-of-the-box experience and a mature third-party ecosystem; sensitive environments not intending to harden the default security boundary themselves.

4.5 Doubao (ByteDance)

What it is. A full-stack layout covering the C-end App + Volcano Engine MaaS + Coze + HiAgent. Doubao 2.1 / 2.0 runs the dual line of “multimodal agent model + all-modal creation model.”

Capability map (as of mid-2026):

Strengths

Bottlenecks

Best fit

Not suited for: tasks centered on deep analysis of ultra-long documents; private deployments demanding deep privatization and a fully open-source, prunable stack.

4.6 Selection Advice (by scenario)

Your situation First choice Reason
Complex software engineering + want to control the harness Codex Code capability in the first tier; harness open-sourced and forkable
Team multi-role collaboration, cross-system office WorkBuddy Expert/Skill/Connector three layers + multi-endpoint + multi-expert parallel
Chinese frontend development + budget sensitive TRAE Starts at $3; strong Chinese-language context and frontend generation
Self-built agent platform, need full control DeepSeek Harness MIT fully open source, everything is a plugin, auditable Trajectory
Voice/video/image creation + large-scale low-cost calls Doubao All-modal real-time leadership + costs an order of magnitude lower
Academic research and reproducible evaluation DeepSeek Harness Minimal preset + Trajectory replay

Chapter 5: Model Comparison: Strengths, Bottlenecks, and “Who Leads Where”

5.0 Panorama Overview

Model Version/time Context Input/output price One-line positioning
Claude Opus 5 2026-07-24 1M (output 128K) $5 / $25 Benchmark for deep reasoning and agentic coding
ChatGPT / GPT-6 2026-10-08 10M (API) $5 / $25 All-purpose platform, cross-week memory + native Codex
Grok 4.7 2026-09-21 500K — Real-time data + multi-agent + X ecosystem distribution
Qwen Qwen3-Max 2025-12-15 256K $0.50 / $5.00 Ceiling of the open-weight ecosystem
Hunyuan Hy3 2026-07-06 262K $0.14 / $0.58 Cost-performance + Apache 2.0 domestic flagship
DeepSeek V4-Pro / V4.1-Flash 2026-08 / October update long context peak-valley pricing Reasoning + cost + open harness in one
MiniMax M3 2026-06-01 1M (output 512K) $0.30 / $1.20 First “frontier coding + 1M + native multimodal” open-weight model
Kimi K3 2026-07-16 1M — World’s first open 3T-class model, long-horizon coding benchmark

5.1 Claude Opus (Anthropic) — The Benchmark for Depth and Long-Horizon Reasoning

Strengths

Bottlenecks

Best for: complex software engineering, high-risk production workloads, long-document analysis, long-form writing needing consistent style, multi-step tool pipelines needing autonomy.

5.2 ChatGPT / GPT-6 (OpenAI) — Platform Breadth First

Strengths

Bottlenecks

Best for: one-stop general workbench; research-grade deep retrieval; full-chain image + voice + code + Agent needs; team collaboration and custom GPT ecosystem.

5.3 Grok (xAI) — The Maverick of Real-Time and Distribution Channels

Current status (as of 2026-10-19): the latest available model is Grok 4.7 (2026-09-21), reading up to 500K tokens at once; Grok 4.8 is still training; Grok 5 is not released and has no official date (promises of end of 2025 → 2026 Q1 → both missed; Musk has said 4.8 / 4.9 come before 5, with an open window before end of 2026). On 2026-10-14 xAI released Grok Voice 3.0.

Strengths

Bottlenecks

Best for: real-time information retrieval and sentiment analysis, X-ecosystem content creation, in-car voice interaction, novelty-seeking tasks.

5.4 Qwen (Alibaba) — The Ceiling of the Open-Weight Ecosystem

Strengths

Bottlenecks

Best for: enterprises needing open-source self-hosting + privatization; multilingual overseas products; medium-complexity general agent workloads; cost-controllable scaled calls.

5.5 Hunyuan Hy3 (Tencent) — The Cost-Performance and Compliance Domestic Flagship

Strengths

Bottlenecks

Best for: cost-sensitive scaled agent workloads; procurement-safe paths for regulated Western enterprises; WeChat-ecosystem products; gaming/digital-human/financial-risk-control verticals.

5.6 DeepSeek — The Triangle of Reasoning, Cost, and Open Engineering

Strengths

Bottlenecks

Best for: self-built agent platforms; cost-sensitive scaled workloads; research and reproducible evaluation; organizations needing model-neutral architectures.

5.7 MiniMax M3 — The First Open-Weight Model with “Frontier Coding + 1M + Native Multimodal”

Strengths

Bottlenecks

Best for: agent workloads needing 1M context + open weights + cost control; long-document/long-audio-video content pipelines; privatization with data sovereignty requirements; voice and video creation workflows.

5.8 Kimi K3 (Moonshot AI) — The Scale and Long-Horizon Benchmark of Open Models

Strengths

Bottlenecks

Best for: ultra-long documents and ultra-long-horizon engineering tasks (hours to days of autonomous execution); large-scale parallel research; scenarios needing open weights + frontier long-horizon capability; cost-sensitive agent workloads.

5.9 “Which Models Lead Where” — The Position Table

Text / Reasoning / Coding

Dimension Leader Basis
Hardest abstract reasoning Claude Opus 5 ARC-AGI 97.5%, ARC-AGI-2 90.4%, GPQA Diamond 93.9%, HLE 54.9%; harness-optimized GPT-5.6 Sol ARC-AGI-3 from 13.3% to 38.3%
Software engineering (SWE-bench family) Claude Opus 5 Verified 96.0% / Pro 79.2% / Multilingual 89.5%
Ultra-long context GPT-6 10M tokens (API), ~1.5 million characters at once
Long-horizon autonomous execution Kimi K3 13-hour continuous coding, 24-hour kernel optimization, 5-day continuous runs, 300 parallel subagents
Strongest reasoning under open weights Kimi K3 2.8T open 3T-class; HLE and SWE-Bench Pro at frontier
Cost-performance frontier Hunyuan Hy3 / DeepSeek V4 Flash / MiniMax M3 $0.14/M input, $0.30/M input, $1.20/M output
Chinese everyday language feel Doubao slang, colloquial expression, C-end polish
Domestic comprehensive reasoning + olympiad Doubao 2.0 Pro IMO / CMO gold medals; Putnam Bench above Gemini 3 Pro
Math and formalization Hunyuan T1 MMLU-Pro 87.2%, MATH-500 96.2%, 2x decoding
Multilingual coverage Qwen3-Max 100+ languages

Image

Rank Model Notes
#1 quality Recraft V4.1 tops Artificial Analysis text-to-image quality
#1 deployment GPT Image 2 (2026-04-21) most-deployed base image model; token billing, Batch API 50% off
Enterprise copyright-safe default Adobe Firefly fully licensed training data, enterprise commercial indemnity, native Creative Cloud integration
Strongest Chinese commercial creation Doubao Seedream 5.0 / 5.0 Pro lasso precise editing, auto layer splitting/filling, intelligent layout in 10+ languages, single image carrying full-page PPT info; Lite version first with web retrieval
Text rendering / layout Seedream 5.0 and GPT Image 2 tied Chinese layout advantage more pronounced

Video

Rank Model Notes
#1 with audio Doubao Seedance 2.0 tops AA text-to-video Arena (with audio) ELO 1215; first to make joint audio-video generation SOTA; #1 across all three Arenas (text-to-video / image-to-video / editing); 15-second multi-shot + audio-video sync + multimodal input
Length and professional previsualization Doubao Seedance 2.5 30-second native video direct generation (far beyond the industry 15–20 second cap), 50 all-modal material references, 3D white-model previsualization (camera/scene/position planned in advance)
Cinema-grade quality (silent) Google Veo 3.5 1080p, stable physics simulation, long-shot temporal coherence, native Gemini API integration
Asian short video and ads Kuaishou Kling 4 native 9:16 vertical, fastest iteration, native Douyin/TikTok-style adaptation
Camera movement and cost-performance MiniMax Hailuo 2.3 #9 AA text-to-video, #5 image-to-video
Exited Sora 2 standalone app shut down 2026-03/04, off the lists; GPT-6 itself has no video generation

Voice

Dimension Leader Notes
Chinese TTS naturalness Doubao speech synthesis 2.0 domestic measured Chinese naturalness 9.2/10 (top tier), natural-language emotion control; first packet 300–400ms; 5-second cloning, similarity 97.5%; singing, dialects, accent mimicry, roleplay
Real-time full-duplex voice Doubao RealtimeVoice / SeedRealtime Speech2Speech end-to-end framework (not ASR→LLM→TTS cascade), conversation pacing problems reduced by half vs cascade; SeedRealtime native audio-video full-duplex, fully launched in Doubao app 2026-08-05, first consumer-grade scaled; proactively perceives the frame and calls tools
TTS leaderboard / voice similarity MiniMax Speech 2.6 tops Arena voice leaderboard (beating OpenAI and ElevenLabs), voice similarity 99%, serving 60,000+ enterprises
English dubbing ceiling ElevenLabs English naturalness 9.8/10 leading by a landslide; top emotional labels; Chinese naturalness 8.8/10
Ultra-low latency Azure TTS domestic data center first packet ~120ms (measured lowest), 700+ voices, 500K characters/month free tier
Voice evaluation benchmark Grok Voice official claim Voice API #1 on Big Bench Audio; Grok Voice 3.0 (2026-10-14)
Full-duplex conversation assistant GPT-Live 2026-07-08, full-duplex interruptible, “mm-hmm” interjections, can search the web while talking
Sound design Doubao voice design image-to-voice (upload character image for one-click voice), text-to-voice
Cinema-grade sound effects Doubao Audio 1.0 single prompt generating dialogue + ambience + music + SFX full track suite

Chapter 6: Future Directions and Trend Judgments

6.1 Six High-Certainty Trends

Trend One: Models Commoditize; the Harness Decides Winners

Basis: after open-sourcing its harness, OpenAI explicitly argued that “harness design, not model capability, is the primary lever on agent performance”; DeepSeek made the harness a public good under MIT; in the same week, Codex CLI, Claude Code, DeepSeek Harness, and GLM all converged on the same structure — harness/compute separation, stateless core, Manifest abstraction, Trajectory recording, subagent delegation.

Implication: choosing a model matters less; choosing a harness matters more. “Which model we use” gradually becomes a routing problem, not a faith problem.

Trend Two: From Single Agents to “Collective Agents”

Basis: Kimi Agent Swarm’s 300 subagents / 4000+ tool calls / 4.5x faster; Grok 4.20 Heavy’s 16 agents; Codex’s parallel subagents with worktree isolation; WorkBuddy’s Team-type Experts.

Implication: the next stage of performance gains no longer come mainly from “stronger models,” but from better task decomposition and concurrent scheduling. Kimi K3’s partial rollout (51 million sandboxes) shows that even “training” must be organized as collective agents.

Trend Three: Context Is Memory; 10M Windows + Cross-Week Persistent Memory Become Standard

Basis: GPT-6’s 10M context and cross-week persistent memory; Claude Opus 5 / Kimi K3 / MiniMax M3’s 1M; Grok 5 preview touting “bigger memory”; MiniMax MSA pushing per-token cost of 1M context down to 1/20.

Implication: workflows like “summarize it and paste it to me” will disappear. But the new problem that follows is memory governance — what to remember, what to forget, how to forget, how to audit: worth more than “whether you can store it.”

Trend Four: Skills and Plugins Become the “Package Manager + App Store” of the AI Era

Basis: Agent Skills is an open standard (46 products support it); Agent Plugins 1.0.0 jointly pushed by OpenAI/Amazon/Cursor/Microsoft/Vercel; MCP 2026-07-28 brings Skills over MCP into the spec; WorkBuddy’s skill marketplace has Wind’s 1600+ Skills; DeepSeek Harness’s Creator mode generates plugins from conversation; Kimi Claw’s ClawHub has 5000+ skills.

Implication: the distribution unit of the AI era is no longer the App, but Skills and MCP Servers. Whoever controls the “skill marketplace” and the “skill quality evaluation system” controls the AI-era app store. This also means: the engineering quality of Skills (readability, boundary clarity, failure handling, evaluation sets) becomes core competitiveness.

Trend Five: All-Modal Unified Models Replace Cascaded Architectures

Basis: Doubao SeedRealtime’s unified audio-video modeling (vs. the per-stage loss of cascaded ASR→VLM→TTS); Doubao Seedance 2.0’s joint audio-video generation (first SOTA); MiniMax M3’s interleaved text+image+video training from day one of pretraining; GPT-6’s Symphony architecture (claiming native unified processing of text/image/audio/video) — but the same material also has a counterexample: MiniMax M3’s voice and music are still API-layer stitching; “unified interface ≠ model fusion.”

Implication: within the next 12–24 months, “whether the voice model is natively fused with the main model” becomes the dividing line between “true all-modal” and “assembled all-modal.” Voice is the last modality that must be crossed.

Trend Six: Governance Moves from “Post-Hoc Review” to “Runtime Constraints”

Basis: the MCP spec writes user consent, data privacy, and tool safety as core principles (though not enforceable at the protocol layer); Codex’s sandbox mode with writable root, permission slash commands, and approval flows for reused cloud environments; WorkBuddy’s Ask/Plan/Craft permission tiers; DeepSeek Harness’s replayable, forkable Trajectory; harness/compute separation keeping credentials from ever descending into the sandbox.

Implication: “auditable agents” become an admission requirement for enterprise procurement. Agents without trajectory records, permission tiers, or sandbox isolation will be eliminated outright in regulated industries. This matters more to people building B-end products than to people building models.

6.2 Four Worth-Betting-On but Unsettled Judgments

  1. “Always-on agents” will become the third daily entry point. Microsoft, OpenAI (dots), WorkBuddy (smart glasses form factor), and Kimi Claw all point toward “background-resident, wake anytime.” But regulatory and privacy boundaries are not settled — an agent permanently resident on your device with continuous sensing permission is a social contract not yet negotiated.
  2. “Office software” as a category will keep retreating to the background. Functions won’t disappear, but the entry point shifts from “humans opening software” to “agents calling APIs.” This means software companies’ moats shift from features to data and scenarios.
  3. Assetization of industry know-how is the biggest commercial opportunity. The WorkBuddy open platform’s 100+ partners across 20+ domains validates: the most valuable things in traditional industries (processes, experience, context, scripts), once encapsulated as Skill / Expert / Connector, turn from “labor cost” into “reusable digital assets.” This may be the most certain industrial opportunity of 2026–2028.
  4. Single-point model companies’ bargaining power will keep declining. When harnesses become public goods and models are interchangeable via routing, “we have our own model” is no longer a moat. Model companies’ moats shift toward: cost structure, corpus uniqueness, scenario data, and channels.

6.3 A “What to Watch” Observation Checklist

Observation target Key signal What it means
MCP spec iteration adoption speed of extensions; whether protocol-level enforcement appears whether protocol standards can actually constrain implementers
Agent Skills ecosystem third-party Skill count, quality, whether evaluation/ranking systems exist whether skills can become tradable goods
Harness open-sourcing progress more core harnesses open-sourced; fork ecosystem scale whether agent infrastructure becomes a public good
Long-context cost curve slope of per-token compute cost decline vs. window length whether 10M context becomes widespread
Native voice fusion whether a flagship with voice and main model in the same pretraining framework appears whether “true all-modal” holds
Procurement compliance changes in mainstream enterprise procurement whitelists the usable boundary of Chinese models in regulated markets
Regulation landing EU AI Act enforcement pace; domestic generative AI measure practice market re-division around 2027

6.4 Down to the Individual: Three Concrete Suggestions

  1. Move your effort from “writing prompts” to “defining acceptance criteria.” Model execution is no longer the bottleneck in 2026; judging “is it done” is. The scarce people in the industry are not those who can use AI, but those who can state clearly “what counts as done” and verify it.
  2. Pick one harness and go deep, instead of trying every vendor. The harness sets the ceiling, and transferable experience (how to write SKILL.md, how to design tool schemas, how to handle context compaction, how to set approval boundaries) is an asset that spans models and products.
  3. Start building your own skills and connector inventory now. Whether you use Codex, WorkBuddy, or DeepSeek Harness, the skills and connectors you accumulate are your assets; models can change, platforms can change, but methods and context cannot. WorkBuddy users are already doing this (Wind’s 1600+ Skills, Kimi Claw’s 5000+ skills, Codex’s AGENTS.md and Skills) — entering now is far cheaper than entering a year later.

Appendix: Core Concept Quick Reference

Term One sentence Most easily confused with Era artifacts
Agent A system with goals that autonomously selects tools, adjusts to feedback, and persists until done the difference from “a one-off LLM call” or “a fixed pipeline” Codex / Claude Code / WorkBuddy / dsh / Kimi Agent
Loop The closed cycle of perceive→reason→act→observe→reflect not “multi-turn conversation” ReAct / agentic loop / Trajectory / partial rollout
Harness Everything except the model needed to turn a model into a working agent vs. “framework” or “SDK”: it runs a complete runtime Codex harness / dsh / Agents SDK / Claude Code
MCP The open standard protocol for agent-external-system communication vs. “tool”: a tool is one thing; a protocol is one way of connecting MCP 2026-07-28 / four Tier 1 SDKs / Connector
Skill An on-demand operation manual + scripts + resource package vs. MCP division: skill teaches “how,” MCP provides “where it connects” Agent Skills 1.0 / Agent Plugins 1.0 / skill marketplaces / ClawHub
Compiler / Harness / Compute separation Reasoning loop on the trusted side, execution on the isolated side credentials don’t drift with sandboxes Manifest + 7 sandbox providers
Trajectory Append-only complete run trace, replayable and forkable not ordinary logging DeepSeek Harness Trajectory / Codex traces
Subagent / Swarm Delegating subtasks to dedicated agents in parallel not “opening several windows” Kimi Agent Swarm (300) / Grok 16 agents / Codex worktree