TrueForge: Anthropic's Managed Agent Harness, But Open Source

Agent Loop vs. Agent Harness: Building Production-Ready AI Agents

This video examines the critical distinction between a basic agent loop and a full agent harness, using the open-source project True Forge as a concrete example. The presenter argues that while a minimal loop is trivial to build, production-grade agents require extensive scaffolding to handle context limits, failures, security, and long-running tasks.

The Basic Agent Loop and Its Limits

A naive agent loop can be written in 15 lines of Python: the model requests a tool, the tool is called, output is appended to the prompt, and the cycle repeats. This works for simple prompts of two or three turns, but collapses under real production workloads due to two primary failure modes:

• Context window overflow: Models lack persistent memory, so every turn replays the entire history. As the window fills, the signal-to-noise ratio diminishes, causing reasoning capability to degrade. > “The longer an agent run, the dumber it’s going to get.”
• Missing infrastructure: External API drops, retries, state persistence across long sessions, and security (e.g., preventing a model from dropping a database table) are absent from the basic loop.

The Harness: Scaffolding for Production

A harness wraps the loop with retries, backoffs, isolated code sandboxes, human-in-the-loop approvals, and aggressive context management. Building the loop is easy; building a good harness is very difficult.

Key Architectural Patterns in a Harness

• Deferred schema loading: Instead of loading all tool schemas upfront (burning thousands of tokens), pass only server names and a few tiny meta tools. The model discovers schemas on demand, trading upfront token cost for increased latency.
• File offloading: Stream raw API responses to disk inside the sandbox, feed the model only a tiny preview and local file path, and let the agent use bash tools to grep exact traces. This saves tokens and keeps signal high.
• Code mode: The agent writes a concise Python script that runs in the sandbox; tool calls inside the script are bridged back to the harness. Only the final result is returned, avoiding context burn on raw JSON and sloppy mental math.
• Sandbox as a tool: Keep the core loop on your server and treat execution environments as ephemeral tools—spin up on demand, tear down immediately. This prevents production tokens from leaking into the execution environment.
• Subagents and compaction: For long tasks, spin off a subagent with a fresh window for noisy research, reporting only a distilled answer. Alternatively, use compaction: a background model summarizes old turns when a token threshold is hit, though this is fundamentally lossy.

True Forge: An Open-Source Harness Example

True Forge (MIT licensed) is a vendor-agnostic harness that ships all these patterns natively. It supports any OpenAI-compatible API, including local models, and is a production server with an HTTP interface, built-in dashboard, and agent runtime. It claims up to 75% lower cost compared to cloud-managed agents.

The demo shows building a research agent (using XAR for web search and a local Qwen model) and an on-call agent for a checkout API with an MCP server exposing 8 tools. Read-only tools run automatically; destructive operations trigger human-in-the-loop approval via the UI. True Forge tracks all previous sessions and traces, helping developers debug tool schemas and improve agent design. Agents can also be scheduled at regular intervals.

Key Takeaway

The agent loop is trivial; the harness is what makes agents production-ready. True Forge provides a robust, open-source, model-agnostic implementation of best practices for context management, security, and scalability—making it a compelling alternative to proprietary cloud-managed agents.