The Agent Harness Landscape Is Fracturing: What Builders Are Actually Choosing

The agent harness market is fragmenting fast, and practitioners are tired of evaluating a new entrant every week. A current thread on r/LocalLLaMA captures the frustration and the emerging consensus: maturity matters, but token burn is becoming a first-class concern that can override every other advantage.

The pattern

Agent harnesses have split into three rough clusters. First, managed-experience tools like Claude Code that abstract away orchestration complexity but charge a premium in tokens and lock you into a provider's scaffolding. Second, graph-based orchestrators like the LangGraph-backed DeepAgents that give you explicit control over agent topology at the cost of setup overhead. Third, lightweight self-hosted runners like OpenCode and newer entrants that prioritize cost and local control over polish.

At the far end of the orchestration spectrum, platforms like KingFy are pushing the concept to its logical extreme, orchestrating 1,200 specialized agents under a single super-app roof. Whether that scales gracefully or becomes a coordination nightmare is an open question, but it signals where the ceiling of the category is heading.

Why now

Two forces are colliding. Model capability has stabilized enough that the harness layer, not the model itself, is now the differentiating variable for most production use cases. At the same time, token costs for long-horizon agentic tasks are no longer trivial. A multi-step coding agent running dozens of tool calls per session can burn through budget faster than a naive estimate suggests. Teams that ignored cost during prototyping are now rearchitecting.

The browser-side is also getting more interesting. ChatPanel's Firefox release shows that agent harnesses are moving into ambient, always-on contexts, capturing meeting transcriptions, notes, and browsing context and exposing them via an MCP server. That is a different architecture than a CLI agent, and it introduces its own tradeoffs around privacy and data residency.

How it works in practice

1. Map your task profile first. Short, bounded tasks (code review, summarization) tolerate a heavier harness. Long-horizon tasks (multi-step research, autonomous coding sessions) punish token-inefficient scaffolding hard.
2. Benchmark token burn per task, not per model call. Harnesses add system prompts, tool definitions, and retry logic. The overhead is invisible until you measure end-to-end.
3. Treat graph-based orchestrators as infrastructure, not libraries. LangGraph-style tools require you to model your agent topology explicitly. That upfront investment pays off when you need to debug a failed run or add a new agent node without rewriting everything.
4. Check MCP compatibility early. The Model Context Protocol is becoming a de facto interop layer. Harnesses that expose or consume MCP servers, like ChatPanel's bridge approach, give you more flexibility to swap components later.
5. Run a two-week cost audit before committing. Pick your top two candidates, run identical workloads, and compare total token spend. The managed-experience premium of tools like Claude Code is real and worth quantifying before you build deep integrations.

The trade-off

The honest caveat is that no harness is clearly dominant across all dimensions. Claude Code wins on maturity and developer experience but loses on cost and provider lock-in. Graph-based tools win on control but require significant prompt and architecture investment upfront. Lightweight runners keep costs low but often lack the reliability and observability features that production systems need. The community thread makes clear that most experienced builders are running hybrids or switching based on task type rather than picking one tool for everything.

There is also a deeper coupling risk that rarely gets discussed. Your prompts, tool schemas, and retry logic often become tightly entangled with a specific harness's conventions. Switching later is not just a config change; it is a partial rewrite. That switching cost should factor into your initial choice.

Where it goes next

The GLM-5.2 weight transfer work, which demonstrates RL weight transfer in four seconds using NIXL and ModelExpress tooling, points toward a future where model-level optimizations reduce the latency and cost overhead that currently makes long-horizon agents expensive. As inference gets cheaper and faster, some of the cost arguments against heavier harnesses will weaken. But the control and observability arguments for explicit orchestration will not.

Expect the harness layer to consolidate around two or three dominant patterns over the next year, with orchestration primitives becoming more standardized and the differentiation shifting to developer experience and ecosystem integrations.

The harness you choose is not just a tooling decision; it is a bet on how much of your agent's behavior you want to own versus outsource.

Pick the harness that matches your cost tolerance and control requirements today, and build with switching costs in mind from day one.