The Model Became a Plugin. The Bill Didn't.

1. What actually happened this week

On August 13, with no launch event, DeepSeek shipped two things at once: the GA build of V4-Pro (0813), and an open-source agent runtime called DeepSeek Harness (CLI name dsh). One is the model. The other is the shell the model runs inside. Four days later, the attention split in a way few predicted. The model got buried under the pricing story, while the shell — MIT licensed, written in Node.js, still carrying a "developer preview" warning — climbed toward six figures in GitHub stars, with a community plugin ecosystem forming over the weekend.
Harness has exactly one design idea: everything is a plugin. Model adapters, the tool registry, the session log, sandboxes, the filesystem, and the agent loop itself are all plugins, and all of them are replaceable. The documentation's phrase "no privileged core to patch" is the whole point: extending Harness does not mean editing Harness. It means mounting another plugin beside the existing ones. Underneath sits the Cordis meta-framework, derived from a paper on a programming paradigm for spatiotemporal composability.
Two other things landed the same week, pointing the same direction:

Around August 15, Codex's Multi Agents v2 gained cross-model delegation: a capable orchestrator such as GPT-5.6 Sol can hand narrowly scoped grunt work to the faster, cheaper Luna. Per the developer who surfaced the change, Luna workers are "pure sub agents" that cannot message each other or spawn further agents, and the default behavior still clones the parent's model and settings. Getting the new path currently requires prompting for it.
Agent Plugins 1.0 reached general availability in GitHub Copilot, refined with Vercel, AWS, Anysphere, GitHub, Microsoft and OpenAI, with Google joining as a core maintainer on launch day. The spec is deliberately small: a plugin.json manifest, an optional skills/ directory, an optional mcp.json. Read together, all three say the same thing: the model is being demoted to a configuration value, and the runtime is being promoted to an architectural decision.

2. What's swappable and what isn't

For two years the default mental model has been that the weights matter and everything around them is glue. Harness's four presets invert that assumption.

Note minimal. When DeepSeek published V4-Pro-0813's numbers on public coding-agent benchmarks — 87.9 on Terminal Bench 2.1, 62.7 on DeepSWE, 74.1 on Toolathlon-Verified — the model was running inside Harness in minimal mode for some of them. Which means a "model score" has contained a harness contribution all along. Swap the shell and the number moves. That isn't contamination; it's the honest shape of the thing. Agent capability was always a joint product of model and runtime.
code mode deserves a closer look. Conventional function calling is a loop: the model emits a tool call, the runtime executes it, the result is appended to context, the model emits the next one. Five operations mean five full round trips, each one re-processing the accumulated context. Code mode compiles the tool surface into a TypeScript SDK, hands it to the model, and lets the model write a single program. What you save is not only latency but four prefills you no longer pay for.
On the swappable side, the Harness provider catalog covers Anthropic, OpenAI, AWS Bedrock, Azure, Google's enterprise agent platform and DeepSeek's own endpoint — plus an explicit slot for custom OpenAI-compatible gateways. It even ships two subagent providers that hand work directly to Claude Code and Codex, both off by default, both resolving the vendor binary from your PATH so you supply the install and the login. There is an MCP client, Agent Client Protocol support, and it reads AGENTS.md and CLAUDE.md.
A Chinese lab shipped an agent framework that runs a competitor's model with zero friction. That looks like generosity. It is closer to a bet: models will commoditize; harnesses won't. Changing models is a config line. Changing runtimes means rewriting session storage, rerunning regressions, retraining a team. VentureBeat put it bluntly — for enterprise developers, Harness may be the more consequential half of the August 13 announcement.
There is an irony here. In the same week Harness made models trivially swappable, DeepSeek's billing became harder to swap. From 16:00 UTC on August 16 (midnight Beijing time on August 17), the V4 family moved to peak/off-peak pricing. V4-Pro output went from a flat $0.87 per million tokens to $1.98 off-peak and $3.96 at peak; cache-hit input went from $0.003625 to $0.022 off-peak and $0.044 at peak — roughly 5x even at the discounted rate, about 12x at peak. And long sessions, repository analysis and subagent fan-out — exactly what Harness is built for — are the most cache-intensive workloads there are.
So developers get an odd pairing: the runtime layer has never been this portable, and the cost layer has never demanded this much arithmetic. The model is a plugin. The bill isn't.

3. Finishing the sentence "everything is a plugin"

For "everything is a plugin" to hold in practice, one piece is still missing: something coherent behind the plugin. Otherwise you list five providers in config and inherit five keys, five invoices, five quota alarms and five rate-limit dialects. The configuration unified; the operations didn't.
That is the slot a model gateway fills. wrouter.ai exposes a single OpenAI-compatible entry point, which is precisely what Harness's "custom OpenAI-compatible gateway" plugin expects:

from openai import OpenAI

client = OpenAI(api_key="wr-***", base_url="https://wrouter.ai/v1")

# Orchestrator: planning and decomposition
plan = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Analyze the auth module in this repo and list refactor steps"}],
)

# Workers: well-scoped grunt work on a cheaper model, same key, same invoice
for step in parse_steps(plan.choices[0].message.content):
    client.chat.completions.create(
        model="deepseek-v4-flash",
        messages=[{"role": "user", "content": step}],
    )

Wiring it into a Harness model plugin is the same move: point the provider at https://wrouter.ai/v1, then assign model names by role inside the preset — a strong model for the orchestrator, a fast one for subagents, a third-party model for cross-checking during evaluation. Three properties do the work here. Interface stability means a preview-stage project that openly promises breaking changes at least won't break on the model side. Model coverage means "changing models is one line" holds across vendors, not just within one vendor's product line. Unified billing means peak/off-peak rates, cache hit ratios and the orchestrator-versus-worker split are legible in one place, instead of being reconstructed by subtraction across five invoices at month end.
One practical note: since Harness records everything the model sees in an append-only session log, and billing is now time-of-day dependent, write the model name, token counts and request timestamp into that same log. When you need to answer "how much did last week's runaway agent session cost, and which step was expensive," that log will be more useful than any invoice.

4. Closing

Harness went viral this week not because it invented a feature, but because it wrote down as architecture something everyone was already doing quietly: the model is a replaceable part, and the runtime is the asset. Codex's cross-model delegation and the Agent Plugins 1.0 packaging format are the same sentence in different words.
The takeaway for developers is concrete. Assume you will replace every model you currently use within six months, then design your call layer for that assumption. Make model names configuration. Make providers plugins. Collapse billing into one place. That way, the next time a vendor silently repoints an endpoint at 2 a.m. or announces a 12x increase on cached input, the change on your side is a string.
If you're building that layer now, wrouter.ai can serve as the unified entry point — closing out half the cost and stability problems of multi-model orchestration so you can go back to tuning the part that actually differentiates you: the agent loop.

Sources