Revolutionary estimation system powered by collaborative AI agents
DeliverableEstimatePro v3 is a groundbreaking AI-powered estimation system that revolutionizes software project estimation through human-AI collaborative intelligence. Unlike traditional estimation tools, this system uses 4 specialized AI agents working in parallel to evaluate projects from multiple perspectives, then engages in iterative dialogue with humans to capture tacit knowledge and refine estimates to match human intuition.
Key Innovation: The system's core strength lies in its iterative feedback loop where human insights (tacit knowledge) are continuously integrated with AI analysis, creating estimates that evolve from rough calculations to precise, human-validated projections.
Real Results: In our demonstration, the system successfully processed 12 initial deliverables, engaged in human dialogue about performance requirements, and automatically added 2 new deliverables (Performance Optimization and Load Testing), increasing the estimate from 85,500 USD to 136,275 USD with enhanced accuracy.
Software project estimation has always been one of the most challenging aspects of development, directly impacting project success. Traditional approaches have struggled to capture the inherent uncertainty and complexity of modern software projects.
DeliverableEstimatePro v3 was born from direct experience with estimation challenges repeatedly faced in real software development environments.
Across countless projects, we encountered these critical issues:
These challenges demanded a fundamental shift in approach.
Instead of traditional single-perspective estimation, we adopted this innovative approach:
DeliverableEstimatePro v3 liberates estimation from mere numerical calculation, redefining it as an intelligent partner supporting human cognitive processes.
Four specialized agents analyze complexity from different perspectives, surface tacit knowledge through dialogue, and pursue true accuracy through iterative consensus-building.
This represents evolution beyond traditional estimation tools into a cognitive collaborative system.
Input Excel with 12 deliverables → AI analysis → Human feedback → Output Excel with 14 deliverables including AI-calculated effort, cost, and confidence scores
The system's revolutionary approach centers on iterative human-AI collaboration:
DeliverableEstimatePro v3 is a multi-agent AI system that automates software project deliverable estimation. Unlike traditional single-LLM approaches that struggle with complex estimation requirements, this system uses 4 specialized agents working collaboratively.
The system begins by processing the input Excel file, automatically detecting and loading all deliverables:
# From workflow_orchestrator_simple.py def load_deliverables_from_excel(self, excel_path: str) -> List[Dict[str, str]]: """Load deliverables from Excel file""" deliverables = [] df = pd.read_excel(excel_path) for _, row in df.iterrows(): deliverable = { 'name': str(row.get('Deliverable Name', '')), 'description': str(row.get('Description', '')) } deliverables.append(deliverable) return deliverables
Real Execution Result:
📊 Analyzing Excel...
Loaded 12 deliverables
📋 Loaded deliverables:
1. Requirements Definition Document: Document that organizes and clarifies the overall system requirements
2. Basic Design Document: Document that describes the basic design policy and overall structure of the system
3. Detailed Design Document: Document that describes detailed design content for each function
4. Database Design: Database table design and ER diagram creation
5. API Design: REST API specification creation and design of each endpoint
6. Frontend Development: User interface development using React/Vue.js
7. Backend Development: Server-side development using Node.js/Python
8. Admin Panel: Development of administrator dashboard and configuration screens
9. Unit Testing: Creation and execution of automated tests for each functional unit
10. Integration Testing: Implementation of integration testing for the entire system
11. Operation Manual: Creation of manual for system operation
12. Deployment: Deployment to production environment and CI/CD pipeline construction
The system employs 4 specialized AI agents that work in parallel to evaluate the project from different angles:
# From workflow_orchestrator_simple.py def _execute_parallel_evaluation(self, state: EstimationState) -> EstimationState: """Execute parallel evaluation with 3 agents""" with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor: futures = [ executor.submit(self._run_business_evaluation, state), executor.submit(self._run_quality_evaluation, state), executor.submit(self._run_constraints_evaluation, state) ] for future in concurrent.futures.as_completed(futures, timeout=120): result = future.result() state.update(result) return state
Real Execution Result:
🔄 Starting parallel evaluation: Business, Quality, Constraints
⚡ Running 3 agents in parallel...
📋 Business & Functional Requirements Evaluation - Started
🎯 Quality & Non-Functional Requirements Evaluation - Started
🔒 Constraints & External Integration Evaluation - Started
📋 Business & Functional Requirements Evaluation - Completed (14.57seconds)
🎯 Quality & Non-Functional Requirements Evaluation - Completed (19.45seconds)
🔒 Constraints & External Integration Evaluation - Completed (20.40seconds)
⚡ Parallel execution completed - Total time: 20.42s
Evaluates business objectives, functional requirements, and user stories:
# From agents/business_requirements_agent_v2.py SYSTEM_PROMPT = """You are a Business Requirements Analysis Expert specializing in evaluating business and functional requirements for software projects. Your role is to: 1. Assess the clarity and completeness of business objectives 2. Evaluate functional requirements comprehensiveness 3. Analyze user stories and acceptance criteria 4. Assess business value and ROI potential 5. Identify stakeholders and their roles 6. Evaluate business process flows """
Focuses on non-functional requirements and quality attributes:
# From agents/quality_requirements_agent.py SYSTEM_PROMPT = """You are a Quality Requirements Analysis Expert specializing in evaluating quality and non-functional requirements. Your role is to: 1. Assess performance requirements and scalability needs 2. Evaluate security requirements and compliance needs 3. Analyze availability and reliability requirements 4. Assess maintainability and extensibility needs 5. Evaluate usability and user experience requirements 6. Analyze operational monitoring and observability needs """
Analyzes technical constraints and external integrations:
# From agents/constraints_agent.py SYSTEM_PROMPT = """You are a Technical Constraints Analysis Expert specializing in evaluating constraints and external integration requirements. Your role is to: 1. Assess technical constraints and technology limitations 2. Evaluate external system integration requirements 3. Analyze regulatory and compliance constraints 4. Assess infrastructure and deployment constraints 5. Evaluate resource and budget constraints 6. Analyze operational and maintenance constraints """
Synthesizes all evaluations into concrete estimates:
# From agents/estimation_agent_v2.py def generate_estimate(self, deliverables, system_requirements, evaluation_feedback): """Generate comprehensive estimation based on multi-agent analysis""" # Calculate effort using complexity and risk factors final_effort = base_effort * complexity_factor * risk_factor cost = final_effort * daily_rate return EstimationResult( deliverable_estimates=estimates, financial_summary=financial_summary, technical_assumptions=technical_assumptions, overall_confidence=overall_confidence, key_risks=key_risks, recommendations=recommendations )
After parallel evaluation, the system generates an initial estimate:
Real Execution Result:
💰 Estimation Results:
Total Effort: 171.00000000000003 person-days
Total Amount: $85,500.00
Confidence: 0.59
📋 All Deliverable Estimates Details:
--------------------------------------------------------------------------------
No. Deliverable Name Base Effort Final Effort Amount Confidence
--------------------------------------------------------------------------------
1 Requirements Definition 5.0 6.5 $3,250.00 0.70
2 Basic Design Document 8.0 10.4 $5,200.00 0.70
3 Detailed Design Documen 10.0 13.0 $6,500.00 0.60
4 Database Design 10.0 15.6 $7,800.00 0.60
5 API Design 10.0 15.6 $7,800.00 0.60
6 Frontend Development 15.0 24.3 $12,150.00 0.50
7 Backend Development 20.0 31.2 $15,600.00 0.50
8 Admin Panel 10.0 13.0 $6,500.00 0.60
9 Unit Testing 10.0 13.0 $6,500.00 0.60
10 Integration Testing 10.0 13.0 $6,500.00 0.60
11 Operation Manual 5.0 5.0 $2,500.00 0.80
12 Deployment 8.0 10.4 $5,200.00 0.70
--------------------------------------------------------------------------------
Total 171.0 $85,500.00
This is where the revolutionary aspect of the system shines. The human provides feedback that represents tacit knowledge - implicit understanding that wasn't captured in the initial requirements:
Real Human Input:
Do you approve? (y/n/modification request): Performance expectations are implicit in our vision. The system must handle 10,000 concurrent users and ensure sub-2-second response time on key pages. Please reflect this in the estimation.
This feedback represents critical tacit knowledge that was missing from the original requirements but essential for accurate estimation.
The system processes the human feedback and automatically refines the estimate:
# From agents/estimation_agent_v2.py def refine_estimate(self, current_estimate, user_feedback, evaluation_feedback, previous_estimate=None): """Refine estimation based on user feedback and previous iterations""" # Analyze user feedback for new requirements # Adjust complexity factors based on feedback # Add new deliverables if needed # Recalculate all estimates return refined_estimation_result
Real Execution Result:
🔄 Improving the estimate...
🧮 Recalculating estimate reflecting modification requests...
✅ Improvement completed
💰 Estimation Results:
Total Effort: 272.54999999999995 person-days
Total Amount: $136,275.00
Confidence: 0.56
📋 All Deliverable Estimates Details:
--------------------------------------------------------------------------------
No. Deliverable Name Base Effort Final Effort Amount Confidence
--------------------------------------------------------------------------------
1 Requirements Definition 5.0 6.5 $3,250.00 0.70
2 Basic Design Document 8.0 10.4 $5,200.00 0.70
3 Detailed Design Documen 10.0 13.0 $6,500.00 0.60
4 Database Design 10.0 15.6 $7,800.00 0.60
5 API Design 10.0 15.6 $7,800.00 0.60
6 Frontend Development 15.0 31.5 $15,750.00 0.50
7 Backend Development 20.0 46.8 $23,400.00 0.50
8 Admin Panel 10.0 13.0 $6,500.00 0.60
9 Unit Testing 10.0 13.0 $6,500.00 0.60
10 Integration Testing 10.0 13.0 $6,500.00 0.60
11 Operation Manual 5.0 5.0 $2,500.00 0.80
12 Deployment 8.0 10.4 $5,200.00 0.70
13 Performance Optimizatio 20.0 45.0 $22,500.00 0.50 ← NEW!
14 Load Testing & Performa 15.0 33.8 $16,875.00 0.50 ← NEW!
--------------------------------------------------------------------------------
Total 272.5 $136,275.00
This is the revolutionary aspect: The AI didn't just adjust existing estimates - it automatically identified and added 2 completely new deliverables:
This demonstrates the system's ability to understand implicit requirements and translate human tacit knowledge into concrete deliverables and estimates.
The system supports unlimited iterations of human feedback and AI refinement:
# From workflow_orchestrator_simple.py def _execute_user_interaction(self, state: EstimationState) -> EstimationState: """Execute user interaction loop with unlimited iterations""" max_iterations = 3 # Configurable limit iteration_count = 0 while iteration_count < max_iterations: # Display current estimate self._display_estimation_results(state) # Get user feedback user_input = input("Do you approve? (y/n/modification request): ").strip() if user_input.lower() == 'y': break elif user_input.lower() == 'n': # Handle rejection break else: # Process modification request state = self._execute_refinement(state, user_input) iteration_count += 1 return state
This iterative loop is the core innovation - it allows the system to continuously incorporate human tacit knowledge, refining estimates until they match human intuition and experience.
The system outputs an enhanced Excel file containing:
# From utils/excel_processor.py def create_estimation_output(self, estimation_result, output_path): """Create comprehensive Excel output with all estimates""" # Create detailed estimation sheet for i, deliverable in enumerate(estimation_result.deliverable_estimates): ws.cell(row=i+2, column=1, value=deliverable.name) ws.cell(row=i+2, column=2, value=deliverable.base_effort_days) ws.cell(row=i+2, column=3, value=deliverable.final_effort_days) ws.cell(row=i+2, column=4, value=self.currency_formatter.format_amount(deliverable.cost)) ws.cell(row=i+2, column=5, value=deliverable.confidence_score) # Add financial summary # Add technical assumptions # Add risk factors and recommendations
Real Final Result:
📤 Outputting results...
Estimate output to: ./output/estimate_20250714-174840.xlsx
Total amount: $136,275.00
Session log output to: ./output/session_log.json
The final Excel contains:
┌─────────────────────────────────────────────────────────────┐
│ DeliverableEstimatePro v3 │
├─────────────────────────────────────────────────────────────┤
│ main.py (Application Control) │
│ ├─ Input Processing (Excel + System Requirements) │
│ ├─ Workflow Execution (SimpleWorkflowOrchestrator) │
│ └─ Result Output (Excel + Session Log) │
├─────────────────────────────────────────────────────────────┤
│ SimpleWorkflowOrchestrator (Workflow Control) │
│ ├─ Parallel Evaluation Execution (3 agents simultaneously) │
│ ├─ Estimation Generation (EstimationAgent) │
│ └─ Interactive Loop (Modification Request Handling) │
├─────────────────────────────────────────────────────────────┤
│ 4 AI Agents │
│ ├─ BusinessRequirementsAgent (Business/Functional Req.) │
│ ├─ QualityRequirementsAgent (Quality/Non-Functional Req.) │
│ ├─ ConstraintsAgent (Constraints/External Integration) │
│ └─ EstimationAgent (Estimation Generation) │
├─────────────────────────────────────────────────────────────┤
│ Common Foundation Layer │
│ ├─ PydanticAIAgent (Agent Base Class) │
│ ├─ PydanticModels (Data Structure Definition) │
│ ├─ StateManager (State Management) │
│ ├─ CurrencyUtils (Multi-currency Support) │
│ └─ i18n_utils (Internationalization Utilities) │
└─────────────────────────────────────────────────────────────┘
Each agent specializes in a single domain:
File: agents/pydantic_agent_base.py
Role: Unified foundation for all agents
Key Methods:
def execute_with_pydantic(self, user_input: str, pydantic_model: Type[BaseModel]) -> Dict[str, Any]: """Execute with Pydantic structured output"""
Features:
File: agents/business_requirements_agent_v2.py
Domain: Business and functional requirements evaluation
System Prompt Key Points:
Output Data Type: BusinessEvaluationResult
Evaluation Aspects:
File: agents/quality_requirements_agent.py
Domain: Quality and non-functional requirements evaluation
Output Data Type: QualityEvaluationResult
Evaluation Aspects:
Effort Impact Calculation: Quantifies the impact of each requirement on effort as a percentage
File: agents/constraints_agent.py
Domain: Constraints and external integration requirements evaluation
Output Data Type: ConstraintsEvaluationResult
Evaluation Aspects:
Risk Management: Feasibility risk assessment and mitigation strategy proposals
File: agents/estimation_agent_v2.py
Domain: Estimation generation and accuracy improvement
Output Data Type: EstimationResult
Key Functions:
Estimation Algorithm:
Final Effort = Base Effort × Complexity Factor × Risk Factor
Cost = Final Effort × Daily Rate
# 3-agent simultaneous execution with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor: futures = [ executor.submit(run_business_evaluation), executor.submit(run_quality_evaluation), executor.submit(run_constraints_evaluation) ]
# Evaluation result integration evaluation_feedback = { "business_evaluation": state.get("business_evaluation"), "quality_evaluation": state.get("quality_evaluation"), "constraints_evaluation": state.get("constraints_evaluation") }
EstimationResult (Main Model) ├── deliverable_estimates: List[DeliverableEstimate] ├── financial_summary: FinancialSummary ├── technical_assumptions: TechnicalAssumptions ├── overall_confidence: float ├── key_risks: List[str] └── recommendations: List[str]
BusinessEvaluationResult ├── overall_score: int (0-100) ├── business_purpose: BusinessEvaluationDetail ├── functional_requirements: BusinessEvaluationDetail ├── user_stories: BusinessEvaluationDetail ├── business_value: BusinessEvaluationDetail ├── stakeholders: BusinessEvaluationDetail ├── business_flow: BusinessEvaluationDetail └── improvement_questions: List[ImprovementQuestion]
int (0-100 range)float (0-1 range)float (person-day units)int (currency units)float (percentage)class DeliverableEstimate(BaseModel): name: str = Field(description="Deliverable name") base_effort_days: float = Field(description="Base effort (person-days)") confidence_score: float = Field(description="Confidence (0-1)") @validator('confidence_score') def validate_confidence(cls, v): if not 0 <= v <= 1: raise ValueError('Confidence must be in 0-1 range') return v
1. Input Processing
├─ Excel file loading
├─ System requirements collection
└─ Data validation
2. Parallel Evaluation Execution
├─ BusinessRequirementsAgent
├─ QualityRequirementsAgent
└─ ConstraintsAgent
3. Estimation Generation
├─ Evaluation result integration
├─ EstimationAgent execution
└─ Estimation calculation
4. Interactive Loop
├─ Result display
├─ User approval confirmation
└─ Modification request handling
5. Result Output
├─ Excel output
└─ Session log output
File: state_manager.py
Functions:
# True parallel execution using ThreadPoolExecutor with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor: futures = [ executor.submit(run_business_evaluation), executor.submit(run_quality_evaluation), executor.submit(run_constraints_evaluation) ]
def _execute_refinement(self, state: EstimationState) -> EstimationState: """Estimation improvement through modification request reflection""" # History saving state = save_iteration_to_history(state, user_feedback) # Modification request reflection result = self.estimation_agent.refine_estimate( current_estimate, user_feedback, evaluation_feedback, previous_estimate )
File: utils/currency_utils.py
class CurrencyFormatter: """Multi-currency formatting utility""" CURRENCY_SYMBOLS = { 'USD': '$', 'JPY': '¥', 'EUR': '€', 'GBP': '£' } def format_amount(self, amount: float, currency: str = None) -> str: """Format amount with appropriate currency symbol and formatting""" currency = currency or self.currency symbol = self.CURRENCY_SYMBOLS.get(currency, currency) if currency == 'JPY': return f"{symbol}{amount:,.0f}" else: return f"{symbol}{amount:,.2f}"
File: .env
CURRENCY=USD
DAILY_RATE=500
DEBUG_MODE=fales
The system automatically applies currency formatting throughout:
While DeliverableEstimatePro v3 represents a significant advancement in estimation methodology, it is important to acknowledge its current limitations for transparent evaluation and future improvement:
DeliverableEstimatePro v3 builds upon and extends several established research domains while introducing novel contributions to the field.
Our system extends classical multi-agent architectures by introducing domain-specialized agents with human feedback integration:
Previous Work:
Our Contribution: First application of specialized multi-agent architecture to software estimation with real-time human collaboration loops.
Traditional estimation research has focused on mathematical models and historical data analysis:
Established Methods:
Research Gap Addressed: None of these methods effectively capture and integrate tacit knowledge during the estimation process. Our system represents the first systematic approach to tacit knowledge integration in software estimation.
Recent advances in human-AI collaboration provide the theoretical foundation for our approach:
Foundational Research:
Our Extension: We demonstrate how iterative human-AI dialogue can surface implicit requirements and dynamically adjust project scope—a capability not demonstrated in previous estimation systems.
DeliverableEstimatePro v3 represents a paradigm shift in software project estimation. By combining multi-agent AI analysis with iterative human collaboration, it transforms estimation from a static calculation into a dynamic, intelligent dialogue.
This system establishes a new standard for AI-human collaborative estimation, proving that the future of software estimation lies not in replacing human expertise, but in amplifying it
through intelligent collaboration.
Our demonstration perfectly illustrates the system's revolutionary nature:
This is not just estimation - it's cognitive collaboration where AI and human intelligence combine to create results neither could achieve alone.
DeliverableEstimatePro v3 transforms software estimation from a painful, inaccurate process into an intelligent, collaborative experience that captures the full complexity of modern software projects while remaining accessible and actionable.
The future of estimation is here - and it's revolutionary.