Cowork Forge

English | 中文

🤖 Full-Stack AI Development Team - Complete Collaboration from Idea to Delivery 🤖

Cowork Forge is not just a code generator, but a complete virtual development team. It includes professional roles like Product Manager, Architect, Project Manager, and Engineer, working together through AI agent collaboration to transform your ideas into production-ready software systems.

---

👋 What is Cowork Forge?

Cowork Forge is a complete AI-powered development team system that simulates how real software teams collaborate. AI agents take on roles as Product Manager, Architect, Project Manager, and Engineer, working together to complete everything from ideation to delivery.

Unlike AI coding assistants that only generate code snippets, Cowork Forge provides end-to-end development lifecycle management:

• Product Manager AI: Transforms your ideas into detailed Product Requirements Documents (PRD)
• Architect AI: Designs complete technical architecture and system components
• Project Manager AI: Breaks down tasks, plans dependencies, and defines implementation paths
• Engineer AI: Implements code, ensures quality, and generates delivery reports

Each role uses Actor-Critic patterns for self-review and optimization, with human validation at critical decision points to ensure output quality and direction.

One person can have a complete development team - Cowork Forge makes AI agents work for you like a real team.

Traditional Development	Development with Cowork Forge
Requires Multiple Roles and Tools Need Product Manager to write PRD Need Architect to design technical solution Need Project Manager to break down tasks Need Engineer to write code High cost and long cycle for multi-role collaboration	One System Covers All Roles AI Product Manager auto-generates professional PRD AI Architect designs complete technical solution AI Project Manager intelligently breaks down tasks AI Engineer implements high-quality code Full-process collaboration, human only validates key decisions

---

🏆 Cowork Forge vs. Competitors

Cowork Forge stands out in the AI development tools landscape through its unique multi-agent architecture and comprehensive workflow coverage.

Core Capabilities Comparison

Capability	Cowork Forge	GitHub Copilot	Cursor AI	Aider
End-to-End Workflow	✅ Complete (Idea→Delivery)	❌ Code completion only	❌ Code editing focus	❌ Code assistance only
Multi-Agent Architecture	✅ 8 specialized agents	❌ Single model	❌ Single model	❌ Single model
PRD Generation	✅ Automated	❌ N/A	❌ N/A	❌ N/A
Technical Design	✅ C4 architecture docs	❌ N/A	❌ N/A	❌ N/A
Implementation Planning	✅ Task breakdown & milestones	❌ N/A	❌ N/A	❌ N/A
Incremental Updates	✅ Smart delta analysis	❌ N/A	❌ Limited	❌ Limited
Multi-Language Support	✅ Rust, Python, JS/TS	✅ Many languages	✅ Many languages	✅ Many languages
Human-in-the-Loop	✅ Critical decision points	❌ N/A	❌ Limited	❌ Limited
Automated Verification	✅ Build/test integration	❌ N/A	❌ N/A	❌ N/A
Safety Checks	✅ Multi-layer security	❌ N/A	❌ Basic	❌ Basic
Artifact Storage	✅ Versioned artifacts	❌ N/A	❌ N/A	❌ N/A
Open Source	✅ MIT License	❌ Proprietary	❌ Proprietary	✅ MIT License
Self-Hosted	✅ Local execution	❌ Cloud only	❌ Cloud only	✅ Local execution

Key Differentiators

1. Complete Virtual Development Team

Unlike tools that only assist with writing code, Cowork Forge provides complete development team role coverage:

• Product Manager Role: Transforms vague ideas into structured Product Requirements Documents
• Architect Role: Designs complete technical architecture and system components
• Project Manager Role: Breaks down tasks, plans dependencies, and implementation paths
• Engineer Role: Implements code and performs quality verification

This full-role coverage ensures end-to-end continuity and professionalism from requirements analysis to code implementation.

2. Multi-Agent Collaboration

Cowork Forge's specialized agents work together like a real development team:

• Idea Agent: Captures and structures user requirements
• PRD Loop Agent: Generates comprehensive PRDs with actor-critic refinement
• Design Loop Agent: Creates technical architecture with actor-critic refinement
• Plan Loop Agent: Breaks down implementation tasks with actor-critic refinement
• Coding Loop Agent: Plans and executes code changes with actor-critic refinement
• Check Agent: Verifies code quality and completeness
• Delivery Agent: Generates comprehensive delivery reports
• Change Triage Agent: Analyzes and triages incremental change requests
• Code Patch Agent: Implements precise code patches for modifications
• Modify Delivery Agent: Generates modification delivery reports

3. Human-in-the-Loop Validation

Critical outputs require human confirmation before proceeding, ensuring:

• Accurate requirement capture
• Sound technical decisions
• Feasible implementation plans
• Safe code changes

This balance of automation and human control sets Cowork Forge apart from fully autonomous tools.

4. Incremental Code Updates

When requirements or designs change, Cowork Forge intelligently identifies affected files and updates only what's necessary—preserving your customizations and avoiding full regeneration.

5. Built-in Safety

Multi-layer security checks prevent:

• Dangerous command execution (rm -rf, sudo, etc.)
• Unauthorized file system access
• Malicious code injection
• Resource exhaustion

❤️ Like Cowork Forge? Star it 🌟 or Sponsor Me! ❤️

🌠 Features & Capabilities

• 7-Stage Development Workflow: Comprehensive workflow covering Idea Intake → PRD Generation → Technical Design → Implementation Plan → Coding → Quality Check → Delivery, corresponding to the complete process of a real development team.
• Specialized AI Agents: Each stage handled by a dedicated agent with domain expertise. Four critical stages (PRD, Design, Plan, Coding) use actor-critic loops for iterative refinement, ensuring output quality meets professional standards.
• Intelligent Code Planning: Analyzes project structure, dependencies, and generates precise code change plans.
• Incremental Code Updates: Smart delta analysis updates only affected files, preserving existing modifications.
• Automated Quality Verification: Multi-language build/test integration with comprehensive error analysis and reporting.
• Human-in-the-Loop Validation: Critical outputs (PRD, design, plans) require human confirmation before proceeding.
• Artifact-Based Storage: Versioned storage of all stage outputs with JSON and Markdown formats.
• Todo List Management: Automatic task tracking with status inference and progress reporting.
• Multi-Language Project Support: Automatic detection and handling of Rust, Python, JavaScript/TypeScript projects.
• Security & Safety: Command validation, path access control, and watchdog monitoring for safe execution.

🏗️ Architecture

Cowork Forge is built with a modular, domain-driven architecture:

graph TB
    subgraph "CLI Layer"
        CLI[cowork-cli]
    end
    
    subgraph "Core Layer"
        Orch[Orchestrator]
        Exec[StageExecutor]
    end
    
    subgraph "Agent Layer"
        IDEA[Idea Agent]
        PRD[PRD Loop Agent]
        DESIGN[Design Loop Agent]
        PLAN[Plan Loop Agent]
        CODING[Coding Loop Agent]
        CHECK[Check Agent]
        DELIVERY[Delivery Agent]
    end
    
    subgraph "Infrastructure Layer"
        TOOLS[Tools]
        VERIFY[Verification]
        MEMORY[Memory]
        HITL[HITL]
        CONFIG[Config]
    end
    
    subgraph "External"
        LLM[OpenAI LLM]
        FS[File System]
        CMD[Command Line]
    end
    
    CLI --> Orch
    Orch --> Exec
    Exec --> IDEA
    Exec --> PRD
    Exec --> DESIGN
    Exec --> PLAN
    Exec --> CODING
    Exec --> CHECK
    Exec --> DELIVERY
    
    IDEA --> TOOLS
    CODING --> TOOLS
    CHECK --> TOOLS
    
    CHECK --> VERIFY
    CODING --> VERIFY
    
    Exec --> HITL
    
    TOOLS --> FS
    TOOLS --> CMD
    
    IDEA -.-> LLM
    PRD -.-> LLM
    DESIGN -.-> LLM
    CODING -.-> LLM

Loading

Key Components

Pipeline Orchestrator

Manages session lifecycle, stage dependencies, and workflow execution with support for full and partial pipeline assembly.

AI Agents

Specialized agents work collaboratively, each responsible for a specific stage of the development lifecycle. Four agents (PRD, Design, Plan, Coding) use actor-critic loop patterns for iterative refinement with human feedback. Includes: Idea, PRD, Design, Plan, Coding, Check, Delivery, Change Triage, Code Patch, Modify Delivery.

Instruction Templates

Provides specialized prompt templates for each agent, defining their behavior and output format.

Tools Module

Safe file operations and command execution with security checks and resource limits.

LLM Integration Layer

Manages interactions with large language models, including rate limiting, API clients, and request optimization.

Data Module

Defines system data models and session management mechanisms.

Storage Module

Provides persistent data management and retrieval capabilities.

🧠 How It Works

Cowork Forge uses a sophisticated multi-stage workflow orchestrated by the Orchestrator:

sequenceDiagram
    participant User as User
    participant CLI as Cowork Forge CLI
    participant Orch as Orchestrator
    participant Agents as AI Agents
    participant LLM as OpenAI LLM
    participant FS as File System
    participant CMD as Command Line

    User->>CLI: Provide idea/requirement
    CLI->>Orch: Start new session
    Orch->>Agents: Execute IdeaIntakeAgent
    Agents->>LLM: Structure requirements
    LLM-->>Agents: Return IdeaSpec
    Agents->>User: HITL validation
    User-->>Agents: Confirm/edit
    
    loop For each stage
        Orch->>Agents: Execute next agent
        Agents->>LLM: Generate stage output
        LLM-->>Agents: Return results
        
        alt Critical stage
            Agents->>User: HITL validation
            User-->>Agents: Confirm/edit
        end
        
        alt Coding stage
            Agents->>FS: Read project files
            Agents->>LLM: Plan code changes
            LLM-->>Agents: Return code plan
            Agents->>User: HITL validation
            User-->>Agents: Confirm plan
            Agents->>FS: Write code changes
            Agents->>CMD: Run build/test
            CMD-->>Agents: Return results
        end
    end
    
    Orch->>Agents: Execute DeliveryAgent
    Agents->>User: Present delivery report

Loading

🖥 Getting Started

Prerequisites

• Rust (version 1.70 or later)
• OpenAI API Key for LLM access
• Git and language-specific build tools (cargo, npm, pip, etc.)

Installation

Build from source:

# Clone the repository
git clone https://github.com/sopaco/cowork-forge.git
cd cowork-forge

# Build the project
cargo build --release

# The CLI binary will be available at:
# target/release/cowork

Configuration

Cowork Forge uses a config.toml file for configuration. Create one in your project directory or use --config to specify a path:

# LLM Configuration
[llm]
api_base_url = "https://api.openai.com/v1"
api_key = "sk-your-openai-api-key"
model_name = "gpt-5-codex"

🚀 Usage

Starting a New Development Session

# Start a new project with an idea
cowork new "Build a REST API for a task management application"

# Start with a configuration file
cowork new "Create a web dashboard" --config ./config.toml

# Resume an existing project
cowork resume

Session Workflow

When you start a session, Cowork Forge will guide you through the 7-stage workflow:

1. Idea Intake: Your idea is structured into a formal specification (idea.md)
2. PRD Generation: A comprehensive Product Requirements Document with actor-critic refinement
3. Technical Design: Architecture design with component specifications and actor-critic refinement
4. Implementation Plan: Task breakdown with dependencies and actor-critic refinement
5. Coding: Code implementation with actor-critic refinement and human validation
6. Quality Check: Verification of feature coverage and code completeness
7. Delivery: Final delivery report with implementation summary

At each critical stage, you'll be prompted to review and confirm the output before proceeding.

Example Session Flow

$ cowork new "Build a CLI tool for file conversion"

[Stage 1/7] Idea Agent
Analyzing your requirement...
Generated IdeaSpec: "A command-line tool for converting files between formats"

Do you want to:
  [1] Accept and continue
  [2] Edit the specification
  [3] Regenerate
> 1

[Stage 2/7] PRD Generation Agent
Generating Product Requirements Document...
Created PRD with 12 requirements and 5 user stories

Review the PRD at: .cowork/artifacts/session-001/prd.md
Do you want to:
  [1] Accept and continue
  [2] Edit the PRD
  [3] Regenerate
> 1

[Stage 3/7] Design Agent
Creating technical architecture...
Generated C4 system context and container diagrams

Review the design at: .cowork/artifacts/session-001/design.md
Do you want to:
  [1] Accept and continue
  [2] Edit the design
  [3] Regenerate
> 1

... (continues through all 7 stages)

[Delivery] Project Complete!
Delivery report: .cowork/artifacts/session-001/delivery.md

Summary:
- 12 requirements implemented
- 4 modules created
- 15 test cases added
- Build: PASSED
- Tests: 15/15 PASSED

Managing Projects

# View project status
cowork status

# Modify from a specific stage
cowork modify --from prd
cowork modify --from design
cowork modify --from plan
cowork modify --from coding

Configuration Management

# Initialize configuration file
cowork init

# Use verbose logging
cowork new "your idea" --verbose

# Enable LLM streaming output
cowork new "your idea" --stream

🌐 The Cowork Forge Ecosystem

Cowork Forge is organized as a modular Rust workspace with clear separation of concerns:

graph TD
    subgraph "User Interface"
        CLI["cowork-cli"]
    end

    subgraph "Core System"
        Core["cowork-core"]
    end
    
    subgraph "External Services"
        LLM[("OpenAI LLM")]
        FS[("File System")]
        CMD[("Command Line")]
    end

    %% Define Dependencies
    CLI --> Core
    
    Core --> LLM
    Core --> FS
    Core --> CMD

Loading

• cowork-core: The heart of the system containing all business logic, agents, orchestrator, and supporting modules.
• cowork-cli: Command-line interface for interacting with the Cowork system.

Core Modules

cowork-core is organized into the following domain modules:

• pipeline: Workflow pipeline orchestration managing session lifecycle and stage execution.
• agents: Specialized AI agents (Idea, PRD, Design, Plan, Coding, Check, Delivery, Modify, CodePatch, ModifyDelivery).
• instructions: Prompt templates for each agent.
• tools: File operations and command execution with safety checks.
• llm: LLM integration layer including rate limiting and API clients.
• data: Data models and session management.
• storage: Data persistence and retrieval.

🔒 Security

Cowork Forge implements multiple layers of security:

1. Command Validation: Dangerous commands are blocked before execution
2. Path Access Control: Restricted access to sensitive system directories
3. Build Tool Whitelist: Only authorized development tools can be executed
4. Timeout Controls: Prevents resource exhaustion from long-running commands
5. Watchdog Monitoring: Detects and prevents agent deviation from objectives

🤝 Contributing

We welcome all forms of contributions! Report bugs or submit feature requests through GitHub Issues.

Development Process

1. Fork this project
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Create a Pull Request

Running Tests

# Run all tests
cargo test

# Run tests with coverage
cargo test --all-features

# Run specific module tests
cargo test -p cowork-core

📚 Documentation

Comprehensive documentation is available in the litho.docs directory:

• Project Overview - System context and architecture
• Architecture Overview - Detailed architecture documentation
• Core Workflows - Workflow and process documentation
• Domain Modules - In-depth domain analysis

🪪 License

This project is licensed under the MIT License. See the LICENSE file for details.

🙏 Acknowledgments

• Built with Rust
• Powered by OpenAI GPT models
• Inspired by modern software development practices and AI agent research

📬 Contact

• GitHub: sopaco/cowork-forge
• Issues: GitHub Issues

---

Transform your development workflow with Cowork Forge—the future of collaborative software development. 🚀