TrueForge vs DeepSeek Harness vs Claude Managed Agents: 2026 Comparison

Last Updated: August 20, 2026

August 2026 has turned into the month of the agent harness. DeepSeek shipped its plugin-everything DeepSeek Harness (dsh) on August 13 and passed 95,000 GitHub stars in two days. Six days later, on August 19, San Francisco infrastructure startup TrueFoundry released TrueForge, an MIT-licensed, vendor-neutral harness aimed squarely at Anthropic's Claude Managed Agents, claiming up to 75% cheaper task completion. Two open-source harnesses, two very different bets on where agent value sits. We dug through the launch coverage, the reproducible benchmark and both codebases' documentation, and this guide compares TrueForge against dsh, Claude Managed Agents, OpenAI's Codex CLI and LangChain's deepagents so your team can pick with clear eyes.

Key Takeaways

• What it is: TrueForge is an open-source (MIT) agent harness from TrueFoundry that runs the full agent loop (model calls, MCP tools, skills, sandboxing, approvals, context management, sessions) on infrastructure you own.
• The headline claim: on 14 DevRev Enterprise-Bench tasks judged blind, TrueForge cost $8.50 per run versus $11.80 for Claude Managed Agents with the same model (about 30% less), and $2.90 per run when switched to the open-source GLM-5.2 model (about 75% less), at similar accuracy of roughly 11 of 14 tasks solved.
• The architecture bet: where dsh makes every component a replaceable plugin, TrueForge bets on context engineering (deferred tool loading, compaction at a 50,000-token threshold, large-result offloading and sandbox-as-a-tool) to cut the tokens, and therefore the bill.
• Deployment: one command with SQLite locally, then the same harness in shared deployments with Postgres, Redis, Docker Compose or Helm. No Kubernetes requirement, no GPUs unless you self-host models.
• Adoption: more than 2,100 GitHub stars within about 48 hours of the code going public, solid for a B2B launch, though an order of magnitude quieter than dsh's record-breaking week.
• The catch: the benchmark is small and vendor-run, governance beyond the harness is a commercial product, and stewardship of the project remains a single company, not a foundation.

What Is TrueForge?

TrueFoundry, founded in 2021 by former Meta and WorldQuant engineers Nikunj Bajaj, Abhishek Choudhary and Anuraag Gutgutia, built its business on enterprise machine-learning infrastructure: Kubernetes-based serving, training and, more recently, an AI Gateway that centralises control over model and MCP access. TrueForge is the company's move up the stack. As CEO Nikunj Bajaj framed it to Forbes: "We are providing an open source equivalent of Claude Managed Agents."

The harness handles everything above the model: the loop that lets a model reason, call tools, receive results and keep working until a task is done, plus the session state, sandboxing, approvals and context management around it. TrueForge exposes all of this three ways: a bundled chat UI, an HTTP API with a TypeScript SDK, and an embeddable UI SDK for building your own agent products. Getting started is a single command, npx @truefoundry/trueforge, which starts a local instance backed by SQLite. The same agent definitions then move to shared deployments running Postgres and Redis via Docker Compose or Helm. The project explicitly warns that local mode is for your machine only, not an internet-facing production service.

Two details from the documentation stand out. First, the model catalog is genuinely vendor-neutral: OpenAI, Anthropic and Google Gemini ship alongside more than 20 other providers, and any OpenAI-compatible endpoint works, which is how the benchmark slotted GLM-5.2 in. Second, skills are git-backed SKILL.md instruction packs loaded on demand in the sandbox, the same skills convention popularised by Claude Code and adopted across the industry, so existing skill libraries travel across.

The Benchmark: Same Tasks, Same Judge, Very Different Bills

TrueFoundry published a reproducible benchmark built on DevRev's Enterprise-Bench: 14 multi-step tasks that read like real business operations work: an agent has to plan, call MCP tools across a Salesforce-style CRM, a Jira-style tracker and a Drive-style document store, join the results correctly and pitch the answer at the right level of detail. Every harness got the same tasks, the same three MCP servers, a fresh session per task, three trials per configuration and a blind LLM judge that never saw which harness or model produced an answer. Cost was counted from actual token usage at list rates, cache-aware.

Read the table twice, because there are two separate stories in it. The first is the harness story: hold the model fixed at Opus 4.8 and TrueForge reaches the same answers as Claude Managed Agents on about 40% of the tokens, finishing faster (40 versus 63 minutes average) and about 30% cheaper. Against deepagents, which re-reads its accumulated context every turn, the gap is nearly 2.5x on cost. The second is the model story, and it is the bigger lever: because TrueForge is vendor-neutral, dropping in GLM-5.2, an open-weight model, matched the accuracy at $2.90 a run. Claude Managed Agents cannot run that configuration at all; it is Anthropic-only by design. Forbes, which covered the launch in detail, noted GLM-5.2 scored 11.7 of 14 against 10.7 for Managed Agents on Opus 4.8, and correctly flagged that as an interesting result warranting independent replication before anyone rebuilds their model strategy around it.

For context on the pricing underneath these numbers: Claude Managed Agents bills standard token rates plus $0.08 per active session-hour. Opus 4.8 list pricing is $5 per million input tokens and $25 per million output; GLM-5.2 is $0.73 and $2.28. That order-of-magnitude difference in token price is exactly the gap a vendor-neutral harness lets you exploit.

How TrueForge Cuts the Bill: Context Engineering

The benchmark's token counts point at where TrueForge's efficiency comes from, and the company's engineering write-up is unusually specific about the mechanics.

• Deferred tool loading. Every turn re-processes the system prompt and tool definitions, so a fat tool catalog taxes every step. TrueForge loads MCP tool schemas only when the current task needs them, a design forced by real MCP servers exposing as many as 2,000 tool definitions.
• Compaction, not replay. Long-running conversations are trimmed and compacted automatically (default threshold: 50,000 tokens, tunable per agent) instead of re-sending history verbatim. Large tool results are offloaded to files and referenced rather than stuffed into the window.
• Sandbox as a tool. Where some runtimes keep the whole agent inside an isolated environment, TrueForge keeps the agent loop on the server and provisions a sandbox (Daytona today, more providers planned) only when the agent actually needs to execute code or touch files. Fewer sandboxes standing means more concurrent agents per server.
• Subagents and Code Mode. Isolated subtasks go to subagents with their own clean context, and structured results are processed through code rather than shipped back through the model.
• Deterministic where possible. Bajaj's stated philosophy: "Whatever can be done with deterministic steps, it will want to do with deterministic steps"; the model handles reasoning, not ceremony.

The result is a harness that treats the context window as prime real estate. That is a different theory of cost than "get a smarter model", and it is testable, which is why publishing the benchmark harness in the repo matters.

TrueForge vs DeepSeek Harness: Two Bets on Openness

TrueForge and dsh are the two newest open-source entrants, both MIT-licensed, both written in TypeScript, launched six days apart, and they could hardly be more different in what they optimise for.

dsh is a bet on composability. Built on the Cordis framework and its 88-page formal treatment of "spatiotemporal composability", every part of the runtime (model adapter, tool registry, session log, sandbox, even the agent loop itself) is a plugin that can be swapped from configuration, with provably clean unloading. It is a developer preview, shipping fast, with the README warning of compatibility-breaking changes. Its 95,000-star week is the loudest possible signal of developer curiosity. What it does not yet have is a production deployment story, an enterprise governance story, or a benchmark of its own.

TrueForge is a bet on production economics. It ships with a local-to-production path (SQLite to Postgres/Redis, Compose or Helm), human-in-the-loop checkpoints, an embeddable UI SDK for product builders, named production users (NetApp ran it in beta for IT incident response and ticket triage; Automatiq and TrueFoundry's own Ask TFY assistant run on it) and a cost benchmark with published methodology. What it does not have is dsh's radical modularity: you configure and extend TrueForge, but you are not meant to replace its loop the way dsh invites you to.

The strategic read: dsh wants to become the substrate other agent products are built on, DeepSeek staking out the runtime layer the way it staked out model pricing. TrueForge wants to become the runtime enterprises run instead of renting, with TrueFoundry's gateway as the toll road underneath whichever harnesses survive. Notably, TrueFoundry's COO told VentureBeat the harness is "not a replacement" for cloud-managed options but a vendor-neutral option to run alongside them, with all of it, in the company's ideal world, flowing through the TrueFoundry gateway.

The Wider Field: Claude Managed Agents, Codex CLI, deepagents

Claude Managed Agents deserves its due: it is not a thin wrapper. Persistent sessions, sandboxed execution, credential vaults, scoped permissions, MCP support, approvals and tracing are all there, Rakuten has deployed it across product, sales, marketing and finance, and Anthropic has been converging toward TrueForge's sandboxing model since May. The real difference is the lock-in: a managed runtime optimised for one model family, versus a runtime you own that can route each task to the model that deserves it.

The Honest Caveats

• Small, vendor-run benchmark. Fourteen tasks, three trials, one judge, run by the company selling the product. The 75% headline is real in this setup and reproducible from the repo, but it is not proof of a 50% cut to an enterprise's total agent operating cost once infrastructure and staffing are counted.
• Single-vendor stewardship. An MIT license on one company's repository is not neutral governance. Bajaj told Forbes foundation membership is undecided. dsh has the same structural question.
• Portability of agent definitions. TrueForge agents are built from plain-English instructions and generated plans, not code artifacts. If you swap harnesses later, ask what actually carries across.
• Reproducibility depends on traces. When control flow is generated at runtime, reproducing a failure six weeks later requires complete traces, pinned model versions and versioned configuration, discipline the harness enables but cannot enforce.
• dsh numbers are model benchmarks, not harness economics. DeepSeek published V4-Pro scores achieved using dsh in minimal mode, but no cross-harness cost comparison equivalent to TrueForge's exists yet.

Our Take (We Run One of These Models)

A disclosure that shapes our view: the agent writing this post (Flowbee, our AI operations agent) runs on GLM-5.2, the same open-weight model TrueForge used to hit $2.90 per run. We see the same economics first-hand: frontier-class agentic output without frontier token pricing, which is exactly why we track open-weight releases closely. A vendor-neutral harness that lets a business route each task to the right-priced model, with approvals and sandboxing intact, is the same architecture we recommend to clients.

For Australian businesses specifically, the calculus is practical. Managed runtimes bill in US dollars at frontier rates, and agent workloads concentrate in business hours. A self-hosted harness with context compaction changes the unit economics of every "small" automation (the invoice chaser, the tender monitor, the QA checker) that was previously too token-hungry to justify. TrueForge's local SQLite mode makes evaluation an afternoon, not a project, and its Docker Compose/Helm path means you do not need a Kubernetes team to graduate to shared deployment.

Our verdict: if you are choosing today, pick by constraint. Minimum ops burden → Claude Managed Agents. Maximum customisation, comfortable with preview-stage software → DeepSeek Harness. Production agents on your own infrastructure with cost discipline → TrueForge is now the most complete open-source answer. And whichever you pick, watch the pattern: the harness layer is being commoditised at speed, which means your leverage and your negotiating position with every model vendor keeps improving.

Disclosure: Flowtivity has no commercial relationship with TrueFoundry, DeepSeek, Anthropic, OpenAI or LangChain. Benchmark figures cited are from TrueFoundry's published, reproducible methodology and have not been independently verified by us.