StartThe agentic harness is open source's new battleground
By Addy · August 29, 2026 · Editorial standards
Open-source AI has spent much of its energy trying to win at the model layer. The more interesting fight is happening one layer higher. Hermes Agent, T3 Code, and OpenCode are all building around models rather than only training them.
That layer has an awkward name: an agentic harness. It handles the tools, state, permissions, context, retries, and handoffs that turn a model into an AI agent. The model is the chef's judgment. The harness is the kitchen, order rail, timers, and health code. A better chef does not fix a kitchen that loses orders or lets ingredients spoil.
That is why the harness is becoming open source's scapegoat. When an open-source coding agent fails to finish a task, the model gets blamed for being weak, the interface gets blamed for being rough, and the harness gets blamed for everything in between. The more accurate reading is that this layer is becoming the durable product.
The three projects are not equivalent. OpenCode is a coding agent. T3 Code is a control surface for agents that already exist. Hermes Agent is a persistent, general-purpose runtime with coding capabilities. Treating them as three versions of the same product misses the point. Together, they show where open source is accumulating value.
The Agent Is More Than Its Model
An AI agent is a model placed inside a loop. The model proposes an action. The harness decides which tools are available, builds the context, executes the action, captures the result, decides whether to retry, asks for approval when necessary, and determines whether the task is actually complete.
That distinction is easy to miss because closed products package all of it under one name. Claude Code and Codex present a model, prompt system, tool layer, context policy, permission system, memory strategy, and command surface as one product. A user sees one agent. An evaluator often reports one score. The boundary between model capability and system design disappears.
Open source makes that boundary visible. A developer can inspect the tool definitions, replace the model provider, change the context strategy, add a permission gate, or fork the interface. That is more work than opening a hosted application. It is also ownership of the part of the system that determines how intelligence becomes action.
The distinction matters most on long tasks. A model can write a good patch and still fail as an agent if it cannot find the right files, loses the task state after a context limit, repeats a failed command, edits without a rollback path, or declares success without running the tests. Those are harness failures, model failures, or failures created by the interaction between both. A single score cannot tell you which.
OpenCode Makes Model Choice a Feature
OpenCode is the clearest example of an open-source coding agent turning model choice into part of the product. Its MIT-licensed repository describes an open-source coding agent with terminal and desktop surfaces, built-in build and plan modes, a general subagent, and a provider-flexible architecture. The official OpenCode site says it supports more than 75 LLM providers, including local models.
The practical value is not that every model performs equally well. They do not. The value is that the workflow can survive a model change. A developer can keep the same project conventions, command surface, permissions, session structure, and agent habits while changing the model underneath. When a cheaper model becomes good enough for routine edits, or a new model becomes better at debugging, the user has somewhere to put it.
That is a different kind of lock-in. A closed coding product can make the model and the interface feel inseparable. OpenCode makes the interface the stable part and treats the model as a dependency that can be replaced.
The project has an unusually large attention signal. The OpenCode GitHub repository displayed 202.2k stars and 26.3k forks when checked on August 29, 2026. Its website also claims that more than 16 million developers use it each month. The GitHub numbers are observable. The monthly usage figure is a project claim. Neither is independent evidence that OpenCode completes more real coding tasks than a closed competitor.
The limitation is important. Model agnosticism can mean that a model appears in a provider menu, not that it delivers the same result through the same tools. Tool-call formats differ. Context limits differ. Some providers handle reasoning, streaming, file edits, or authentication differently. A harness can give users choice without giving them parity.
OpenCode's value is therefore optionality, not magic. It keeps the workflow from being held hostage by the model that happens to be strongest in one benchmark cycle.
T3 Code Separates the Control Surface
T3 Code goes one layer higher. It is not a model and does not present itself as a standalone coding agent. Its repository calls it an agent harness control surface. It lets users control agents running on their machines through an iOS app, Android app, web app, and Electron desktop application.
The supported agents include Claude Code, Codex, Cursor, Grok Build, and OpenCode. That list is the point. T3 Code is trying to make the interface for operating agents independent from the company that created the underlying agent.
Think of it as a universal remote for a room full of televisions. It does not manufacture the screens or decide what each channel broadcasts. It gives the user one place to control them. If the remote is open and forkable, the user can change the buttons, add another screen, or build a different layout without waiting for every television manufacturer to agree.
The repository is MIT licensed and displayed 20.9k stars and 5.0k forks on August 29, 2026. Those numbers are smaller than OpenCode's, but the architectural move is more revealing than the count. T3 Code treats the harness as a product category of its own.
It also shows why open source does not have to mean open models. T3 Code can be open while controlling closed agents and routing work through proprietary APIs. Its value is portability and control over the surface, not independence from every provider.
That creates a dependency of its own. T3 Code still relies on the command-line agents it supervises, their authentication systems, their local state, and their behavior when a task fails. A control surface can unify access without unifying reliability. If a provider changes its CLI or permission model, the open layer has to catch up.
Still, the existence of this product category matters. Users are beginning to separate the question of which agent they run from the question of how they supervise it.
Hermes Turns Memory Into Infrastructure
Hermes Agent sits at a different point in the stack. Nous Research describes it as a self-improving AI agent rather than a coding-only tool. Its repository lists persistent memory, autonomous skill creation and refinement, session search, user modeling, parallel subagents, scheduled automation, messaging gateways, and seven terminal backends. It also supports multiple model providers and lets users switch models without changing the rest of the runtime.
Hermes displayed 237.8k GitHub stars, 48.3k forks, and 2,748 contributors on August 29, 2026. Those figures show attention and participation. They do not establish that its self-improvement loop is reliable, that its memory is useful for every user, or that it beats a managed coding product on software engineering tasks.
Hermes matters because it treats the agent as a long-lived environment. OpenCode keeps the coding workflow stable while the model changes. Hermes tries to keep memory, skills, schedules, and delegated work stable while the model, interface, and deployment target change.
The analogy is a workshop with labeled shelves. A single chat session gives you a workbench for one job. A persistent agent can keep the tools, instructions, materials, and notes ready for the next job. That is useful only if the shelves stay organized. A stale memory, an outdated skill, or a secret stored in the wrong place can make persistence a liability.
That is the tradeoff open source makes visible. Users can inspect how memory is written, decide where it lives, remove a bad skill, and change the approval rules. They also have to make those decisions. Persistence is not automatically intelligence. It is state, and state needs governance.
Three Layers, Not Three Versions of the Same Product
The distinction is easier to see in one table:
| Project | Layer it owns | What remains outside it |
|---|---|---|
| OpenCode | Coding agent loop, provider adapters, terminal and desktop workflow | Model quality, provider policies, and token cost |
| T3 Code | Control surface for multiple installed agents and remote access | Underlying agents, model authentication, and vendor behavior |
| Hermes Agent | Persistent runtime, memory, skills, subagents, and deployment backends | Model provider, local operations, and user safety decisions |
The overlap is not accidental. All three projects treat the model as one replaceable component in a larger system. Their differences show that the open-source opportunity is not one product category yet. It is a stack.
The Harness Is Becoming the Durable Asset
Models are consumable. Their prices change, their context limits move, and a new release can make a carefully tuned setup feel old. The operational state around a model is harder to replace: project instructions, tool permissions, skills, memory, context-compaction rules, logs, test routines, and the habits a team builds around failure.
That is where the economic value of an open harness appears. The user is not only buying an answer. The user is preserving a way of working while the model market changes underneath it.
This is also why a harness can matter even when the underlying model is closed. OpenCode can route to a proprietary API. T3 Code can supervise Claude Code or Codex. Hermes can run with a hosted provider. The open layer still gives the user more control over the workflow, even when the intelligence is rented.
The strongest version of the argument is not that open-source agents are smarter. It is that they make the rest of the system inspectable and replaceable. If a provider becomes too expensive, the model can change. If a tool is unsafe, the permission layer can change. If a workflow is missing a verification step, the loop can change. A hosted product may eventually add all of those controls. An open project lets a user change them without waiting.
Why It Is Easy to Blame the Harness
The harness is visible precisely because it is open. That makes it the easiest part of the system to blame when an open-source agent underperforms.
The comparison is often unfair. A model running inside Claude Code or Codex arrives with a vendor-designed prompt, tool adapter, context policy, permission system, and recovery loop. The same model running through an open harness may have different instructions, weaker integrations, or fewer opportunities to verify its work. A benchmark result then gets described as a model result even though the model and the harness were evaluated together.
The opposite mistake is possible too. A strong harness can make a weak model look capable on a narrow workflow. Better context selection, clearer tools, and a good retry policy can rescue a task without changing the underlying model. That does not make the model unimportant. It means the output belongs to the system.
The useful test is not which brand claims the best harness. It is whether two systems can be compared with the same model, repository, tools, context budget, permissions, retry policy, and success criteria. The measurement should include task completion, human interventions, cost, recovery from failure, reproducibility, and rollback quality. There is no public apples-to-apples study of OpenCode, T3 Code, and Hermes Agent under those conditions.
Until that evidence exists, the star counts prove attention and the product pages prove intent. They do not prove reliability. The harness is not a scapegoat because it is irrelevant. It is a scapegoat because it is the part people can see.
Open Source Does Not Mean Free or Safe
OpenCode may be free software while the model tokens still cost money. Hermes can run on a local machine, VPS, container, or cloud backend, but someone still has to manage the machine, credentials, updates, and network exposure. T3 Code can be open while sending work through closed agents and proprietary APIs.
Open source also does not guarantee that data stays local. A harness can keep its code and some state on a user's machine while sending source files, prompts, or memory to a hosted model provider. Persistent memory can hold sensitive project information. MCP servers, browser tools, and shell access create additional paths for mistakes or exfiltration.
The license gives users the right to inspect, modify, and redistribute the software. It does not provide isolation, a security audit, a reliable model, or a rollback plan. Those still have to be built and operated.
That is not an argument against open-source agents. It is the price of owning the stack. A managed product hides more of the operational burden. An open harness gives users the ability to decide how that burden is handled.
The Part Open Source Can Keep
OpenCode makes the model swappable. T3 Code makes the agent controllable. Hermes makes the work persistent. None of them proves that open source has solved agent reliability, and none of them removes the cost of model inference or system maintenance.
They do establish a more useful direction for the category. The model is one dependency. The runtime around it is where workflows accumulate, failures become inspectable, and user control can compound.
The model gets rented by the token. The harness is what users can keep.
Previously on TheQuery: