Forge: An Open-Source, Self-Hosted Visual Builder for AI Agents

A Visual Agent Builder Built for Developers

As AI agent development heats up, the complexity of framework code often gets in the way of developers quickly validating ideas. Forge, an open-source project that recently surfaced on Reddit, aims to lower that barrier through a visual approach. It's a fully self-hosted AI agent builder licensed under MIT, letting developers assemble agents and workflows directly on a canvas — no framework-level code required to test and deploy.

Forge's core philosophy is to free agent development from tedious code orchestration. On the canvas, developers can wire together agents, tools, knowledge bases (RAG), and routing logic like connecting nodes, then test and ship directly. For teams that need rapid prototyping, this what-you-see-is-what-you-get approach can significantly shorten iteration cycles.

Observability: Full Visibility Into Every Run

Forge's observability design is worth highlighting. For every run, it provides a span waterfall that clearly shows token consumption, latency, and cost at each step. Developers no longer have to piece together scattered logs to figure out what a call cost — the entire execution chain is traceable in a single view.

This granular monitoring is especially important for keeping LLM call costs under control in production. Agent workflows often involve multiple model calls and tool interactions, and without observability, cost overruns and performance bottlenecks can be hard to pin down. By surfacing these metrics in the visual interface, Forge makes debugging and optimization considerably easier.

Trim Tool Output with JMESPath to Save Tokens

Forge offers a particularly practical feature: trimming tool output via JMESPath projection. In many scenarios, external APIs return large payloads, but only a small portion of that data actually needs to be fed to the model. Forge lets you extract just the relevant fields before data ever reaches the model.

According to the project's demo video, this mechanism can compress an API response from 10,034 tokens down to 51. Given that tokens directly affect call costs and context window usage, reductions of this magnitude matter enormously for high-frequency agent systems — cutting expenses while also reducing the risk of irrelevant information clouding the model's judgment.

What is JMESPath? JMESPath (JSON Matching Expression paths) is a query language designed specifically for JSON data. With concise syntax, it can precisely extract fields from complex nested JSON structures, supporting filtering, projection, and multi-level path access. Originally proposed by AWS and widely used in tools like the AWS CLI, it's now an independent specification. Rather than manually parsing JSON in code, JMESPath lets you declaratively describe "which fields I want" — for example, results[*].{name: name, price: price} extracts only the name and price fields from a list. In agent tool-calling scenarios, raw JSON from external APIs (weather, search, e-commerce, etc.) often contains metadata, pagination info, and redundant fields that waste tokens and introduce noise. Forge uses JMESPath as a filter layer in the data pipeline, letting developers fill in an expression in the visual interface to trim fields — no extra processing code needed.

Build Once, Deploy Anywhere

Forge's deployment flexibility covers multiple common production scenarios. A workflow built on the canvas can be exported directly as:

• A REST endpoint
• An MCP server
• An email handler
• An embeddable chat widget

This "build once, deliver everywhere" capability means the same agent logic can simultaneously serve API integrations, tool protocols, email automation, and frontend embedding — without rebuilding for each target.

What is an MCP server? MCP (Model Context Protocol) is a relatively new concept worth explaining. MCP is an open protocol proposed and championed by Anthropic in late 2024, designed to standardize how LLM applications communicate with external tools and data sources. Think of it as the "USB port" of AI tool calling — any tool that implements MCP can be called directly by any MCP-compatible client (such as Claude Desktop or Cursor), without custom adapters for each host environment. Forge's ability to export workflows as MCP servers means the logic can be invoked as a tool by any MCP-compatible AI client, dramatically expanding reusability and enabling natural integration into the growing MCP ecosystem.

Lightweight Deployment with a Flexible Stack

On the engineering side, Forge keeps the getting-started bar low. It runs by default on SQLite with an embedded Chroma vector store — no Docker or Postgres required — making local setup quick and painless. When the application scales and production-grade deployment is needed, a configuration switch to Postgres/pgvector and Redis provides a smooth upgrade path.

For model support, Forge is compatible with OpenAI, Anthropic, Google, and any provider supported by LangChain. The entire project is built on LangChain and LangGraph, giving it a solid foundation for ecosystem compatibility — developers can reuse familiar components without being locked into a single model vendor.

Why LangChain and LangGraph? Forge's choice of LangChain and LangGraph as its execution engine defines its capability boundaries and ecosystem position. LangChain is one of the most mature LLM application development frameworks available, offering rich tool integrations, memory management, and chain abstraction. LangGraph is its graph execution engine for multi-step, stateful agent workflows, supporting conditional branching, loops, and parallel nodes — well-suited for complex agent orchestration. Forge is essentially a visual interface built on top of LangGraph's graph execution capabilities; what developers wire up on the canvas gets translated into a LangGraph graph structure at runtime. This means Forge can directly reuse LangGraph's existing node types and tool ecosystem, while also inheriting its performance characteristics and known limitations. Developers already familiar with the LangChain ecosystem will find Forge's behavior model intuitive.

Open Source, No Limits, Community-Driven

Unlike many tools that offer hosted services with usage caps, Forge uses the MIT license with no hosted-service lock-in and no usage limits. For developers and organizations that value data sovereignty and want full control over their infrastructure, this is a clear differentiator. The source code is available on GitHub at nihalashetty/Forge, and the author is actively seeking community feedback.

Overall, Forge addresses several real pain points in today's agent development landscape: complex code orchestration, opaque call costs, and rigid deployment options. It responds with a visual canvas, fine-grained observability, and flexible deployment. That said, as a newly released open-source project, its stability under complex workflows, performance characteristics, and ecosystem maturity still need to be proven through real-world use. For developers looking to experiment with agent workflow construction at low cost, it's a project worth keeping an eye on.