TaskForge CLI transforms your terminal into a command center for AI-powered code generation. Rather than juggling multiple AI coding assistants manually, TaskForge acts as a digital forger's hammer – striking once to delegate complex coding tasks across multiple AI models simultaneously. Inspired by the concept of orchestrating Cursor from Claude Code, this tool elevates that idea into a standalone, multi-model delegation system that works with OpenAI, Claude, and local models.
"Why teach one apprentice when you can command a guild of master craftsmen?"
TaskForge embodies the principle of delegated intelligence. Instead of manually prompting individual AI tools, you define a task once and TaskForge distributes it to multiple AI models. Each model works on a different component, and the results merge into a cohesive solution. This is parallelized cognitive labor – your ideas become blueprints, and the blueprints become executable code without you writing a single character manually.
graph TD
A[User Terminal/CLI] --> B{TaskForge Core Engine}
B --> C[Task Decomposer]
B --> D[Model Orchestrator]
B --> E[Output Merger]
C --> F[Component 1]
C --> G[Component 2]
C --> H[Component N]
D --> I[OpenAI GPT-4 / o3-mini]
D --> J[Claude Opus / Sonnet]
D --> K[Cursor Composer 2]
D --> L[Local CodeLlama / DeepSeek]
E --> M[Unified Code Output]
M --> N[File System / Git Commit]
style A fill:#4a90d9,stroke:#1a1a2e,color:#fff
style B fill:#16213e,stroke:#0f3460,color:#fff
style I fill:#ff6600,stroke:#1a1a2e,color:#fff
style J fill:#6f42c1,stroke:#1a1a2e,color:#fff
style K fill:#00bcd4,stroke:#1a1a2e,color:#fff
style L fill:#4caf50,stroke:#1a1a2e,color:#fff
- Python 3.9+ (for core engine)
- Node.js 18+ (for Cursor integration)
- An OpenAI API key (optional but recommended)
- A Claude API key (optional but recommended)
# Install via pip
pip install taskforge-cli
# Or via npm for Node-centric projects
npm install -g taskforge-cli
# Verify installation
taskforge --versionTaskForge uses YAML-based profiles to define which models handle which tasks. Here's a sample profile that delegates like a seasoned project manager:
# ~/.taskforge/profiles/default.yml
profile_name: "full-stack-workbench"
version: "2.0"
delegation_rules:
- task_pattern: "frontend.*component|React|Vue|UI"
model: "claude-sonnet-4"
priority: 1
merge_strategy: "replace_existing"
- task_pattern: "backend.*API|database|endpoint"
model: "openai-gpt-4o"
priority: 2
merge_strategy: "append"
- task_pattern: "testing|unit.test|integration.test"
model: "cursor-composer-2"
priority: 3
merge_strategy: "insert_before"
- task_pattern: "documentation|README|docs"
model: "claude-opus"
priority: 4
merge_strategy: "replace_existing"
- task_pattern: ".*" # Default fallback
model: "local-codellama-34b"
priority: 99
merge_strategy: "append"
output_settings:
merge_directory: "./generated"
conflict_resolution: "manual_review"
max_iterations_per_model: 3
timeout_per_model: 120 # secondsDeploy a full-stack application with a single command – TaskForge handles the rest:
# Basic invocation: build a microservices architecture
taskforge run "Create a microservices-based e-commerce backend with Node.js, Express, and PostgreSQL. Include authentication, product catalog, and order management."
# Advanced: specify profile and output format
taskforge run \
--profile "full-stack-workbench" \
--task "Generate a responsive dashboard UI using React and Tailwind CSS with 5 data visualization components" \
--output-format "react-tsx" \
--verbose \
--auto-merge
# Batch mode: process multiple tasks from a file
taskforge batch --input ./tasks/migration_plan_2026.txt --profile "migration-expert"| Operating System | Version | Status | Notes |
|---|---|---|---|
| 🐧 Linux | Ubuntu 22.04+ | ✅ Full Support | Native performance |
| 🐧 Linux | Fedora 38+ | ✅ Full Support | Requires Python 3.9+ |
| 🍎 macOS | Ventura 13+ | ✅ Full Support | Apple Silicon optimized |
| 🍎 macOS | Monterey 12 | ✅ Supported | Intel & M-series |
| 🪟 Windows | 11 | ✅ Full Support | WSL2 recommended |
| 🪟 Windows | 10 | Use Windows Terminal | |
| 🐧 Linux | Alpine (Docker) | ✅ Supported | Minimal footprint |
- Multi-Model Delegation Engine – Distributing tasks across OpenAI, Claude, Cursor, and local models simultaneously. Think of it as a conductor leading an orchestra of AI instruments.
- Intelligent Task Decomposition – Breaking complex requirements into smaller, model-optimized sub-tasks. The system analyzes your prompt and splits it like a lumberjack splitting logs along the grain.
- Smart Merge Conflict Resolution – When multiple models return code for the same file, TaskForge uses diff-based merging with human-in-the-loop validation. It's the diplomat of code conflicts.
- Pluggable Model Architecture – Add new models via simple JSON configuration. No code changes required – just like adding a new tool to a Swiss Army knife.
- Responsive UI – Both CLI and optional web dashboard with real-time streaming output. The terminal becomes a live theater of AI generation.
- Multilingual Support – Accept tasks in 20+ languages (English, Spanish, Mandarin, Arabic, Hindi, French, German, Japanese, Korean, Portuguese, Russian, and more). The engine understands intent, not just words.
- 24/7 Customer Support – While the tool runs autonomously, our Discord community and documentation ensure you're never stuck. Think of it as a digital night watchman for your codebase.
- Contextual Memory – Remembers previous delegation patterns and model performance metrics. The system learns which models excel at which tasks like a sommelier learning wine profiles.
- Security Sandboxing – All generated code runs through static analysis before output. A digital quarantine for potential vulnerabilities.
- Git Integration – Automatic commits with model attribution. Every line of code has a birth certificate showing which AI created it.
- Cost Optimization – Automatically routes low-complexity tasks to cheaper models, reserving expensive models for high-value work. It's your financial advisor for AI spend.
- Export to Any Format – JSON, YAML, CSV, SQL, Markdown, or raw file trees. The output is a customizable mosaic of code.
- Progress Persistence – Interrupt and resume multi-hour generation sessions. Code generation survives terminal crashes like a phoenix from the ashes.
TaskForge leverages OpenAI's latest models for tasks requiring creative reasoning and broad knowledge:
# .taskforge/config.yml
openai:
api_key: ${OPENAI_API_KEY} # Use environment variables
model: "gpt-4o" # or "o3-mini" for faster tasks
temperature: 0.7
max_tokens: 8192
streaming: true # Real-time output
fallback_model: "gpt-4-turbo"Optimized for: Architectural design, complex logic generation, natural language understanding, and multi-step reasoning.
Claude models handle tasks requiring nuance, safety, and long-context understanding:
claude:
api_key: ${ANTHROPIC_API_KEY}
model: "claude-opus-4" # or "claude-sonnet-4" for cost efficiency
temperature: 0.5
max_tokens: 16384
thinking_mode: true # Enables Claude's extended reasoning
system_prompt: "You are a senior software architect..."Optimized for: Code review, documentation generation, security-critical code, and tasks requiring deep contextual understanding.
Direct integration with Cursor's Composer 2 for IDE-level code generation:
cursor:
mode: "composer-2"
workspace: "./project"
models: ["gpt-4o", "claude-sonnet-4"] # Cursor's model routing
auto_save: trueThis project is optimized for discoverability with natural keyword placement:
- AI code generation tool
- Multi-model coding assistant
- CLI for AI orchestration
- Code delegation framework
- Parallel AI development
- Automated software generation
- Multi-LLM code synthesis
- Prompt engineering platform
- AI-driven development pipeline
- Code generation orchestrator
These keywords appear naturally throughout the documentation, ensuring developers searching for these solutions find TaskForge without artificial stuffing.
| Variable | Description | Required |
|---|---|---|
TASKFORGE_OPENAI_KEY |
OpenAI API key | Yes (if using OpenAI) |
TASKFORGE_CLAUDE_KEY |
Anthropic API key | Yes (if using Claude) |
TASKFORGE_CURSOR_PATH |
Path to Cursor binary | Optional |
TASKFORGE_HOME |
Config directory | Defaults to ~/.taskforge |
TASKFORGE_LOG_LEVEL |
DEBUG, INFO, WARN, ERROR | Defaults to INFO |
# ~/.taskforge/config.yml
global:
concurrent_tasks: 4 # Number of parallel model calls
max_output_size_mb: 100
default_profile: "balanced-team"
auto_merge: false
git_commit_prefix: "[TaskForge] "
plugins:
- name: "code-validator"
path: "./plugins/validator.py"
hooks: ["post-generation", "pre-merge"]
- name: "cost-tracker"
path: "./plugins/cost-tracker.js"
hooks: ["post-completion"]Imagine you need a WebSocket-based chat app with React frontend, Node.js backend, PostgreSQL database, and Redis caching. Here's how TaskForge handles it:
-
Task Input:
taskforge run "Build a real-time chat application with the following stack: React + TypeScript frontend, Node.js + Express backend, PostgreSQL for messages, Redis for presence tracking. Include OAuth2 authentication." -
Decomposition: TaskForge splits this into:
- Database schema (OpenAI)
- Backend API (Claude)
- WebSocket handlers (Cursor Composer 2)
- Frontend components (Claude Sonnet)
- Authentication flow (OpenAI o3-mini)
- Documentation (Local CodeLlama)
-
Parallel Execution: All six components generate simultaneously in ~90 seconds.
-
Merge: TaskForge combines outputs, resolves import conflicts, and produces a unified project structure.
-
Output: A complete, runnable application with:
- 47 files generated
- 3,800+ lines of code
- 95% test coverage
- Full TypeScript types
- Docker configuration
This project is licensed under the MIT License – see the LICENSE file for details. You can use, modify, and distribute this software freely, even in commercial products.
Important: TaskForge is a tool for augmenting human productivity, not replacing it. The generated code should always be reviewed by a qualified developer before deployment. The authors are not responsible for any damages, data loss, or security vulnerabilities arising from the use of this tool. AI models can produce incorrect, insecure, or biased code. Always validate outputs, especially for production systems. By using TaskForge, you acknowledge that AI-generated code requires human oversight.
Security Note: Never expose your API keys in configuration files committed to version control. Always use environment variables or secret management services.
| Distribution | Architecture | Download |
|---|---|---|
| Linux (x86_64) | AMD/Intel | Download |
| Linux (ARM64) | Raspberry Pi, AWS Graviton | Download |
| macOS (Intel) | x86_64 | Download |
| macOS (Apple Silicon) | M1/M2/M3/M4 | Download |
| Windows (x86_64) | AMD/Intel | Download |
| Docker | Multi-arch | docker pull taskforge/core:latest |
TaskForge CLI – Because your time is too valuable to prompt the same thing twice. Built for developers who think in parallel in 2026.