Why Agent Harnesses Should Be Open
Watch what happens to any piece of software once everyone starts building on top of it. It gets opened up. Not because engineers are idealists, but because the alternative stops making sense. The OS running the internet's servers is open. The engine inside almost every browser is open. The thing that packages and runs containers is open, down to the spec it follows. The pattern is evident by now: the layer everyone depends on becomes the layer everyone can see.
Agents just grew one of those layers. It's called the harness, and the case for an open agent harness is the same case that opened every layer before it.
The harness is the runtime the model lives in. It reads what the model says, does it, hands back the result, and goes again until the job is done. Everything an agent can do that a bare model can't lives in the harness, not the model: run code, call a tool, remember what it did three steps ago, stop itself before it wires money somewhere. The model thinks. The harness makes the thinking count.
How much does the harness matter? The same model, in a better harness, can swing scores by double digits and cut token cost by roughly half on identical tasks. NVIDIA measured exactly that: an open harness hitting 82.2% on SWE-bench Verified at about half the tokens of the harness it beat.
That makes it the most important layer in your agent. And the most important layer shouldn't be a box you're not allowed to open. Here's the case.
Infrastructure in the critical path goes open
Look at where the closed versions ended up. Proprietary Unix owned the server room, then lost it to Linux and never got it back. Closed browser engines faded; the open ones now render basically every page you read. Container runtimes, and the orchestration stacked on top, are open the whole way down to the standard.
It keeps happening for one reason. Once a layer becomes the ground everyone stands on, and the place the hard engineering piles up, a version you can read, change, and run yourself beats one you rent. Put the two side by side and the pressure is obvious:
The timing tilts the table further. The top models are bunching up. Give them the same hard task and the gap is small and shrinking. Whatever used to separate one agent from another has slid out of the model and into the layer wrapped around it. And the open versions of that layer aren't the toy editions: open harnesses are already topping the coding and security leaderboards against closed systems.
Standards don't survive in a black box
Agents get interesting the moment they stop being islands: sharing tools, calling each other, carrying a skill from one place to the next. That's the whole point of MCP, of the agent-to-agent protocols people are reaching for, of a portable skills format. None of it holds up without open implementations at the exact layer where the connecting happens.
The people who built these protocols already know this. Anthropic didn't keep MCP as a Claude feature. They published it, handed it to the Linux Foundation, and now OpenAI, Google, and half the tooling ecosystem speak it. That's what a real standard costs: you give up control of the layer so everyone can build on it.
Close the harness and you undo that at the one layer where it matters most. The ecosystem splinters into vendor islands, everyone quietly rebuilding the same plumbing where no one else can see it. Every platform era before this one climbed out of that mess the same way: the bottom layer opened, and the standards finally stuck.
You answer for what it does
When an agent breaks something in production (bills the wrong account, deletes the wrong row, leaks a field it never should have touched), you take the call. Not your harness vendor. Carrying the blame for behavior you can't inspect or change is a bad place to stand, and it's exactly where a closed harness puts you: full responsibility for your most autonomous software, zero ability to see how it makes up its mind. No serious team should sign that. No regulated one can.
We'll be straight about the limit. Open source doesn't make everything go away. Run enough agents and you've still got credentials sprawled everywhere, budgets you can't cap per team, guardrails to enforce, one audit trail to hold together. Real problem, real business. But it sits on top of the harness. It's not a reason to weld the harness shut. Watch for the bundle: lock the runtime so someone can sell you the governance. Don't take that deal. Keep the harness open, and buy the rest the day you actually need it.
So we built an open agent harness
We believe this enough to have shipped it. TrueForge is our open agent harness, MIT-licensed. It's the real production thing, not a demo with the interesting parts taken out: sandboxed execution, context engineering, subagents, human approvals, MCP tools, and a UI, all running on your own infrastructure.
Because it's the layer under everything else, it's all yours. Read it. Run it on your own metal. Fork it the day our judgment and yours part ways. It takes any model, and because it's tuned to spend fewer tokens a turn, it runs the same agent at less than half the cost of Claude Managed Agents. When you need governance across teams, it's there through TrueFoundry's AI Gateway, and not a moment before you ask for it.
One npx command and it's running locally, UI and all. Docker Compose and Kubernetes when you want to host it properly. We're shipping this early and in the open on purpose. Clone it, build something valuable, and shape its future.