Sam Altman made the case for open-source harnesses in July.

a month later, someone shipped it, and it’s more efficient than most managed harnesses.

here is the problem it was aimed at:

a large share of your agent’s token bill is the model rereading things it already read.

that isn’t the model’s doing. the runtime around it decides what goes into every prompt and how often the model gets called.

for example, an agent queries a CRM at step four and gets back 400 rows. those rows get piled up in the conversation history.

by step nineteen, the model has to read those rows fifteen times unnecessarily, and every token read is billed at input rates.

it happened because your harness assembled that prompt on every turn and kept the rows in it.

that gives you two levers: how much context the harness carries forward, and how often it calls the model.

there are four practical ways to keep the prompt from growing unnecessarily:

→ load tool schemas on demand. a server with 100 tools doesn’t need to put all 100 into every prompt when the agent only calls two.

→ offload large results to disk. turn a large response into a short preview and a file path instead of replaying the entire result on every turn.

→ delegate to subagents. let a subagent spend thirty tool calls in its own context and return one summary to the root agent.

→ run toolchains in code. one script calls three tools, joins the results, and returns a table instead of three turns each dragging a full response.

but reducing context is only half the job. you also need to control how often the model gets called.

a good harness should avoid unnecessary planning, verification, and reflection when the work can be completed in fewer steps.

@TrueFoundry’s open-source agent harness, TrueForge, is built around both of those controls.

it sits between the model and the tools, deciding what goes into every prompt and when another model call is actually needed. it also breaks token usage down across the harness, skills, instructions, tools, and messages.

DevRev’s Enterprise-Bench is where this gets tested, on multi-step tasks of the kind where an agent pulls records from one system and reconciles them against another.

TrueFoundry ran TrueForge there against Claude Managed Agents, both on the same model, and both finished the same number of tasks.

the tie is the part that matters, because it means the gap underneath is not a quality tradeoff.

TrueForge reached that score on close to a third of the tokens, with roughly 40% fewer trips back to the model. for the same result, that comes out around 2.7x cheaper than Claude Managed Agents.

swapping in an open model made it sharper still. TrueForge with GLM-5.2 scored a little higher than either setup above, and the entire benchmark run cost about $3 at list prices.

being open source matters beyond the license here. the model underneath can be swapped without rewriting the agent, and the whole thing can run inside your own environment when the data cannot leave it.

all of this comes down to the runtime around the model, the context it carries, the tools it exposes, and how many times it goes back to the model.

that is what a production harness actually owns.

the full task list, the per-run numbers, and the MIT-licensed code are on GitHub: http://github.com/truefoundry/trueforge…

(don’t forget to star )

you can read more about the same in the article quoted below.

thanks to the TrueForge team for working with me on this one.

truefoundry/trueforge

Source: https://github.com/truefoundry/trueforge

The open-source agent harness - the runtime layer that turns an LLM into a working agent

TrueForge

TrueForge runs the agent execution loop for you - model calls, MCP tools, skills, sandboxing, approvals, context management, and session state - and exposes it three ways: a chat UI, an HTTP API with a TypeScript SDK, and an embeddable UI SDK.

Why TrueForge?

Building an agent is easy. Running one well is not - you need streaming, session persistence, tool servers, sandboxing, approvals, and a UI. TrueForge gives you that out of the box:

• Initial setup from catalogs - configure models, MCP servers, skills, and a sandbox once; agents pick from what you connected. Presets come from shipped YAML catalogs you can customize.
• Any model provider - OpenAI, Anthropic, Google Gemini, and other catalog providers, or any OpenAI-compatible endpoint.
• MCP tools - remote MCP servers with header auth or OAuth, including in-chat authorization.
• Skills - git-backed SKILL.md instruction packs, loaded on demand in the sandbox.
• Sandbox as a tool - isolated code/file execution (Daytona today; more providers planned), provisioned only when needed. Secrets stay in the harness.
• Human checkpoints - tool approval, ask-user-questions, and Generative UI in chat.
• Context engineering - subagents, deferred tool loading, Code Mode, large-result offloading, and compaction.
• Chat UI + SDK - use the bundled UI, automate with @truefoundry/trueforge-sdk, or embed @truefoundry/trueforge-ui.

It scales down and up: local mode (one process, SQLite) or hosted mode (Postgres + Redis, Docker Compose or Helm).

Getting started

Run TrueForge (local, Docker Compose, or Kubernetes), connect a model and tools, and build your first reusable agent in the Quickstart.

To work on TrueForge from this repository, see CONTRIBUTING.md.

Architecture

Local mode is for your machine only. It is a convenient way to try TrueForge — not a production or internet-facing setup. There is no login by default, and data lives in a local SQLite file. Please keep it on localhost. We cannot take responsibility for data loss or unauthorized access if local mode is used beyond that. For a shared or production deployment, use hosted mode.

Documentation

Benchmarks

We compare TrueForge against Claude Managed Agents and deepagents on the same tasks, tools, and model - same accuracy, lower cost. Reproduce it from benchmark/. Write-up: Benchmarking.

Contributing

We love contributions - bug reports, features, and docs fixes. See CONTRIBUTING.md and our Code of Conduct. Fork PRs should change source only; maintainers regenerate the SDK after merge.

To report a security vulnerability, follow SECURITY.md instead of opening a public issue.

Talk to us

• Community Discord
• Founder emails: [email protected] / [email protected]

License

TrueForge is released under the MIT License.