Forge: Local-First Multi-Agent Programming Runtime for Autonomous AI Development

In an era where AI-assisted programming tools are becoming increasingly popular, most developers still face a core dilemma: either rely on cloud services and sacrifice privacy, or use local tools with limited functionality. Forge was created to resolve this contradiction—it is a truly local-first, plan-first multi-agent software engineering runtime that allows you to enjoy an agent programming experience comparable to Claude Code or OpenAI Codex while maintaining full control over your data. It offers 18 sandbox tools, support for 6 model providers, a complete REPL, and a UI dashboard—with no telemetry and no vendor lock-in.

Project Background & Design Philosophy

Forge's core philosophy can be summed up in one sentence: "Not an assistant, but a runtime." Unlike those "black-box" tools that perform model inference in the cloud and only show users the final results, Forge brings the complete scheduler, sandbox environment, permission system, state machine, agent loop, memory layer, and plugin ecosystem to the local side. The model you choose is fully under your control—every operation requires your approval, and the entire process is inspectable and replayable. This design philosophy stems from a respect for developers' autonomy. In the current AI programming tool ecosystem, users are often forced to compromise between convenience and privacy. Forge aims to prove that these two are not mutually exclusive—through its carefully designed local architecture, you can gain powerful AI-assisted capabilities while maintaining full control over your data and processes.

Core Architecture Analysis

Multi-Agent Collaboration System

Forge has six built-in professional agents, each with clear responsibility boundaries:

• Planner: Responsible for decomposing complex tasks into executable subtask sequences
• Architect: Designs code structures and system architecture solutions
• Executor: Performs specific coding and file operations
• Reviewer: Conducts quality checks on code changes
• Debugger: Diagnoses and fixes runtime errors
• Memory: Manages cross-session context and knowledge accumulation

Task State Machine & Execution Loop

Forge uses a strict state machine to manage the task lifecycle. Each task goes through clear state transitions from creation to completion: pending, planning, executing, reviewing, completed, or failed. This state design allows long-running complex tasks to be safely interrupted and resumed, and provides a clear coordination mechanism for multi-agent collaboration. The execution loop uses an iterative tool call pattern. At each step, the Executor agent evaluates the current state, selects appropriate tools (such as file reading, code editing, command execution, etc.), observes the results after execution, and then decides the next action. This "observe-think-act" loop pattern is highly consistent with human programming thinking.

Multi-Layer Memory System

To enable agents to "learn", Forge has a layered memory architecture:

• Working Memory: Context of the current session, including recent conversations and file operations
• Short-Term Memory: Relevant knowledge and conventions of the current project
• Long-Term Memory: Cross-project general programming patterns and best practices

This layered design allows the system to focus on the current task while using accumulated experience to make more informed decisions.

Tool Ecosystem & Model Support

Forge provides 18 built-in sandbox tools covering all aspects of software development:

File & Code Operations: read (file reading), write (file writing), edit (file editing), grep (code search), glob (file matching)

Environment Interaction: run_command (command execution), git (version control operations), web (network requests)

Development Assistance: code analysis, dependency checking, test running, etc.

All tools run in a sandbox environment to ensure security. More importantly, Forge supports automatic detection and adaptation of 6 model providers: Ollama, LM Studio, vLLM, llama.cpp, OpenAI-compatible interfaces, and Anthropic. This means you can flexibly choose local models or cloud APIs based on task requirements, privacy needs, or performance considerations. The system also has built-in classification support for 41 model families, including mainstream open-source models like Llama, Qwen, DeepSeek, Gemma, Phi, Mistral, and Codestral—ensuring that the model you choose is correctly identified and optimized for use.

Usage Modes & Workflows

Forge offers 9 preset working modes to adapt to different development scenarios:

• fast: Minimizes planning and executes directly—ideal for simple tasks
• balanced: Moderate planning and execution—first choice for daily development
• heavy: Detailed planning and multi-round reviews—suitable for critical code changes
• plan: Generates execution plans only, no actual execution
• execute: Strictly follows existing plans
• audit: Focuses on code review and security checks
• debug: Focuses on problem diagnosis and fixing
• architect: Focuses on high-level design and architectural decisions
• offline-safe: Runs completely locally, prohibits any external requests

This flexible mode switching allows Forge to adapt to various scenarios from rapid prototyping to production-level development.

Technical Highlights & Performance Metrics

Forge demonstrates a high level of engineering excellence in its technical implementation:

Startup Performance: Cold start of "forge doctor" takes only 173ms, and "forge --help" takes 238ms—this is top-tier for Node.js CLI tools.

UI Design: The built-in Web UI is only 90KB (uncompressed) and does not rely on CDNs at all, meaning the graphical interface can be used normally even in offline environments.

Containerization Support: Provides a multi-architecture container image of approximately 355MB, runs as a non-root user, has built-in health checks, and is suitable for CI/CD integration.

Test Coverage: Has 548 test cases distributed across 97 test files, all passing, with an execution time of about 5.5 seconds—reflecting the project's emphasis on quality.

Key Application Scenarios & Value Proposition

Forge is particularly suitable for the following scenarios:

Privacy-Sensitive Development Environments: For teams handling sensitive code or data, Forge offers a fully local running option, eliminating the risk of data leakage.

Customized AI Workflows: Through the plugin system and programmable instruction sets, teams can build exclusive AI development assistants that comply with their own specifications.

Offline or Network-Restricted Environments: In scenarios like aviation, military, or certain enterprise intranets, Forge's offline capability ensures that development efficiency is not affected.

Model Experimentation & Comparison: Supports multiple local and cloud models simultaneously, making it easy for developers to compare the performance of different models on specific tasks.

Education & Research: Its open-source architecture and transparent execution process make it an ideal platform for studying the working principles of AI programming assistants.

Summary & Future Outlook

Forge represents an important trend: AI programming tools are evolving from "cloud-based black boxes" to "local transparent runtimes". It proves that developers don't have to choose between "convenience" and "control"—through careful architectural design, both can be achieved. For developers who pursue data sovereignty, need deep customization, or work in special environments, Forge offers an attractive option. Its value lies not only in its functions but also in the concept it advocates: AI should be an enhancement tool for developers, not a replacement or constraint. As the capabilities of local large language models continue to improve, local-first runtimes like Forge will become increasingly important. It shows us a future where every developer can have a fully owned, trustworthy AI programming partner.