AgentForge: An Agent Workflow Orchestration Framework for Production Environments

AgentForge is an open-source intelligent agent workflow orchestration framework designed for production environments. It uses YAML to define processes, supports hybrid orchestration of deterministic tools and non-deterministic LLM calls, and includes built-in approval gates, multi-node scheduling, and real-time dashboards. Its core goal is to enable agent applications to have production-level reliability.

As LLM-based agent applications move from experimental prototypes to production deployment, developers face challenges in orchestrating multiple agents, tools, and human reviews to build reliable, observable, and scalable workflows. Existing solutions have core issues: weak orchestration capabilities (lack of native multi-step support), insufficient reliability (difficulty reconciling LLM's non-deterministic outputs with production's deterministic requirements), limited scalability (high migration cost from local prototype to distributed deployment), and poor observability (lack of unified execution tracking, state management, and manual intervention mechanisms). AgentForge is designed to solve these pain points.

Design Philosophy: AgentForge proposes the "Harness" concept—an agent is a named flow of steps where tool calls are first-class citizens. It supports mixing deterministic and non-deterministic steps (llm, script, validate, transform, loop/condition) in YAML, allowing LLM to "propose" and tools to "rule" (blocking bad outputs). It uses declarative process definitions via YAML (e.g., code generation flow with loop and condition steps).

Architecture: Separates control plane (process/gate controller, scheduler, storage, event bus, dashboard server) and execution plane (local processes, Docker containers, remote nodes with capability declarations). This allows smooth scaling from single machine to distributed deployment.

• Approval Gates: Native support for inserting human review points at key nodes (approve, reject, revise).
• Multi-Model Support: Plug-and-play for mainstream LLMs (Anthropic, OpenAI, Gemini, Ollama) with extensions for custom models.
• Cost Control: Built-in cost caps, multi-worker scheduling, real-time dashboards for cost observability.
• Reference Templates: Ready-to-use templates like simple-sdlc, api-builder, code-review, content-generation, data-pipeline.

• Single Machine Mode: A Node.js process runs both control and execution planes with SQLite storage. Start dashboard via npx @mandarnilange/agentforge dashboard.
• Docker Mode: Use docker compose up -d (dashboard at port 3001).
• Production Mode: Supports PostgreSQL persistence, OpenTelemetry tracking, Docker isolation, and multi-worker horizontal scaling (control plane is single copy, execution plane scalable).

AgentForge's domain-agnostic design applies to multiple scenarios:

• Software Development: Full SDLC (code generation, review, testing, fixing).
• Content Production: Multi-step content generation, review, publishing workflows.
• Ops Automation: Standardized ops scripts mixing script execution and LLM decisions.
• Data Processing: Complex data pipeline orchestration and monitoring. Any scenario needing coordination of multiple LLM calls, tool executions, and human reviews can use AgentForge.

Compared to LangChain and AutoGen, AgentForge's unique value lies in:

• Production-First: Designed from the start for reliability, observability, and cost control.
• Tools as First-Class Citizens: Not附属 to LLM but core parts of the process.
• Declarative Configuration: YAML definitions lower entry barriers while retaining programming extensibility.
• Enterprise Features: Out-of-the-box approval gates, cost caps, multi-tenant scheduling.

AgentForge represents an important step in agent frameworks' evolution toward production environments. It goes beyond "enabling LLM to call tools" to "making LLM applications run reliably in production". For teams exploring agent application deployment, AgentForge offers a low-code entry experience and scalable architecture. As agent apps move from experiments to production, such engineering-rigorous frameworks will play an increasingly important role.