wiki/implementation/implementation_adaptive_react_mode.md

Adaptive React Mode: Process-Focused Implementation

Core Problem

Current React mode is blind - it doesn't understand what the user actually wants and can't learn from mistakes. It generates code when user wants data, and has no way to improve.

How the Adaptive Engine Works

The Process Flow

1. User Request → 2. Intent Analysis → 3. Action Planning → 4. Execution → 
5. Content Validation → 6. Learning Update → 7. Progress Check → 8. Next Action

Step-by-Step Process

Step 1: Intent Analysis

What happens: System analyzes what user actually wants

• Input: User prompt "Calculate first 1000 prime numbers"
• Analysis: User wants DATA (numbers), not CODE (algorithms)
• Output: Intent object with dataType="numbers", format="raw_data"

Step 2: Action Planning

What happens: System plans action based on intent

• Input: Intent analysis + learned strategies
• Process: "User wants numbers → use ai.process with data delivery prompt"
• Output: Action plan with specific parameters

Step 3: Execution

What happens: Execute the planned action

• Input: Action plan
• Process: Call ai.process with "Deliver the first 1000 prime numbers as a list"
• Output: ActionResult with documents

Step 4: Content Validation

What happens: Check if delivered content matches intent

• Input: ActionResult + Intent analysis
• Process: "Does content contain actual numbers? Is it code or data?"
• Output: Validation result (success/failure + specific issues)

Step 5: Learning Update

What happens: Learn from the result

• Input: Validation result + action taken
• Process: "This action worked/didn't work for this type of request"
• Output: Updated strategy for future similar requests

Step 6: Progress Check

What happens: Determine if task is complete

• Input: Validation result + progress state
• Process: "Did we deliver what user wanted? What's still missing?"
• Output: Continue/Stop decision + next action suggestions

The Learning Mechanism

How Learning Works

1. After each action: System records what was attempted and how well it worked
2. Pattern recognition: System identifies successful vs failed approaches
3. Strategy update: System updates its approach for similar future requests
4. Adaptive planning: Next action is planned using learned strategies

Example Learning Process

Request: "Prime numbers"
Action 1: ai.process("Write code to generate primes") → Delivers code → FAIL
Learning: "For number requests, don't ask for code generation"
Action 2: ai.process("List the first 1000 prime numbers") → Delivers data → SUCCESS  
Learning: "For number requests, ask for data delivery directly"

The Validation Process

What Gets Validated

1. Data type match: Does content contain what user asked for?
2. Format match: Is it in the expected format?
3. Quality check: Is the content usable and complete?
4. Success criteria: Does it meet the specific requirements?

Example Validation

User wants: "First 1000 prime numbers"
Content delivered: "def generate_primes(n): ..."
Validation: 
- Data type: FAIL (code instead of numbers)
- Format: FAIL (code instead of data)
- Quality: FAIL (not usable as requested)
Result: FAIL - "Deliver actual numbers, not code"

The Progress Tracking

What Gets Tracked

1. Completed objectives: What has been successfully delivered
2. Partial achievements: What was partially successful
3. Failed attempts: What didn't work and why
4. Learning insights: What was learned from each attempt

Example Progress Tracking

Objective: "First 1000 prime numbers"
Attempt 1: Generated code → FAIL → Learned: Don't generate code for data requests
Attempt 2: Generated data → SUCCESS → Learned: Direct data delivery works
Progress: 100% complete, strategy updated for future number requests

Implementation Plan

Phase 1: Add Intent Analysis to React Mode

Goal: Make React mode understand what user actually wants

Changes to existing code:

1. Modify _observeBuild in reactMode.py:

   • Add content analysis to observation
   • Include actual content snippets, not just metadata
   • Add intent match assessment

2. Enhance extractReviewContent in promptFactoryPlaceholders.py:

   • Include content analysis in review
   • Add specific validation against user intent
   • Provide clear improvement suggestions

New files:

• gateway/modules/workflows/processing/adaptive/intentAnalyzer.py
• gateway/modules/workflows/processing/adaptive/contentValidator.py

Phase 2: Add Learning to React Mode

Goal: Make React mode learn from mistakes and improve

Changes to existing code:

1. Modify _refineDecide in reactMode.py:

   • Use learned strategies for action planning
   • Apply learned patterns to avoid repeated failures
   • Update strategies based on validation results

2. Enhance action selection prompts:

   • Include learned strategies in AI prompts
   • Add specific guidance based on past failures
   • Adapt prompts based on user intent type

New files:

• gateway/modules/workflows/processing/adaptive/learningEngine.py
• gateway/modules/workflows/processing/adaptive/strategyStore.py

Phase 3: Add Progress Tracking

Goal: Make React mode understand what has been accomplished

Changes to existing code:

1. Modify executeTask in reactMode.py:

   • Track progress across steps
   • Use progress to inform next actions
   • Stop when objectives are actually met

2. Enhance stopping logic:

   • Check if user intent has been fulfilled
   • Consider partial achievements
   • Make intelligent continue/stop decisions

New files:

• gateway/modules/workflows/processing/adaptive/progressTracker.py

Integration with Existing Refactoring

Follows Generic Workflow Processing Structure

gateway/modules/workflows/processing/
├── core/                           # Common functionality
│   ├── actionExecutor.py          # Enhanced with adaptive execution
│   └── messageCreator.py          # Enhanced with adaptive messaging
├── modes/                         # Mode-specific implementations
│   └── reactMode.py              # Enhanced with adaptive capabilities
├── shared/                        # Shared utilities
│   └── promptFactoryPlaceholders.py  # Enhanced with adaptive prompts
└── adaptive/                      # NEW: Adaptive components
    ├── intentAnalyzer.py
    ├── contentValidator.py
    ├── learningEngine.py
    └── progressTracker.py

Key Integration Points

1. ActionExecutor: Enhanced to use learned strategies
2. MessageCreator: Enhanced to show adaptive progress
3. ReactMode: Enhanced with adaptive process flow
4. PromptFactory: Enhanced with learned prompt patterns

Implementation Steps

Step 1: Create Adaptive Directory

mkdir -p gateway/modules/workflows/processing/adaptive

Step 2: Implement Core Adaptive Components

1. Create intentAnalyzer.py - analyzes user intent
2. Create contentValidator.py - validates delivered content
3. Create learningEngine.py - learns from feedback
4. Create progressTracker.py - tracks progress

Step 3: Integrate with Existing React Mode

1. Modify reactMode.py to use adaptive components
2. Enhance observation building with content analysis
3. Add learning to action planning
4. Add progress tracking to execution flow

Step 4: Test and Validate

1. Test with various user intents
2. Validate learning effectiveness
3. Ensure integration with existing refactoring

Expected Results

Before (Current React Mode)

• Blind to user intent
• No learning from mistakes
• Fake success indicators
• No progress understanding

After (Adaptive React Mode)

• Understands user intent
• Learns and improves over time
• Real validation and success assessment
• Tracks progress and makes intelligent decisions

Example Improvement

User: "Calculate first 1000 prime numbers"

Current React Mode:
Step 1: ai.process("Write code to generate primes") → Code → FAIL
Step 2: ai.process("Write code to generate primes") → Code → FAIL
Step 3: ai.process("Write code to generate primes") → Code → FAIL
Result: User gets code, not numbers

Adaptive React Mode:
Step 1: ai.process("Write code to generate primes") → Code → FAIL
Learning: "For number requests, don't ask for code"
Step 2: ai.process("List the first 1000 prime numbers") → Numbers → SUCCESS
Learning: "For number requests, ask for data directly"
Result: User gets actual numbers