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

TrueForge – an open‑source LLM‑agent runtime

What it is – TrueForge is a TypeScript‑based “agent harness”. It runs the execution loop for a language‑model‑powered agent: making model calls, invoking tools, managing sandboxed code execution, handling approvals, persisting session state, and exposing everything through three interfaces:

Chat UI – a ready‑made web interface.
HTTP API – a REST endpoint with an OpenAPI spec.
SDKs – TypeScript client (@truefoundry/trueforge-sdk) and embeddable UI component (@truefoundry/trueforge‑ui).

It is designed to let developers focus on the agent logic while TrueForge takes care of the plumbing.

Why use it?

All the plumbing in one place – streaming responses, session persistence, tool servers, sandboxing, human approvals, and context management are built‑in.
Pluggable resources – models (OpenAI, Anthropic, Gemini, or any OpenAI‑compatible endpoint), MCP tool servers, skill packs (git‑backed SKILL.md files), and sandbox providers (currently Daytona) are configured via YAML catalogs.
Scalable deployment – run locally with a single process and SQLite, or in a hosted setup using Postgres + Redis via Docker‑Compose, Helm, or Railway.
Cost‑effective – benchmarked to give the same accuracy as Claude Managed Agents and deepagents while using less compute.

Quick start (one‑liner)

npx @truefoundry/trueforge@latest

The command launches a local instance (SQLite, no external infra). Follow the on‑screen prompts or the quick‑start guide to connect a model, add tools/skills, and start chatting.

Core architecture (high‑level)

+-------------------+      +-------------------+      +-------------------+
|   Chat UI / SDK   | <--->|   TrueForge HTTP  | <--->|   Agent loop      |
| (web or embed)    |      |   API (REST)      |      | (model calls,    |
+-------------------+      +-------------------+      |  MCP tools,      |
                                                   |  sandbox, state) |
                                                   +-------------------+

Storage – SQLite for local mode; Postgres (plus Redis for caching) for hosted mode.
Resources – The agent loop reads the YAML catalogs to discover models, MCP servers, skills, and sandbox providers.
Sandbox‑as‑tool – Code runs in an isolated environment; secrets stay inside the harness.
Human checkpoints – Optional approval steps or “ask‑user” prompts before a tool is executed.

Getting started beyond the one‑liner

Mode	When to use	How to run
Local	Personal experimentation, prototyping	`npx @truefoundry/trueforge` (SQLite, no login)
Hosted	Team collaboration, multi‑replica, production‑like workloads	Deploy with Docker‑Compose, Helm chart, or Railway; configure Postgres + Redis

The docs cover:

Initial setup – configuring catalogs for models, MCP servers, skills, sandbox.
Creating an agent – selecting resources, enabling tool approval, adding generative UI.
Sessions & schedules – view past runs, set recurring agents.
Authentication – optional OIDC for shared deployments.
Benchmarking – reproduce cost/accuracy comparisons in benchmark/.

Installation & ecosystem

npm packages – @truefoundry/trueforge (CLI/server), @truefoundry/trueforge-sdk, @truefoundry/trueforge-ui, @truefoundry/trueforge-core.
Helm chart – published at tfy.jfrog.io/... for Kubernetes.
Documentation – https://trueforge.dev (intro, API reference, UI guide, etc.).

Community & contribution

Discord – https://discord.com/invite/fHeGRvakb
Issues / PRs – follow the standard GitHub workflow; after merging, maintainers regenerate the SDK.
Security – report via SECURITY.md.
License – MIT.

TL;DR

TrueForge gives you a production‑ready runtime for LLM agents: plug in any model, add tools/skills, let the harness handle sandboxing, approvals, and persistence, and interact via a web UI or TypeScript SDK. It works locally for quick tests or scales to Kubernetes for team use.

truefoundry/trueforge