The Model Is Frozen. The Harness Is the Battlefield — How Big Tech Is Productizing the Agent Layer

nooyix — Sun, 16 Aug 2026 23:41:17 +0000

If you think the AI race is still about who has the biggest model, you missed the real fight of the past year. As the top models converge in capability, the announcements from OpenAI, Anthropic, Google, and Microsoft have quietly stopped being about the model — and started being about the harness wrapped around it.

This post breaks down what a harness is, why it became the battleground, exactly how each company is turning it into a product, and what to watch next.

What is a "harness"?

An agent's capability splits in two. One part is the model weights — the raw ability of the LLM. The other is the harness: everything wrapped around the model — prompts, tools, skills, control flow, and agent-to-agent collaboration.

The term comes from software's test harness (the scaffolding that drives a system so it actually runs), later evaluation harness (e.g. EleutherAI's lm-evaluation-harness), and now agent harness. Same model, different harness → wildly different results. In other words: agent = model + harness.

Why the harness became the battlefield

First, models leveled up. The gap between frontier models narrowed, so differentiation now comes from what you make the model do, not whose model is smarter.

Second, the harness is cheap and fast to change. Retraining a model costs a fortune; a harness is basically code — you can iterate on it instantly.

Third, this is where lock-in happens. Once you're fluent in one company's tool format and orchestration, switching hurts. So every vendor is racing to own their harness ecosystem.

How the global players are doing it

Same harness, different pressure points: Anthropic bets on open protocols, OpenAI on tool execution, Google on agent-to-agent communication, Microsoft on consolidation.

🟣 Anthropic — splitting the harness into an open standard

Anthropic's strategy is a clean three-layer split.

At the bottom sits MCP (Model Context Protocol), a JSON-RPC standard it open-sourced in November 2024 to kill the M×N integration problem — the combinatorial mess of writing a custom connector for every tool. The tell is that Anthropic didn't keep it proprietary: OpenAI (Mar 2025), Google (Apr 2025), and Microsoft adopted it, and in December 2025 Anthropic donated MCP to the Agentic AI Foundation, a Linux Foundation directed fund — genuinely giving up sole control. The current spec (2026-07-28) is even a stateless redesign.

On top sit Agent Skills (Oct 2025): reusable capability modules defined by a single SKILL.md file. The clever bit is progressive disclosure — normally only the ~100-token name/description sits in the prompt; the full instructions load only on a match, and bundled scripts contribute only their output to context. The same format runs on claude.ai, Claude Code, and the API. At the top, the Claude Agent SDK (Sep 2025, formerly the Claude Code SDK) exposes "the same agent loop that powers Claude Code" as a library — context compaction, subagents, hooks, structured output, native MCP.

In one line: standardize the tool interface as a neutral public protocol (MCP), make expertise a portable file (Skills), ship the real runtime (Claude Code) as an SDK.

📎 Official: MCP intro · MCP spec · MCP donation (AAIF) · Agent Skills · Agent SDK docs

🟢 OpenAI — going all-in on tool execution

OpenAI's harness is two layers. The base is the Responses API (GA Mar 2025) — a built-in agentic loop where the model can call multiple tools in one request, plus first-party hosted tools (web search, file search, code interpreter, computer use) and native remote MCP support. Above it is the Agents SDK (Mar 2025, the production successor to the experimental Swarm), whose whole mental model is three ideas — agents, tools, handoffs — rounded out by guardrails, sessions, and tracing. The dividing line: drive the loop yourself with the Responses API, or let the SDK run it for you.

The headline 2026 move is Programmatic Tool Calling: instead of one tool call per turn, GPT-5.6 (Jul 2026) writes a JavaScript program that orchestrates your tools — in parallel, with loops and conditionals — which OpenAI runs in an isolated V8 sandbox (no network, no filesystem) and returns only the final result. By keeping bulky intermediate outputs out of the context window, OpenAI reports one customer cutting token usage by 63.5%. (OpenAI also shipped AgentKit in Oct 2025, but its Agent Builder and Evals are being wound down through late 2026 — the durable pieces are the Responses API + Agents SDK.)

In one line: obsess over tool-execution efficiency — let the model orchestrate tools as code.

📎 Official: Agents SDK docs · Programmatic Tool Calling guide · AgentKit announcement

🔵 Google — a communication standard between agents

Google bet one level up: on how independently built agents talk to each other. The A2A (Agent-to-Agent) protocol lets one agent delegate work to another regardless of framework. Its core primitive is the Agent Card — a JSON document at a well-known URL advertising an agent's identity, skills, endpoint, and auth; work flows as Tasks carrying Messages and Artifacts. The pitch: A2A is to agents what HTTP is to web services.

Google announced it in April 2025 and donated it to the Linux Foundation in June 2025; the first stable spec, v1.0.0, landed in March 2026 (current v1.0.1). Per the Linux Foundation, 150+ organizations back the standard and its repo passed 22k stars. On the developer side, the open-source ADK (Agent Development Kit) is Gemini-optimized but model-agnostic (works with Claude, OpenAI too), ships orchestration primitives (sequential/parallel/loop), moved Python to a graph-based v2.x engine, and spans Python/Java/Go/TypeScript. Notably, Google makes A2A but also consumes MCP — embracing both standards.

In one line: capture the agent-to-agent layer with an open protocol — release A2A to grow the whole pie.

📎 Official: A2A spec · A2A donated to LF · ADK (GitHub)

🟠 Microsoft — consolidating the mess

Microsoft spent 2025–2026 collapsing a fragmented story into one stack. Its two open-source projects — enterprise-grade Semantic Kernel and research-driven AutoGen — were merged into the Microsoft Agent Framework (MAF) (public preview Oct 2025 → 1.0 GA early April 2026). AutoGen is now in maintenance mode; Semantic Kernel gets fixes for at least a year, then migrates. MAF combines SK's enterprise plumbing (typed sessions, middleware, telemetry) with AutoGen's agent abstractions, and adds a graph-based workflow engine for deterministic control flow. It ships for .NET, Python, and Go.

Standards are all native — MCP for tools, A2A for cross-runtime coordination (a Python agent driving a .NET agent), OpenAPI for arbitrary APIs. At Build 2026 it added CodeAct (the model writes Python that calls tools, executed in a sandboxed micro-VM — the same idea as OpenAI's PTC). Around the SDK sit the low-code Copilot Studio, the Azure AI Foundry runtime, and Agent 365 for governance.

In one line: consolidate and govern — one stack from code to low-code to runtime to management, embracing every standard.

📎 Official: Agent Framework intro · Overview docs · GitHub

At a glance

	Bet	Signature tools	Standards
Anthropic	Open standard + portability	MCP, Skills, Agent SDK	Created MCP
OpenAI	Tool-execution efficiency	Responses API, Agents SDK, PTC	Adopted MCP
Google	Agent-to-agent comms	A2A, ADK	Created A2A + consumes MCP
Microsoft	Consolidation + governance	Agent Framework, Foundry, Agent 365	MCP + A2A native

Two threads running through all of it

1. The harness is converging onto two standards

Tools speak MCP, agents speak A2A — and both now live under the Linux Foundation umbrella (MCP via the AAIF, A2A directly). All four companies support both. The harness is turning from each vendor's secret sauce into infrastructure built on shared protocols — much like the internet standardized on HTTP.

2. "The model writes code to drive the tools"

The more interesting convergence: OpenAI's Programmatic Tool Calling, Microsoft's CodeAct, and Anthropic's advanced tool use all landed on the same idea almost simultaneously — the model orchestrates tools by writing code, executed in a sandbox. We're moving from one-tool-call-per-turn to the model writing a program with parallelism, loops, and branches. This pattern — cheaper on tokens, lower latency — looks likely to become the default for the next generation of harnesses.

What to watch

1. Standards settled; the layer above didn't. MCP and A2A standardized the bottom, but orchestration SDKs, runtimes, and clouds are still each vendor's turf. The competition just moved up a level.

2. Open standards, quiet lock-in. "The standard is open, but the substance (deploy, govern) runs on our cloud" is the shared playbook. How far do you trust MCP/A2A openness when Foundry/Vertex/etc. still capture the deployment?

3. Security — a widening attack surface. The more a harness connects to external tools, data, and unknown agents, the bigger the permission/trust/audit problem. It's why production guides push "hooks that block dangerous commands" and governance layers like Agent 365 — and why, in an era of the model running code it wrote, sandbox isolation is the safety story.

4. The complexity paradox. The more SDKs make assembly easy, the harder it gets to know what's running where. Every layer of convenience adds a layer of debugging and cost-tracking difficulty.

Wrapping up

Big Tech's real competition moved from model size to the harness and its standards. The model becomes a shared component; the fight is over what you connect it to (MCP), how you run it (SDKs), and how agents collaborate (A2A).

Building a good agent is less and less about picking a bigger model, and more about which harness ecosystem you stand on. So — which camp's harness would you bet on today? Or would you hold onto the standards (MCP, A2A) and keep your SDK swappable? 👇

Standards reference — MCP spec · A2A spec. Per-company official links are marked 📎 above.

DEV Community: nooyix