If you write code with AI every day, you probably take model selection seriously: checking benchmarks, comparing prices, reading evaluations. Tool selection, on the other hand, is probably casual: how the UI looks, whether it’s free, whatever your colleagues use. This priority ranking carries an implicit assumption – the model determines the ceiling of output, and the tool merely exposes the model’s capabilities, so differences between tools can’t be that significant.
In May 2026, this assumption is being broken from two directions simultaneously.
The bottom-up direction comes from data. Cline ran Terminal-Bench 2.0 and revealed systematic differences for the same model across different runtimes – claude-opus-4.7 scores 74.2% on Cline versus 69.4% on Claude Code, a 4.8 percentage point gap for the same model. The top-down direction comes from industry signals – DeepSeek is hiring an Agent Harness product manager, OpenAI established Deployment Co. for full-stack Agent services, and Anthropic released Claude Cowork and Partner Network. The category of “model company” is being absorbed by the larger category of “Agent platform.”
These two lines point to the same conclusion: agent runtime is not just a neglected engineering layer – it is becoming the primary competitive interface of the entire AI industry.
To intuitively grasp the magnitude of 4.8pp, the best frame of reference is model version iterations.
Terminal-Bench 2.0’s public data provides a direct comparison. Claude Opus 4.5 to 4.6 was one version iteration, scoring 59.8% to 65.4% on the same Claude Code harness – an increase of 5.6 percentage points. Claude Opus 4.6 to 4.7 was another version iteration, from 65.4% to 69.4% – an increase of 4.0 percentage points.
The 4.8pp that Cline gained on opus-4.7 through runtime optimization is roughly equivalent to the improvement from upgrading opus-4.6 to opus-4.7. In other words, if Claude Code users didn’t upgrade their model but switched to Cline’s runtime, they’d get performance gains comparable to upgrading the model by one version.
An even more extreme example comes from Cline’s own hill climbing experiments. In February this year, the Cline team – without changing the model – optimized only the agent harness’s prompts, tool definitions, error handling, and context management, raising claude-opus-4.5’s Terminal-Bench score from 47% to 57%. A 10 percentage point improvement, entirely from runtime engineering. This number exceeds the combined improvement from two opus version iterations on the same harness (59.8% to 69.4%, cumulative +9.6pp).
The methodology article describes the specific iteration process: using the Harbor framework on Modal to run 89 real terminal tasks, producing results in 40-50 minutes per round, changing one variable at a time – one prompt, one bug fix, one configuration parameter – keeping improvements, rolling back regressions. Cline’s classification of failure modes is also worth noting: roughly 25% of failures hit the model’s capability ceiling and no harness can fix them; the remaining 75% can be fixed through prompt adjustments, tool definition optimization, and error handling improvements.
This 25/75 split is itself a judgment framework. A harness isn’t omnipotent – if you chose the wrong model (using claude-haiku for complex refactoring), no harness can save you. But it’s also not optional – 75% of failures can be fixed at the runtime layer.
LangChain’s independent experiments validate the same point. In their Deep Agents harness profile tests, they found that the same model, with and without targeted harness profiles, can differ by 10-20 percentage points – GPT-5.3 Codex went from 33% to 53% on tau2-bench, Claude Opus 4.7 went from 43% to 53%. A harness isn’t an optional performance optimization; it’s the critical layer that determines whether a model can function at all in Agent scenarios.
Cline’s official description is “rewrote the prompts, simplified the loop, tightened context management, improved feedback loops and error handling, and rethought how tools are defined and surfaced to the model.” Breaking it down, there are four interrelated design decisions.
First is prompt design. Cline rewrote the system prompt – not wording tweaks, but a fundamental redefinition of how the model understands its role, how it uses tools, and how it judges task completion. In agent scenarios, the model needs to maintain its sense of direction across dozens of tool-call turns; a subtle wording difference gets amplified repeatedly over long sessions. Cline’s iteration method is to change one variable at a time and run the full benchmark, using scores rather than intuition to judge prompt effectiveness.
Second is tool definition and presentation. The level of detail in
tool definitions, how parameters are described, the format of return
values – these directly affect the model’s accuracy in calling tools.
Cline isolates provider logic in the @cline/llms layer so
the agent loop itself is unaware of model differences, and tool
definitions only need to be optimized for one set of logic.
Third is context management. An agent’s context window continuously expands during long tasks. When to compact, in what order to delete, which information to preserve – these decisions directly impact performance in the later stages of a task. Prompt Caching as a First-Class Constraint discusses a counterintuitive design principle: to maintain cache prefix stability, compaction should preferentially remove the newest content at the tail rather than old content at the head. Because prefix stability determines cache hit rate – Anthropic’s cache hit pricing is one-tenth of a miss, and DeepSeek’s is similar. This isn’t a performance optimization; it’s a viability constraint that determines whether you can afford to run at all.
Fourth is error handling and feedback loops. Models make mistakes during execution – calling the wrong tool, generating invalid parameters. How the runtime feeds these errors back to the model directly determines whether it can self-correct on the next attempt. Good error messages don’t just say “something went wrong”; they tell the model exactly what went wrong, what the current state is, and what paths are available.
Cline SDK’s four-layer architecture (@cline/shared ->
@cline/llms -> @cline/agents ->
@cline/core) is itself the vehicle for these design
decisions. The agent layer is a stateless pure execution loop, not tied
to session storage; the core layer handles persistence and orchestration
but doesn’t intervene in the agent loop’s execution. This layering makes
A/B testing during hill climbing precisely controllable: changing
prompts doesn’t affect tool definitions, changing tool definitions
doesn’t affect session management.
Cline’s benchmark data is bottom-up evidence – proving runtime’s importance with numbers. The top-down signals are equally strong: model companies themselves are migrating to Agent platforms at scale.
On DeepSeek’s Mokahr recruitment page, the Agent Harness product manager remains listed as the top hot position. This isn’t an isolated role – the same page lists Agent Deep Learning Algorithm Researcher, Agent Data Strategy Engineer, Agent Full-Stack Developer – four tracks forming a complete Agent product team. On March 25, DeepSeek opened 17 Agent-related positions simultaneously; on April 24, the day DeepSeek V4 Preview launched, they added more Agent Full-Stack and Agent Data Strategy roles. V4’s official release notes list “Dedicated Optimizations for Agent Capabilities” as the first item. As of May 16, the Harness PM position still sits at the top of the hot recruitment list – the role hasn’t been filled, and the product direction is still being assembled.
OpenAI’s path is the most aggressive. From Codex CLI (May 2025) to Codex App, Codex Security, and then Frontier (February 2026) – an enterprise Agent platform integrating Business Context, Agent Execution, and Evaluation & Optimization, with customers including HP, Intuit, Oracle, and Uber. In May 2026, OpenAI went further by establishing Deployment Co., backed by private equity firms TPG and Brookfield with over $4 billion in funding, deploying forward-deployed engineers into client organizations for full-stack Agent services.
Anthropic takes a different path. Claude Code targets developers; Claude Cowork targets non-technical users with a fully autonomous desktop agent – running in a Linux VM on Mac, controlling the host machine’s browser and desktop through Chrome MCP. They simultaneously launched Claude Partner Network, with Blackstone, Goldman Sachs, and others each contributing $300 million, providing managed Agents across four industries: healthcare, manufacturing, finance, and retail. Anthropic also added Agent SDK credits to its subscription plans – allocating dedicated quotas for third-party programmable usage.
In May, LangChain released Managed Deep Agents and SmithDB – a purpose-built observability database designed for nested, long-running agent traces. Cline extracted its internal runtime into an open-source SDK (Apache 2.0), transforming from the underlying engine of a VS Code extension and CLI into a standalone product anyone can embed.
This isn’t the action of one company. This is an industry-level structural shift. In the words of AINews’s May 13 summary: “Cline, LangChain, Notion, and Cursor all pushed deeper into agent platform territory.”
The logic driving this collective migration is clear: pricing competition for model APIs has reached its endpoint.
In the same week of April 2026, three labs released frontier models. Claude Opus 4.7 costs $25 per million output tokens, GPT-5.5 is $30, DeepSeek V4-Pro is $3.48, and V4-Flash is $0.28 – V4-Flash’s inference cost is 1/107th of GPT-5.5’s. In the Chinese market, competition is even fiercer: Alibaba’s Qwen 3.6 Plus is free during its preview period, and Xiaomi’s MiMo V2 Flash has an input price of $0.09/M.
When token prices approach zero, pure API revenue cannot sustain ongoing investment in foundation model R&D. The more fundamental issue is the moat: switching costs at the model layer are extremely low. Once your harness or agent runtime is good enough, switching LLM providers often requires minimal adaptation – changing an environment variable or a model ID in a config file, and behavior remains basically the same. OpenCode works exactly this way today: users can freely switch between different LLM providers, and perceived intelligence differences are absorbed by the runtime layer. When switching models is nearly frictionless, the model layer has no moat to speak of. Value capture can only move upstream – from API to platform to service. Agent platforms create an entirely different revenue structure: platform fees (per-seat or monthly subscription), consumption markup (model calls within the platform billed at platform pricing), value-added services (industry templates, custom skills, forward-deployed engineering). More importantly, they create switching costs – system prompts, skill configurations, MCP server connections, harness configurations – once established on a platform, the effort to migrate far exceeds replacing an API key.
The lock-in strategies differ across the three companies. OpenAI pursues full-stack lock-in – distributing through ChatGPT Plus’s 7.7 million subscribers, with Frontier’s Business Context layer keeping enterprise data and workflows within OpenAI’s ecosystem. Anthropic pursues open protocol plus operational lock-in – MCP protocol lowers tool integration switching costs, but Agent behavior configuration, skills, and managed agents’ operational knowledge stays on the Anthropic platform. DeepSeek currently has no platform lock-in – its strategy is ecosystem penetration: MIT open source, OpenAI/Anthropic dual-compatible API, and prices one to two orders of magnitude lower than competitors.
This is precisely why the Harness PM role is so urgent. Ecosystem penetration builds usage habits, not switching costs. LangChain Deep Agents has built-in harness profiles for DeepSeek V4, and OpenClaw set V4 as the default model on its launch day – but these are endpoint-level integrations that don’t constitute lock-in. DeepSeek needs its own Agent platform to create switching costs on par with OpenAI and Anthropic. In the Chinese market, this need has additional urgency: competitors’ Agent strategies are all tied to their own lifestyle ecosystem – Alibaba’s Qwen integrates with Taobao, ByteDance distributes through Douyin and Volcengine, Tencent has WeChat’s billion-scale user base. DeepSeek is the only pure-technology player.
For people who use AI to write code – not people who sell AI – this structural shift has several direct consequences.
First, choosing a runtime deserves as much seriousness as choosing a model. Cline’s hill climbing experiments and LangChain’s harness profile tests both demonstrate that runtime can independently contribute 10-20 percentage points of performance difference. This magnitude is equivalent to one model version iteration.
Second, the dimensions for choosing a runtime are more complex than model selection. Model selection primarily considers benchmarks and price. Runtime selection requires considering: breadth of model support (whether your workflow needs to switch between different models), degree of layering (whether you can use only the parts you need), prompt engineering openness (whether you can modify system prompts and tool definitions), and caching strategy (cache hit rate directly affects cost baseline and latency). These dimensions currently lack standardized benchmarks for cross-runtime comparison – Terminal-Bench 2.0 is the only test that provides cross-harness data, but it tests terminal scenarios and doesn’t represent all coding tasks.
Third, the Chinese market has a special window. DeepSeek’s harness isn’t built yet – the PM position was still open on May 16. This means DeepSeek V4’s current performance advantage needs to be released through third-party runtimes (Cline, OpenCode, LangChain Deep Agents). Whoever can help DeepSeek solve the “has model, no lock-in” problem – by building a harness profile optimized for DeepSeek V4, or by converting DeepSeek’s model advantage into a productized Agent experience – gets the next card dealt. This isn’t something that requires waiting for DeepSeek to finish on their own; it’s something that can be started right now.
Finally, the most reliable method for making choices remains unchanged: run A/B tests on your own codebase. Terminal-Bench provides directional signal – runtime differences genuinely exist and are non-trivial in magnitude. Harness PM hiring provides trend signal – the entire industry is moving in this direction. But which runtime performs best on your specific workflow can only be determined by testing on real code yourself. Use a framework like Harbor, on your own repo, with the models you actually use, running 10-20 representative tasks. This is more valuable than reading any benchmark ranking.
The category of “model company” is dissolving. OpenAI, Anthropic, and DeepSeek are all doing the same thing: packaging model capabilities into Agent platforms and services, extending downstream in the value chain. The agent runtime layer is not icing-on-the-cake engineering optimization; it is this industry’s next major battleground. Its competitive outcome will determine which layer captures AI’s value over the next five years.