Stoneforge Agent Orchestration Platform

As of March 2026, several notable open-source AI coding agents exist, each serving different developer needs. Use this summary to choose an agent based on your workflow:

• OpenCode: A Go-based terminal agent supporting 75+ models. Features 'Build' (full access) and 'Plan' (read-only) modes. Best for model flexibility and local model privacy.
• Aider: A terminal agent with deep Git integration. It builds a repository map and auto-commits changes with descriptive messages. Best for maintaining clean, reviewable Git histories.
• Cline: A VS Code extension with 'Plan' and 'Act' modes. It features deep Model Context Protocol (MCP) integration and requires explicit permission for actions. Best for human-in-the-loop editor workflows.
• OpenHands: A platform/framework for building agents with sandboxed execution and multi-agent collaboration. Best for custom agent workflows and security-conscious environments.
• Continue: An IDE extension (VS Code/JetBrains) focusing on code completion and source-controlled AI checks that can run in CI. Best for embedding AI into existing IDE workflows.
• Goose: A terminal agent built by Block that uses MCP servers to extend its capabilities (file ops, terminal, browser). Best for extensibility via the MCP ecosystem.
• Plandex: Focused on large, multi-file tasks. It accumulates changes in a sandbox for review before applying them and supports plan branching. Best for large refactors.
• Void: An open-source VS Code fork providing a Cursor-like experience with local configuration and no telemetry. Best for developers wanting an AI-native editor without proprietary lock-in.

Stoneforge is an orchestration layer designed to manage multiple AI coding agents working in parallel on the same codebase. Unlike standalone agents, Stoneforge handles the operational complexity of scaling AI work across a team.

Core Functions

• Task Dispatching: Assigns tasks to specific worker agents.
• Git Worktree Isolation: Ensures each agent operates in its own isolated worktree to prevent conflicts.
• Context Handoff: Manages the transfer of context between different agent sessions.
• Merge Coordination: Coordinates the merging of changes produced by different agents.

Agent Roles

The system operates using a role-based model:

• Director: Plans the tasks and orchestrates the workflow.
• Workers: Execute the assigned tasks.
• Stewards: Review the work produced by workers.

Supported Worker Agents

Stoneforge currently supports the following as worker agents:

• Claude Code
• Codex CLI
• OpenCode

Stoneforge is not a standalone coding agent, but an orchestration layer designed to manage multiple AI agents working in parallel on the same codebase.

While individual agents (like Claude Code, Codex CLI, or OpenCode) handle specific tasks, Stoneforge manages the coordination overhead that occurs when scaling AI development. It automates task dispatching, monitors progress, handles retries, and manages the merge queue.

Key Capabilities:

• Agent-Agnostic Orchestration: Dispatches tasks to various supported agents.
• Git Worktree Isolation: Isolates agent work in separate worktrees to prevent conflicts during execution.
• Dependency-Aware Scheduling: Tracks dependencies between tasks to prevent wasted work.
• Role-Based System: Uses a structured hierarchy of Directors (task assignment), Workers (execution), Stewards (review/merge), and Daemons (automatic dispatch).

Best for: Teams where coordination between multiple parallel AI agent sessions has become a bottleneck, specifically when managing manual merge conflicts and task juggling.

Stoneforge agents operate within isolated git worktrees in a multi-agent orchestration system. Performing a checkout of a main branch will detach the main workspace from master, breaking the orchestration system for all agents.

Critical Restrictions

• NEVER run git checkout master, git checkout main, or git switch master/main.
• NEVER run git checkout origin/{{baseBranch}} (this detaches HEAD in your worktree).

Recommended Read-Only Commands

If you need to inspect the state of the base branch without switching branches, use these commands:

• Read a file from the base branch: git show origin/{{baseBranch}}:<path/to/file>
• Diff against the base branch: git diff origin/{{baseBranch}}..HEAD or git diff origin/{{baseBranch}} -- <file>
• Check for a specific commit in the base branch: git branch --contains <commit> --list {{baseBranch}}

If a branch switch is absolutely necessary, create a temporary branch instead: git branch temp-{{baseBranch}}-test origin/{{baseBranch}} && git checkout temp-{{baseBranch}}-test

# Read a file without switching
git show origin/{{baseBranch}}:<path/to/file>

# Diff against base branch
git diff origin/{{baseBranch}}..HEAD

# Create a temporary branch for testing
git branch temp-{{baseBranch}}-test origin/{{baseBranch}} && git checkout temp-{{baseBranch}}-test