Who trueforge is for#
LLMOps engineers building reusable agents
TrueForge gives LLMOps engineers a production agent runtime they can deploy once and reuse across multiple agents. The Agents Library in the chat UI stores named agents with their model, MCP connections, and skills. The HTTP API and TypeScript SDK let engineers automate agent creation and session management from CI pipelines or internal tooling.
Skip if:
Your workflow is primarily prompt engineering and evaluation rather than building a persistent, tool-using agent runtime. Evaluation-focused platforms like Vellum are a better fit for that use case.
Platform teams standardizing on shared agent infrastructure
Hosted mode supports multiple replicas behind a load balancer, with Redis peering replicas so streams and cancellations route correctly across instances. Teams that want a single internal endpoint for all agent workloads can deploy TrueForge as shared infrastructure and let product teams connect via the SDK or API.
Skip if:
Your organization is committed to a specific cloud provider's ecosystem. Managed platforms like Microsoft Copilot Studio or Google Gemini Enterprise Agent Platform integrate more deeply with their respective cloud environments.
Individual developers wanting a self-hosted AI assistant
Local mode runs with a single npx command, stores data in a local SQLite file, and serves both the agent API and the chat UI on the same port with nothing extra to deploy. The experience is similar to Claude Desktop but backed by an open-source server you can inspect and modify.
Skip if:
You want a managed experience with no server to run. A managed agent product is a simpler path for personal use where self-hosting is not the goal.
Teams building AI chat products for their users
The embeddable UI SDK (@truefoundry/trueforge-ui) lets teams theme the TrueForge chat interface and embed it in a React application, backed by their own TrueForge server. The bundled agent features including skills, MCP tools, and subagents are available in the embedded UI without additional implementation.
Skip if:
You need a fully custom chat UI with fine-grained control over every rendering detail. The UI SDK is customizable by theme, but building entirely custom conversation rendering requires using the raw API instead.
The problem it solves#
Building a basic agent loop takes an afternoon. Building one that runs reliably in production takes months. A working agent needs streaming responses, session state that survives reconnects, a secure sandbox for code execution, a way to route tool calls to MCP-compatible servers, and human approval checkpoints for sensitive actions. Without dedicated infrastructure for each of these concerns, teams either bolt them on piecemeal or reach for a commercial platform that handles it for them.
Commercial agent platforms like Microsoft Copilot Studio, Google Gemini Enterprise Agent Platform, and Vellum solve the infrastructure problem but introduce another: vendor lock-in, opaque pricing, and no ability to inspect or modify the execution environment. You cannot self-host them, and you pay for every agent run. Teams with compliance requirements, cost sensitivity, or the need to customize the runtime are poorly served by managed-only platforms.
How it solves it#
Agent execution loop server
The TrueForge server runs the full agent loop: planning the turn, calling the model, executing tools, streaming every step back to the client, and persisting session state. Conversations survive reconnects and restarts because all session data is written to SQLite (local mode) or Postgres (hosted mode). You configure model providers and MCP servers once; the server orchestrates them on every turn.
MCP tool integration with header and OAuth auth
Connect any MCP-compatible tool server, including remote servers that require header-based auth or OAuth. In-chat authorization lets the agent request credentials during a session rather than requiring pre-configuration. Tool routing and execution are handled by the server, so callers do not need to manage tool state directly.
Sandbox provisioned as a tool on demand
Code execution runs inside an isolated sandbox (Daytona), provisioned only when the agent actually needs to execute code. Turns that stay in the reasoning-and-tool-call loop skip sandbox setup entirely, which keeps non-code turns fast and allows one server to run many concurrent agent sessions. Secrets stay in the harness and are not exposed to the sandbox.
Human approval checkpoints in the agent loop
The agent can pause any turn to request human approval before executing a sensitive tool call, ask the user a clarifying question, or render a Generative UI component inline in the chat. These checkpoints are defined per-agent and can apply to any tool. The chat UI surfaces approval prompts directly in the conversation stream.
TypeScript SDK and embeddable React UI SDK
Everything the server exposes is available via a REST API with Server-Sent Events for streaming. The TypeScript SDK (@truefoundry/trueforge-core) wraps the API for creating sessions, sending turns, and receiving streamed events. The UI SDK (@truefoundry/trueforge-ui) is a React component library for embedding a themed agent chat interface in your own application.
Local and hosted deployment modes
Local mode runs as a single process with SQLite, started with one npx command, requiring no extra infrastructure. Hosted mode uses Postgres and Redis, runs as multiple replicas behind a load balancer, and supports Docker Compose or Helm. The agent feature set is identical in both modes; only the backend storage and scaling topology differ.
Strengths and trade-offs#
Strengths
- MIT license with full self-hostingThe entire codebase is MIT licensed, so you can run TrueForge on your own infrastructure with no licensing fees, fork it for customization, and use it commercially without restriction. Unlike managed agent platforms that keep the runtime proprietary, the full execution environment is open and inspectable.
- Bring-your-own model providerTrueForge connects to any OpenAI-compatible API endpoint, including OpenAI, Anthropic Claude, and Google Gemini, plus any self-hosted model served over the OpenAI-compatible protocol. You are not tied to a single provider, and you can switch models per-agent or per-session by changing the configuration.
- Session state persisted across restartsThe server writes sessions to the configured database (SQLite or Postgres), so conversations resume correctly after server restarts, client reconnects, or network interruptions. This is built into the harness rather than left as an implementation detail for callers.
- Concurrent agents without per-session sandbox overheadBecause the sandbox is provisioned on demand as a tool rather than allocated per session, the server can run many concurrent agent sessions without pre-allocating a sandbox instance for each one. Sessions that stay in the reasoning-and-tool-call loop incur no sandbox cost.
Trade-offs
- -Local mode is not hardened for production useLocal mode runs with SQLite, a single process, and no login by default. The README states it is not hardened for production or shared internet access, and the TrueForge team cannot take responsibility for data loss or unauthorized access if local mode is exposed beyond localhost. Team and production use requires hosted mode with Postgres, Redis, and login enabled.
- -Sandbox support limited to Daytona todayThe sandbox provider is currently Daytona, with additional providers listed as planned but not yet available. Teams with existing sandbox infrastructure on a different provider cannot swap it in until additional providers are implemented.
- -Very young codebaseTrueForge was created in July 2026 and has 1,897 GitHub stars and 27 open issues as of August 2026. The project is actively developed with frequent commits, but it is a young codebase. Teams evaluating it for critical production workloads should factor in maturity alongside the feature set.
trueforge vs alternatives#
TrueForge vs Microsoft Copilot Studio
Microsoft Copilot Studio is a low-code platform for building agents on Microsoft's cloud infrastructure. It offers pre-built connectors to Microsoft 365 services, enterprise identity integration, and a visual flow builder, but runs exclusively on Azure with no self-hosting option.
| Feature | TrueForge | Microsoft Copilot Studio |
|---|---|---|
| License | MIT | Proprietary |
| Self-hosting | Yes (SQLite or Postgres) | No |
| Model providers | Any OpenAI-compatible | Microsoft Azure OpenAI |
| Pricing | Free (infrastructure cost only) | Per-message billing |
Copilot Studio is the better choice for organizations already on the Microsoft 365 stack who need its enterprise connectors and Azure Active Directory integration out of the box. TrueForge is the better choice when you need model flexibility, data ownership, or the ability to inspect and modify the agent runtime itself.
TrueForge vs Vellum
Vellum is a managed LLM workflow and agent orchestration platform with a visual workflow builder, prompt versioning, and evaluation tooling. It handles infrastructure for you with no self-hosting option.
| Feature | TrueForge | Vellum |
|---|---|---|
| License | MIT | Proprietary |
| Self-hosting | Yes | No |
| Pricing | Free (infrastructure cost only) | Usage-based billing |
| Evaluation tooling | Not included | Built-in |
Vellum's built-in evaluation and prompt management tooling give it an edge for teams that want a managed product with no DevOps overhead and a visual interface for prompt iteration. TrueForge is the better fit for teams that need to self-host for compliance or cost reasons, or who need to extend the agent runtime rather than configure it through a UI.
TrueForge vs Google Gemini Enterprise Agent Platform
Google's managed agent platform offers tight integration with Gemini models, Google Workspace connectors, and enterprise identity. Like Copilot Studio, it is a managed service with no self-hosting option.
TrueForge supports Google Gemini as a bring-your-own model provider, so you can use the same models without running on Google's agent infrastructure. The key tradeoff is setup versus control: Google's platform requires no infrastructure management, while TrueForge requires a server but gives you full ownership of the runtime, the session data, and the execution environment. Google's platform is the better choice when deep integration with Google Workspace is a hard requirement.
Install and self-host#
Run the server locally for personal use or deploy with Docker Compose for team deployments; install the TypeScript SDK to drive agents from your own code.
```bash
npx @truefoundry/trueforge
npm install @truefoundry/trueforge-sdk
```What it's built on#
- Languages
- JavaScriptPythonTypeScript
- Frameworks
- React
- Cache
- Redis
- Tooling
- Webpack
FAQ#
Is TrueForge free to use?
Yes. TrueForge is MIT licensed and free to self-host. The npx local mode requires no account and no licensing payment. Hosted mode adds Postgres and Redis as infrastructure requirements but carries no software licensing cost. There is no managed cloud tier or per-request billing in the open-source project.
What model providers does TrueForge support?
TrueForge supports OpenAI, Anthropic, and Google Gemini from the built-in catalog, plus any OpenAI-compatible API endpoint. You configure providers in the server setup and agents pick from what you have connected. There is no requirement to use a single provider across all agents.
How does TrueForge differ from building an agent with a custom loop?
TrueForge is a complete agent runtime, not a library. It provides the server, session persistence, streaming infrastructure, sandbox integration, human approval checkpoints, and a bundled UI. A custom loop requires implementing all of those concerns separately. TrueForge is the better fit when you want a production-grade runtime out of the box; a custom loop is better when you need fine-grained control over every step of the execution model.
Can I run TrueForge on Kubernetes?
Yes. Hosted mode ships a Helm chart for Kubernetes deployments. The chart handles the Postgres and Redis dependencies and supports multiple replicas with Redis peering so streams and cancellations route correctly across instances.
What is the difference between local mode and hosted mode?
Local mode runs as a single process with SQLite, no login by default, started with npx. It is designed for personal use on your own machine and should not be exposed to the internet. Hosted mode uses Postgres and Redis, supports multiple replicas, and enables login via OIDC. The agent feature set is identical in both modes; only the backend storage and scaling topology differ.
Similar open-source tools#
agency-agents
Expert AI agent personalities for every workflow
page-agent
AI-powered GUI Agent for your website
GenericAgent
Autonomous agent that evolves skills over time
Node-RED
Low-code event-driven programming with a browser-based editor
Automatisch
Self-hosted Zapier alternative for workflow automation
Huginn
Self-hosted agents that watch the web and trigger automations