Federated Orchestration & Resource Generation Engine
Intelligent control panel for orchestrating AI coding agents across your workspace
FORGE is a terminal-based control panel that intelligently manages multiple AI coding agents (Claude Code, OpenCode, Aider, Cursor) across your workspace. It automatically distributes tasks to the right models based on complexity and cost, optimizes your AI subscriptions, and provides real-time monitoring through a beautiful TUI.
Think of it as Kubernetes for AI workers.
- Key Features
- Architecture
- Installation
- Quick Start
- CLI Setup Guide
- Configuration
- Documentation
- Troubleshooting
- Contributing
- License
- Spawn and manage multiple AI coding agents simultaneously
- Distribute work across different models and providers (Claude, GPT, Qwen, GLM, etc.)
- Real-time health monitoring with auto-recovery
- Support for tmux, subprocess, and Docker-based workers
- Worker pooling with automatic failover
- Smart model routing based on task complexity (0-100 scoring system)
- Maximize use-or-lose subscriptions before falling back to pay-per-token APIs
- Save 87-94% on AI costs with intelligent routing
- Real-time cost tracking and forecasting
- Subscription vs API cost analysis
- Budget alerts with visual progress bars
Responsive Multi-Panel Layout - Automatically adapts to your terminal size:
All 6 panels visible simultaneously in a 3-column layout:
┌─ Workers ────────┐ ┌─ Tasks ──────────┐ ┌─ Costs ──────────┐
│ GLM-4.7 active │ │ Ready: 0 │ │ Today: $25.43 │
│ Opus idle │ │ In Progress: 0 │ │ Week: $178.92 │
│ Sonnet active │ │ Blocked: 0 │ │ Month: $762.90 │
├─ Activity Log ───┤ ├─ Quick Actions ──┤ ├─ Metrics ────────┤
│ Worker spawned │ │ [s] Spawn Worker │ │ Tasks/hr: 12.5 │
│ Task completed │ │ [k] Kill Worker │ │ Success: 94.2% │
└──────────────────┘ └──────────────────┘ └──────────────────┘
Best for: Large monitors, ultra-wide displays, comprehensive overview
4 panels visible in a 2-column layout:
┌─ Worker Pool ────────────┐ ┌─ Utilization ─────────────┐
│ Total: 17 (4 active) │ │ Worker Utilization: 23% │
│ Unhealthy: 12 │ │ ██████ │
│ │ │ 4/17 workers active │
├─ Task Queue ─────────────┤ │ │
│ Ready: 0 │ │ Status Breakdown: │
│ No pending tasks │ │ ⚡ Active: 4 │
│ │ │ 💤 Idle: 1 │
├─ Activity Log ───────────┤ │ ⛔ Stopped: 12 │
│ Worker stopped... │ │ ⚠️ 12 unhealthy workers │
│ Task completed... │ │ │
└──────────────────────────┘ └───────────────────────────┘
Access Costs/Metrics via hotkeys: Press [c] for Costs, [m] for Metrics
Best for: Standard terminals, laptop screens
Single-view mode - Switch between views using hotkeys:
┌─ FORGE Dashboard - Overview ─────────────────────────────┐
│ Worker Pool │ Utilization │
│ Total: 17 (4 active) │ Worker Utilization: 23% │
│ Unhealthy: 12 │ 4/17 workers active (23%) │
├──────────────────────────┴───────────────────────────────┤
│ Task Queue: Ready: 0 | In Progress: 0 | Blocked: 0 │
│ No pending tasks. │
├──────────────────────────────────────────────────────────┤
│ Activity Log │
│ 21:55:48 claude-code-glm-47-bravo stopped │
│ 21:50:39 claude-code-glm-47-alpha stopped │
└──────────────────────────────────────────────────────────┘
[o]Overview [w]Workers [t]Tasks [c]Costs [m]Metrics [:]Chat
Navigate with hotkeys: o Overview, w Workers, t Tasks, c Costs, m Metrics, l Logs, : Chat
Best for: SSH sessions, tmux panes, small terminals
- 6 available views: Workers, Tasks, Costs, Metrics, Activity Log, Chat
- Real-time worker status and health metrics
- Task queue visualization with bead integration
- Live activity logs and performance metrics
- Conversational interface as primary control - just ask in natural language
- Optional hotkeys for power users (W for workers, T for tasks, etc.)
- 4 configurable themes: Default, Dark, Light, Cyberpunk
- Hot-reload capability for live configuration updates
- State preservation across updates
- Runtime configuration changes via CLI
- Automatic task value scoring (P0-P4 priority levels)
- Model capability matching
- Dependency-aware scheduling with Beads integration
- Bead-level locking for multi-worker coordination
- Lock management to prevent duplicate work
- Natural language commands to control FORGE
- AI-powered tool execution
- Command history and context awareness
- Rate limiting (10 commands/min)
- Audit logging for all commands
- Headless CLI backend: Integrate with any AI tool that supports structured I/O
- Custom launchers: Create worker launchers for any AI coding tool
- Worker configurations: Share reusable worker configs via Git repos
- 45+ built-in tools for dashboard control and management
- Chat tools: worker_status, task_queue, cost_analytics, subscription_usage, spawn_worker, kill_worker, assign_task, and more
FORGE operates as a federated orchestration system with a "dumb orchestrator" design:
┌─────────────────────────────────────────────────────────────────────┐
│ FORGE Control Panel │
│ (Textual TUI Dashboard) │
├─────────────────────────────────────────────────────────────────────┤
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Workers │ │ Tasks │ │ Costs │ │ Metrics │ │
│ │ Pool │ │ Queue │ │ Tracking │ │ & Stats │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ ┌──────────────────┐ ┌──────────────────────────────────────┐ │
│ │ Activity Log │ │ Chat Interface (Conversational) │ │
│ │ (Real-time) │ │ "Spawn 3 sonnet workers" │ │
│ └──────────────────┘ └──────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────┼─────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ Chat │ │ Worker │ │ Log & │
│ Backend │ │ Launchers │ │ Status │
│ │ │ │ │ Watchers │
│ • claude-code │ │ • tmux │ │ • JSONL │
│ • opencode │ │ • subprocess │ │ parsing │
│ • custom │ │ • docker │ │ • inotify │
└───────────────┘ └───────────────┘ └───────────────┘
│ │ │
└─────────────────────┼─────────────────────┘
▼
┌─────────────────┐
│ Data Layer │
├─────────────────┤
│ • Beads (JSONL) │
│ • Status Files │
│ • Cost DB (SQL) │
│ • Config (YAML) │
└─────────────────┘
| Component | Purpose |
|---|---|
| Dashboard (TUI) | Responsive multi-panel UI with 6 available views |
| Chat Backend | Translates natural language to tool calls via AI |
| Worker Launchers | Spawns AI coding agents in tmux/subprocess/docker |
| Status Watcher | Monitors worker status files for real-time updates |
| Log Watcher | Parses worker logs for metrics and activity |
| Beads Integration | Task tracking with dependency management |
| Cost Tracker | Monitors API costs and subscription usage |
FORGE is a "dumb orchestrator" - it has no built-in AI or worker management. Instead, it integrates with your existing tools:
- No built-in AI: Uses your Claude Code, OpenCode, or other tools via headless CLI backend
- No worker management: Delegates to your launcher scripts (tmux, Docker, etc.)
- Configuration-driven: All behavior controlled via YAML config
- Extensible: Create custom launchers, backends, and worker configs
FORGE requires:
- Python 3.10 or higher
- Linux, macOS, or WSL2 (Windows support coming soon)
- tmux (for worker session management, optional but recommended)
- Git (for workspace and repository features)
pip install llmforge# Clone the repository
git clone https://github.com/jedarden/forge.git
cd forge
# Create virtual environment (recommended)
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
# Install in editable mode
pip install -e .
# Verify installation
forge --versionpip install -e ".[dev]"This installs additional tools:
pytest- Testing frameworkpytest-asyncio- Async test supportpytest-textual- TUI testingcoverage- Code coveragemypy- Type checkingruff- Linting and formatting
# Initialize FORGE configuration
forge init
# This creates the directory structure:
# ~/.forge/
# ├── config.yaml # Main configuration
# ├── launchers/ # Worker launcher scripts
# ├── workers/ # Worker configuration templates
# ├── logs/ # Worker logs
# ├── status/ # Worker status files
# └── layouts/ # Saved dashboard layouts# From PyPI
pip install --upgrade llmforge
# From source
cd forge
git pull
pip install -e .# Start the FORGE dashboard
forge dashboardThe dashboard will adapt to your terminal size (see Beautiful TUI Dashboard for layout details).
Ultra-Wide Mode (199+ columns × 38+ rows) - All 6 panels visible:
┌─ FORGE Control Panel ──────────────────────────────────────────────────┐
│ │
│ ┌─ Workers ──────┐ ┌─ Tasks ─────────┐ ┌─ Costs ──────────┐ │
│ │ sonnet-alpha │ │ fg-abc [P0] │ │ Today: $12.34 │ │
│ │ opus-beta │ │ fg-def [P1] │ │ Week: $87.65 │ │
│ │ haiku-gamma │ │ fg-ghi [P2] │ │ │ │
│ └────────────────┘ └─────────────────┘ └──────────────────┘ │
│ │
│ ┌─ Metrics ───────┐ ┌─ Activity Log ────┐ ┌─ Chat ─────────────┐ │
│ │ Tasks/hr: 12.5 │ │ Worker spawned... │ │ : │ │
│ │ Avg time: 8.3m │ │ Task completed... │ │ Type : to chat │ │
│ │ Success: 94.2% │ │ Optimizing costs...│ │ │ │
│ └─────────────────┘ └────────────────────┘ └────────────────────┘ │
│ │
│ [Press : for chat | ? for help | q to quit] │
└─────────────────────────────────────────────────────────────────────────┘
Narrow/Wide Mode (<199 columns) - Use hotkeys to switch between views (see Beautiful TUI Dashboard for details).
Using the conversational interface (press :):
# Press : to activate chat, then type:
"Show me all workers"
"Spawn 2 sonnet workers"
"What did I spend today?"
"Show P0 tasks"
"Optimize my costs"Using hotkeys (optional):
| Key | Action |
|---|---|
: |
Activate chat (primary interface) |
W |
Workers view |
T |
Tasks view |
C |
Costs view |
M |
Metrics view |
L |
Activity log view |
O |
Overview dashboard |
S |
Spawn worker |
K |
Kill worker |
? |
Help |
q |
Quit |
# Spawn workers
forge spawn --model=sonnet --count=3
# Check status
forge status
# Optimize costs
forge optimize
# Validate configuration
forge validate-config
# Get/set config values
forge get dashboard.refresh_interval_ms
forge set dashboard.refresh_interval_ms 500FORGE integrates with AI coding tools through "headless" backends - CLI tools that accept structured input and return structured output.
# 1. Install Claude Code
npm install -g @anthropic-ai/claude-code
# 2. Set up environment
export ANTHROPIC_API_KEY="sk-ant-..."
# 3. Test headless mode
echo '{"message": "hello", "tools": []}' | \
claude-code chat --headless --tools=/dev/null
# 4. Create launcher script
cat > ~/.forge/launchers/claude-code-launcher << 'EOF'
#!/bin/bash
MODEL="$1"
WORKSPACE="$2"
SESSION_NAME="$3"
# Create directories
mkdir -p ~/.forge/logs ~/.forge/status
# Launch Claude Code in tmux
tmux new-session -d -s "$SESSION_NAME" \
"cd $WORKSPACE && claude-code --model=$MODEL 2>&1 | tee ~/.forge/logs/$SESSION_NAME.log"
# Get PID
PID=$(tmux list-panes -t "$SESSION_NAME" -F '#{pane_pid}')
# Output metadata (JSON)
cat << JSON
{"worker_id": "$SESSION_NAME", "pid": $PID, "status": "spawned"}
JSON
# Create status file
cat > ~/.forge/status/$SESSION_NAME.json << EOF
{
"worker_id": "$SESSION_NAME",
"status": "active",
"model": "$MODEL",
"workspace": "$WORKSPACE",
"pid": $PID,
"started_at": "$(date -Iseconds)"
}
EOF
EOF
chmod +x ~/.forge/launchers/claude-code-launcher
# 5. Configure FORGE
cat >> ~/.forge/config.yaml << 'EOF'
chat_backend:
command: "claude-code"
args:
- "chat"
- "--headless"
- "--tools=${FORGE_TOOLS_FILE}"
model: "sonnet"
env:
ANTHROPIC_API_KEY: "${ANTHROPIC_API_KEY}"
FORGE_TOOLS_FILE: "~/.forge/tools.json"
launchers:
claude-code:
executable: "~/.forge/launchers/claude-code-launcher"
models: ["sonnet", "opus", "haiku"]
EOF
# 6. Generate tool definitions
forge generate-tools > ~/.forge/tools.json# 1. Install Aider
pip install aider-chat
# 2. Set up environment
export OPENAI_API_KEY="sk-..." # or ANTHROPIC_API_KEY for Claude
# 3. Create launcher script
cat > ~/.forge/launchers/aider-launcher << 'EOF'
#!/bin/bash
MODEL="$1"
WORKSPACE="$2"
SESSION_NAME="$3"
# Create directories
mkdir -p ~/.forge/logs ~/.forge/status
# Map model names
case "$MODEL" in
"sonnet") MODEL_ARG="claude-sonnet-4-5" ;;
"opus") MODEL_ARG="claude-opus-4-5" ;;
"gpt4") MODEL_ARG="gpt-4" ;;
*) MODEL_ARG="$MODEL" ;;
esac
# Launch Aider in tmux
tmux new-session -d -s "$SESSION_NAME" \
"cd $WORKSPACE && aider --model=$MODEL_ARG 2>&1 | tee ~/.forge/logs/$SESSION_NAME.log"
# Get PID
PID=$(tmux list-panes -t "$SESSION_NAME" -F '#{pane_pid}')
# Output metadata (JSON)
cat << JSON
{"worker_id": "$SESSION_NAME", "pid": $PID, "status": "spawned"}
JSON
# Create status file
cat > ~/.forge/status/$SESSION_NAME.json << EOF
{
"worker_id": "$SESSION_NAME",
"status": "active",
"model": "$MODEL",
"workspace": "$WORKSPACE",
"pid": $PID,
"started_at": "$(date -Iseconds)"
}
EOF
EOF
chmod +x ~/.forge/launchers/aider-launcher
# 4. Configure FORGE
cat >> ~/.forge/config.yaml << 'EOF'
launchers:
aider:
executable: "~/.forge/launchers/aider-launcher"
models: ["sonnet", "opus", "gpt4"]
EOF# 1. Install Continue
# Continue is typically installed as an extension, but can be used via CLI
# See: https://continue.dev/reference/headless
# 2. Create launcher script
cat > ~/.forge/launchers/continue-launcher << 'EOF'
#!/bin/bash
MODEL="$1"
WORKSPACE="$2"
SESSION_NAME="$3"
# Create directories
mkdir -p ~/.forge/logs ~/.forge/status
# Continue uses config file for model selection
# Launch Continue headless mode
tmux new-session -d -s "$SESSION_NAME" \
"cd $WORKSPACE && continue --headless --model=$MODEL 2>&1 | tee ~/.forge/logs/$SESSION_NAME.log"
# Get PID
PID=$(tmux list-panes -t "$SESSION_NAME" -F '#{pane_pid}')
# Output metadata (JSON)
cat << JSON
{"worker_id": "$SESSION_NAME", "pid": $PID, "status": "spawned"}
JSON
# Create status file
cat > ~/.forge/status/$SESSION_NAME.json << EOF
{
"worker_id": "$SESSION_NAME",
"status": "active",
"model": "$MODEL",
"workspace": "$WORKSPACE",
"pid": $PID,
"started_at": "$(date -Iseconds)"
}
EOF
EOF
chmod +x ~/.forge/launchers/continue-launcher
# 4. Configure FORGE
cat >> ~/.forge/config.yaml << 'EOF'
launchers:
continue:
executable: "~/.forge/launchers/continue-launcher"
models: ["gpt4", "sonnet", "claude"]
EOFIf your AI tool doesn't support headless mode, create a wrapper:
#!/usr/bin/env python3
# ~/.forge/backends/custom-wrapper.py
import json
import sys
from anthropic import Anthropic
def main():
# Read FORGE input
input_data = json.load(sys.stdin)
message = input_data["message"]
tools = input_data.get("tools", [])
# Call your AI tool
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
response = client.messages.create(
model="claude-sonnet-4-5",
messages=[{"role": "user", "content": message}],
tools=tools
)
# Extract tool calls
tool_calls = []
for block in response.content:
if block.type == "tool_use":
tool_calls.append({
"id": block.id,
"tool": block.name,
"arguments": block.input
})
# Return FORGE output
result = {
"tool_calls": tool_calls,
"message": response.content[0].text if response.content else "",
"requires_confirmation": False
}
print(json.dumps(result))
if __name__ == "__main__":
main()# Test manually
echo '{"message": "show workers", "tools": []}' | \
your-backend-command --args
# Expected output:
# {"tool_calls": [{"tool": "switch_view", "arguments": {"view": "workers"}}]}
# Test with FORGE (when available)
forge test-backend --verboseLocation: ~/.forge/config.yaml
# Chat backend configuration
chat_backend:
command: "claude-code"
args:
- "chat"
- "--headless"
- "--tools=${FORGE_TOOLS_FILE}"
model: "sonnet"
env:
ANTHROPIC_API_KEY: "${ANTHROPIC_API_KEY}"
FORGE_TOOLS_FILE: "~/.forge/tools.json"
timeout: 30
max_retries: 3
# Worker launcher configurations
launchers:
claude-code:
executable: "~/.forge/launchers/claude-code-launcher"
models: ["sonnet", "opus", "haiku"]
default_args:
- "--tmux"
# Worker configuration repositories
worker_repos:
- url: "https://github.com/forge-community/worker-configs"
branch: "main"
path: "configs/"
# Log collection settings
log_collection:
paths:
- "~/.forge/logs/*.log"
format: "jsonl" # or "keyvalue" or "auto-detect"
poll_interval_seconds: 1
max_age_days: 30
max_size_mb: 1000
# Status file location
status_path: "~/.forge/status/"
# Cost tracking
cost_tracking:
enabled: true
database_path: "~/.forge/costs.db"
forecast_days: 30
# Dashboard settings
dashboard:
refresh_interval_ms: 1000
max_fps: 60
default_layout: "overview"
# Hotkey customization
hotkeys:
workers_view: "W"
tasks_view: "T"
costs_view: "C"
metrics_view: "M"
logs_view: "L"
overview: "O"
spawn_worker: "S"
kill_worker: "K"
chat_input: ":"
# Model routing (cost optimization)
routing:
# Tier assignments for task priorities
priority_tiers:
P0: "premium" # Use opus for critical tasks
P1: "premium" # Use opus for high priority
P2: "standard" # Use sonnet for normal tasks
P3: "budget" # Use haiku for low priority
P4: "budget" # Use haiku for backlog
# Subscription optimization
subscription_first: true
fallback_to_api: true
# Task scoring weights (0-100 scale)
scoring_weights:
priority: 0.4 # 40 points for P0, 30 for P1, etc.
blockers: 0.3 # 10 points per blocked task, max 30
age: 0.2 # Older tasks get more points, max 20
labels: 0.1 # Critical/urgent labels give 10 points# Override config location
export FORGE_CONFIG=~/.config/forge/config.yaml
# Override directories
export FORGE_LAUNCHERS_DIR=~/custom-launchers
export FORGE_WORKERS_DIR=~/custom-workers
export FORGE_LOGS_DIR=/var/log/forge
# API keys (used by workers)
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
# Enable debug logging
export FORGE_DEBUG=1
export FORGE_LOG_LEVEL=debug
# Specify workspace
export FORGE_WORKSPACE=/path/to/project- User Guide - Complete installation, configuration, and usage guide
- Integration Guide - Integrate external tools with FORGE
- Tool Catalog - Reference for all 45+ tools
- Hotkeys Reference - Keyboard shortcuts
- ADRs - Architecture Decision Records
Comprehensive research documentation available in docs/notes/:
- Naming Analysis: Why "FORGE" and alternatives considered
- TUI Design: Dashboard layouts, responsive strategies
- Cost Optimization: Subscription vs API analysis, 87-94% savings strategies
- Model Routing: Task scoring algorithms, capability matching
- Conversational Interface: Chat history, tool transparency, scrolling
- System Architecture: Complete system architecture diagrams
- Algorithm Design: Task assignment, adaptive learning, deadlock detection
# Check Python version
python --version # Must be 3.10+
# Check FORGE installation
forge --version
# Check configuration
forge validate
# Debug mode
FORGE_DEBUG=1 forge
# Common issues:
# - Python version too old → Upgrade Python
# - Dependencies missing → pip install -e ".[dev]"
# - Config syntax error → forge validate
# - Port in use → Check for running forge processes# Check launcher script
ls -la ~/.forge/launchers/
chmod +x ~/.forge/launchers/*
# Test launcher manually
~/.forge/launchers/claude-code-launcher \
--model=sonnet \
--workspace=/tmp/test \
--session-name=test
# Expected output: JSON with worker_id, pid, status
# Check for required tools
which tmux
which claude-code # or other AI tool
# Common issues:
# - Launcher not executable → chmod +x
# - Missing dependencies → Install AI tool
# - Invalid arguments → Check launcher syntax
# - Workspace doesn't exist → Create directory# Test backend manually
echo '{"message": "test", "tools": []}' | \
claude-code chat --headless --tools=/dev/null
# Check API keys
echo $ANTHROPIC_API_KEY # Should be set
# Test tool definitions
# (when available) forge validate-tools ~/.forge/tools.json
# Check backend logs
FORGE_DEBUG=1 forge 2>&1 | grep backend
# Common issues:
# - API key not set → Export ANTHROPIC_API_KEY
# - Backend not installed → Install AI tool
# - Tools file invalid → Generate tools.json
# - Timeout too short → Increase timeout in config# Check status files
ls -la ~/.forge/status/
cat ~/.forge/status/sonnet-alpha.json
# Check log files
ls -la ~/.forge/logs/
tail ~/.forge/logs/sonnet-alpha.log
# Check tmux sessions
tmux list-sessions
# Verify worker process
ps aux | grep sonnet-alpha
# Common issues:
# - Status file not created → Check launcher script
# - Status file invalid → Validate JSON format
# - Worker crashed → Check log file for errors
# - Tmux session died → Restart worker# Check inotify availability
python -c "from watchdog.observers import Observer; print('OK')"
# Verify refresh interval
forge get dashboard.refresh_interval_ms
# Force refresh
# Press Ctrl+L in dashboard
# Common issues:
# - inotify not available → Falls back to polling
# - Refresh too slow → Decrease interval
# - High CPU usage → Increase interval
# - UI frozen → Press Ctrl+L to redraw# Check log file sizes
du -sh ~/.forge/logs/
# Rotate logs if needed
# (when available) forge rotate-logs --max-age=7
# Check database size
du -sh ~/.forge/costs.db
# Reduce history retention
forge set log_collection.max_age_days 7
forge set log_collection.max_size_mb 500
# Common issues:
# - Large log files → Rotate logs
# - Large database → Vacuum or recreate
# - Too many workers → Kill idle workers
# - High refresh rate → Increase interval# Built-in help
: help # Type in chat interface
? # Press ? key
# Documentation
forge docs # Opens https://forge.readthedocs.io (when available)
# Report issues
# https://github.com/jedarden/forge/issues
# Community
# Discord: https://discord.gg/forge (when available)🚧 Active Development - Research phase complete, implementation in progress
See docs/notes/ for comprehensive design documentation and architecture decisions.
- Basic TUI dashboard implementation
- Worker spawning and management
- Task queue integration (Beads)
- Real-time status monitoring
- Log parsing and metrics extraction
- Cost tracking implementation
- Task value scoring algorithm
- Multi-model routing engine
- Cost optimization logic
- Subscription tracking
- Conversational CLI interface (fully implemented)
- Hot-reload and self-updating
- Advanced health monitoring
- Performance analytics
- Multi-workspace coordination
- Team collaboration features
- Audit logs and compliance
- Advanced RBAC
Contributions welcome! This project is in active development.
- Check out the research documentation to understand the architecture
- Open issues for bugs, features, or questions
- Submit PRs with clear descriptions and tests
# Clone the repository
git clone https://github.com/jedarden/forge.git
cd forge
# Create virtual environment
python -m venv venv
source venv/bin/activate
# Install with dev dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Run linter
ruff check src/
ruff format src/
# Run type checker
mypy src/MIT License - see LICENSE for details
The name reflects the core mission:
- Federated: Coordinate across multiple AI providers and models
- Orchestration: Intelligent task distribution and scheduling
- Resource: Optimize subscription and API usage
- Generation: Spawn workers dynamically based on demand
- Engine: Powerful, efficient, reliable automation
Like a blacksmith's forge that transforms raw materials into refined tools, FORGE transforms AI resources into optimized, coordinated intelligence.
Built with insights from the AI coding tools community, optimized for real-world use cases where managing multiple AI subscriptions and workers becomes complex.
FORGE - Where AI agents are forged, orchestrated, and optimized.