Upload folder using huggingface_hub

agentic_system.py

@@ -425,17 +425,17 @@ class AgenticSystem:
         # Initialize components
         self.agents: Dict[str, Agent] = {}
         self.reasoning_engine = ReasoningEngine(
-            min_confidence=0.7,
-            parallel_threshold=3,
-            learning_rate=0.1,
-            strategy_weights={
+            min_confidence=self.config.get('min_confidence', 0.7),
+            parallel_threshold=self.config.get('parallel_threshold', 3),
+            learning_rate=self.config.get('learning_rate', 0.1),
+            strategy_weights=self.config.get('strategy_weights', {
                 "LOCAL_LLM": 0.8,
                 "CHAIN_OF_THOUGHT": 0.6,
                 "TREE_OF_THOUGHTS": 0.5,
                 "META_LEARNING": 0.4
-            }
+            })
         )
-        self.meta_learning = MetaLearningStrategy()
+        self.meta_learning = MetaLearningStrategy(config)
         
         # System state
         self.state = "initialized"

app.py

@@ -84,9 +84,21 @@ class ChatInterface:
         if not check_network():
             logger.warning("Network connectivity issues detected - continuing with degraded functionality")
             
-        # Initialize core components
-        self.orchestrator = AgentOrchestrator()
-        self.agentic_system = AgenticSystem()
+        # Initialize core components with consistent configuration
+        config = {
+            "min_confidence": 0.7,
+            "parallel_threshold": 3,
+            "learning_rate": 0.1,
+            "strategy_weights": {
+                "LOCAL_LLM": 0.8,
+                "CHAIN_OF_THOUGHT": 0.6,
+                "TREE_OF_THOUGHTS": 0.5,
+                "META_LEARNING": 0.4
+            }
+        }
+        
+        self.orchestrator = AgentOrchestrator(config)
+        self.agentic_system = AgenticSystem(config)
         self.team_manager = TeamManager(self.orchestrator)
         self.chat_history = []
         self.active_objectives = {}

meta_learning.py

@@ -44,7 +44,21 @@ class MetaLearningSystem:
     
     def __init__(self):
         self.logger = logging.getLogger(__name__)
-        self.quantum_system = QuantumLearningSystem()
+        
+        # Initialize quantum system with consistent configuration
+        quantum_config = {
+            "min_confidence": 0.7,
+            "parallel_threshold": 3,
+            "learning_rate": 0.1,
+            "strategy_weights": {
+                "LOCAL_LLM": 0.8,
+                "CHAIN_OF_THOUGHT": 0.6,
+                "TREE_OF_THOUGHTS": 0.5,
+                "META_LEARNING": 0.4
+            }
+        }
+        
+        self.quantum_system = QuantumLearningSystem(quantum_config)
         self.strategies = {}
         self.performance_history = []
         self.meta_parameters = MetaParameters()

orchestrator.py

@@ -124,10 +124,10 @@ class AgentOrchestrator:
             parallel_threshold=5,
             learning_rate=0.1,
             strategy_weights={
-                ReasoningMode.CHAIN_OF_THOUGHT: 1.0,
-                ReasoningMode.TREE_OF_THOUGHTS: 1.0,
-                ReasoningMode.META_LEARNING: 1.5,
-                ReasoningMode.LOCAL_LLM: 2.0
+                "LOCAL_LLM": 2.0,
+                "CHAIN_OF_THOUGHT": 1.0,
+                "TREE_OF_THOUGHTS": 1.0,
+                "META_LEARNING": 1.5
             }
         )
         

reasoning/analogical.py

@@ -74,15 +74,26 @@ class AnalogicalReasoning(ReasoningStrategy):
     - Learning from experience
     """
     
-    def __init__(self,
-                 min_similarity: float = 0.6,
-                 max_candidates: int = 5,
-                 adaptation_threshold: float = 0.7,
-                 learning_rate: float = 0.1):
-        self.min_similarity = min_similarity
-        self.max_candidates = max_candidates
-        self.adaptation_threshold = adaptation_threshold
-        self.learning_rate = learning_rate
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize analogical reasoning."""
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Analogical reasoning specific parameters
+        self.min_similarity = self.config.get('min_similarity', 0.6)
+        self.max_candidates = self.config.get('max_candidates', 5)
+        self.adaptation_threshold = self.config.get('adaptation_threshold', 0.7)
         
         # Knowledge base
         self.patterns: Dict[str, AnalogicalPattern] = {}

reasoning/chain_of_thought.py

@@ -41,14 +41,19 @@ class ChainOfThoughtStrategy(ReasoningStrategy):
     """
     
     def __init__(self, 
-                 max_chain_length: int = 10,
                  min_confidence: float = 0.7,
-                 exploration_breadth: int = 3,
-                 enable_reflection: bool = True):
-        self.max_chain_length = max_chain_length
+                 parallel_threshold: int = 3,
+                 learning_rate: float = 0.1,
+                 strategy_weights: Optional[Dict[str, float]] = None):
         self.min_confidence = min_confidence
-        self.exploration_breadth = exploration_breadth
-        self.enable_reflection = enable_reflection
+        self.parallel_threshold = parallel_threshold
+        self.learning_rate = learning_rate
+        self.strategy_weights = strategy_weights or {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        }
         self.thought_history: List[Thought] = []
         
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:

reasoning/emergent.py

@@ -22,17 +22,35 @@ class EmergentReasoning(ReasoningStrategy):
         super().__init__()
         self.config = config or {}
         
-        # Initialize component strategies
-        self.meta_learner = MetaLearningStrategy()
-        self.chain_of_thought = ChainOfThoughtStrategy()
-        self.tree_of_thoughts = TreeOfThoughtsStrategy()
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Initialize component strategies with shared config
+        strategy_config = {
+            'min_confidence': self.min_confidence,
+            'parallel_threshold': self.parallel_threshold,
+            'learning_rate': self.learning_rate,
+            'strategy_weights': self.strategy_weights
+        }
+        
+        self.meta_learner = MetaLearningStrategy(strategy_config)
+        self.chain_of_thought = ChainOfThoughtStrategy(strategy_config)
+        self.tree_of_thoughts = TreeOfThoughtsStrategy(strategy_config)
         
         # Configure weights for strategy combination
-        self.weights = {
+        self.weights = self.config.get('combination_weights', {
             'meta': 0.4,
             'chain': 0.3,
             'tree': 0.3
-        }
+        })
     
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """

reasoning/local_llm.py

@@ -11,11 +11,27 @@ from .base import ReasoningStrategy
 class LocalLLMStrategy(ReasoningStrategy):
     """Implements reasoning using local LLM."""
     
-    def __init__(self):
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
         """Initialize the local LLM strategy."""
-        self.repo_id = "tensorblock/Llama-3.2-3B-Overthinker-GGUF"
-        self.filename = "Llama-3.2-3B-Overthinker-Q8_0.gguf"
-        self.model_dir = "models"
+        super().__init__()
+        self.config = config or {}
+        
+        # Configure parameters with defaults
+        self.repo_id = self.config.get('repo_id', "gpt-omni/mini-omni2")
+        self.filename = self.config.get('filename', "mini-omni2.gguf")
+        self.model_dir = self.config.get('model_dir', "models")
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
         self.logger = logging.getLogger(__name__)
         self.model = None
         

reasoning/monetization.py

@@ -41,7 +41,16 @@ class MonetizationOptimizer:
     5. Increases lifetime value
     """
     
-    def __init__(self):
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize monetization optimizer."""
+        self.config = config or {}
+        
+        # Configure optimization parameters
+        self.min_revenue = self.config.get('min_revenue', 1_000_000)
+        self.min_margin = self.config.get('min_margin', 0.3)
+        self.max_churn = self.config.get('max_churn', 0.1)
+        self.target_ltv = self.config.get('target_ltv', 1000)
+        
         self.models: Dict[str, MonetizationModel] = {}
         self.streams: Dict[str, RevenueStream] = {}
         
@@ -293,7 +302,26 @@ class MonetizationStrategy(ReasoningStrategy):
         """Initialize monetization strategy."""
         super().__init__()
         self.config = config or {}
-        self.optimizer = MonetizationOptimizer()
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Initialize optimizer with shared config
+        optimizer_config = {
+            'min_revenue': self.config.get('min_revenue', 1_000_000),
+            'min_margin': self.config.get('min_margin', 0.3),
+            'max_churn': self.config.get('max_churn', 0.1),
+            'target_ltv': self.config.get('target_ltv', 1000)
+        }
+        self.optimizer = MonetizationOptimizer(optimizer_config)
     
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """

reasoning/multimodal.py

@@ -35,14 +35,41 @@ class MultiModalReasoning(ReasoningStrategy):
         super().__init__()
         self.config = config or {}
         
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Configure model repositories
+        self.models = self.config.get('models', {
+            'img2img': {
+                'repo_id': 'enhanceaiteam/Flux-Uncensored-V2',
+                'filename': 'Flux-Uncensored-V2.safetensors'
+            },
+            'img2vid': {
+                'repo_id': 'stabilityai/stable-video-diffusion-img2vid-xt',
+                'filename': 'svd_xt.safetensors'
+            },
+            'any2any': {
+                'repo_id': 'deepseek-ai/JanusFlow-1.3B',
+                'filename': 'janusflow-1.3b.safetensors'
+            }
+        })
+        
         # Configure modality weights
-        self.weights = {
+        self.weights = self.config.get('modality_weights', {
             'text': 0.4,
             'image': 0.3,
             'audio': 0.1,
             'video': 0.1,
             'structured': 0.1
-        }
+        })
     
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """

reasoning/neurosymbolic.py

@@ -43,7 +43,18 @@ class NeurosymbolicReasoning(ReasoningStrategy):
         super().__init__()
         self.config = config or {}
         
-        # Configure parameters
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Neurosymbolic specific parameters
         self.feature_threshold = self.config.get('feature_threshold', 0.1)
         self.rule_confidence_threshold = self.config.get('rule_confidence', 0.7)
         self.max_rules = self.config.get('max_rules', 10)

reasoning/quantum.py

@@ -34,6 +34,17 @@ class QuantumReasoning(ReasoningStrategy):
         super().__init__()
         self.config = config or {}
         
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
         # Configure quantum parameters
         self.num_qubits = self.config.get('num_qubits', 3)
         self.measurement_threshold = self.config.get('measurement_threshold', 0.1)

reasoning/recursive.py

@@ -65,15 +65,25 @@ class RecursiveReasoning(ReasoningStrategy):
     - Optimization strategies
     """
     
-    def __init__(self,
-                 max_depth: int = 5,
-                 min_confidence: float = 0.7,
-                 parallel_threshold: int = 3,
-                 optimization_rounds: int = 2):
-        self.max_depth = max_depth
-        self.min_confidence = min_confidence
-        self.parallel_threshold = parallel_threshold
-        self.optimization_rounds = optimization_rounds
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize recursive reasoning."""
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Recursive reasoning specific parameters
+        self.max_depth = self.config.get('max_depth', 5)
+        self.optimization_rounds = self.config.get('optimization_rounds', 2)
         
         # Problem tracking
         self.subproblems: Dict[str, Subproblem] = {}

reasoning/specialized.py

@@ -22,16 +22,34 @@ class SpecializedReasoning(ReasoningStrategy):
         super().__init__()
         self.config = config or {}
         
-        # Initialize component strategies
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Initialize component strategies with shared config
+        strategy_config = {
+            'min_confidence': self.min_confidence,
+            'parallel_threshold': self.parallel_threshold,
+            'learning_rate': self.learning_rate,
+            'strategy_weights': self.strategy_weights
+        }
+        
         self.strategies = {
-            'code_rewrite': CodeRewriteStrategy(),
-            'security_audit': SecurityAuditStrategy(),
-            'performance': PerformanceOptimizationStrategy(),
-            'testing': TestGenerationStrategy(),
-            'documentation': DocumentationStrategy(),
-            'api_design': APIDesignStrategy(),
-            'dependencies': DependencyManagementStrategy(),
-            'code_review': CodeReviewStrategy()
+            'code_rewrite': CodeRewriteStrategy(strategy_config),
+            'security_audit': SecurityAuditStrategy(strategy_config),
+            'performance': PerformanceOptimizationStrategy(strategy_config),
+            'testing': TestGenerationStrategy(strategy_config),
+            'documentation': DocumentationStrategy(strategy_config),
+            'api_design': APIDesignStrategy(strategy_config),
+            'dependencies': DependencyManagementStrategy(strategy_config),
+            'code_review': CodeReviewStrategy(strategy_config)
         }
     
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
@@ -134,6 +152,10 @@ class CodeRewriteStrategy(ReasoningStrategy):
     5. Ensures backward compatibility
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Rewrite code while preserving functionality."""
         try:
@@ -172,6 +194,10 @@ class SecurityAuditStrategy(ReasoningStrategy):
     5. Monitors security state
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Perform security audit and generate recommendations."""
         try:
@@ -208,6 +234,10 @@ class PerformanceOptimizationStrategy(ReasoningStrategy):
     5. Validates optimizations
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Optimize code performance."""
         try:
@@ -244,6 +274,10 @@ class TestGenerationStrategy(ReasoningStrategy):
     5. Maintains test suite
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate comprehensive test suite."""
         try:
@@ -283,6 +317,10 @@ class DocumentationStrategy(ReasoningStrategy):
     5. Validates completeness
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate and maintain documentation."""
         try:
@@ -322,6 +360,10 @@ class APIDesignStrategy(ReasoningStrategy):
     5. Maintains versioning
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Design and validate API."""
         try:
@@ -358,6 +400,10 @@ class DependencyManagementStrategy(ReasoningStrategy):
     5. Maintains security
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Manage and optimize dependencies."""
         try:
@@ -394,6 +440,10 @@ class CodeReviewStrategy(ReasoningStrategy):
     5. Validates fixes
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Perform comprehensive code review."""
         try:

reasoning/tree_of_thoughts.py

@@ -44,16 +44,19 @@ class TreeOfThoughtsStrategy(ReasoningStrategy):
     """
     
     def __init__(self, 
-                 max_depth: int = 5,
-                 beam_width: int = 3,
-                 min_confidence: float = 0.6,
-                 exploration_factor: float = 0.3,
-                 prune_threshold: float = 0.4):
-        self.max_depth = max_depth
-        self.beam_width = beam_width
+                 min_confidence: float = 0.7,
+                 parallel_threshold: int = 3,
+                 learning_rate: float = 0.1,
+                 strategy_weights: Optional[Dict[str, float]] = None):
         self.min_confidence = min_confidence
-        self.exploration_factor = exploration_factor
-        self.prune_threshold = prune_threshold
+        self.parallel_threshold = parallel_threshold
+        self.learning_rate = learning_rate
+        self.strategy_weights = strategy_weights or {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        }
         self.node_history: Dict[str, TreeNode] = {}
         self.path_patterns: Dict[str, float] = defaultdict(float)
         
@@ -119,7 +122,7 @@ class TreeOfThoughtsStrategy(ReasoningStrategy):
         beam = [(root.evaluation_score, root)]
         visited: Set[str] = set()
         
-        for depth in range(self.max_depth):
+        for depth in range(5):
             next_beam = []
             
             for _, node in beam:
@@ -136,12 +139,12 @@ class TreeOfThoughtsStrategy(ReasoningStrategy):
                 
                 # Add to beam
                 for child in evaluated_children:
-                    if child.evaluation_score > self.prune_threshold:
+                    if child.evaluation_score > 0.4:
                         next_beam.append((child.evaluation_score, child))
                         node.children.append(child)
             
             # Select best nodes for next iteration
-            beam = heapq.nlargest(self.beam_width, next_beam, key=lambda x: x[0])
+            beam = heapq.nlargest(3, next_beam, key=lambda x: x[0])
             
             if not beam:
                 break
@@ -213,7 +216,7 @@ class TreeOfThoughtsStrategy(ReasoningStrategy):
             sorted_children = sorted(node.children, key=lambda x: x.evaluation_score, reverse=True)
             
             # Explore top paths
-            for child in sorted_children[:self.beam_width]:
+            for child in sorted_children[:3]:
                 path.append(child)
                 dfs(child, path)
                 path.pop()
@@ -224,7 +227,7 @@ class TreeOfThoughtsStrategy(ReasoningStrategy):
         evaluated_paths = await self._evaluate_paths(paths, context)
         
         # Return top paths
-        return sorted(evaluated_paths, key=lambda p: sum(n.evaluation_score for n in p), reverse=True)[:self.beam_width]
+        return sorted(evaluated_paths, key=lambda p: sum(n.evaluation_score for n in p), reverse=True)[:3]
 
     async def _synthesize_conclusion(self, paths: List[List[TreeNode]], context: Dict[str, Any]) -> Dict[str, Any]:
         """Synthesize final conclusion from best paths."""

reasoning/venture_strategies.py

@@ -67,6 +67,21 @@ class AIStartupStrategy(ReasoningStrategy):
     5. Optimizes revenue streams
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate AI startup strategy."""
         try:
@@ -108,6 +123,21 @@ class SaaSVentureStrategy(ReasoningStrategy):
     5. Maximizes recurring revenue
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate SaaS venture strategy."""
         try:
@@ -148,6 +178,21 @@ class AutomationVentureStrategy(ReasoningStrategy):
     5. Maximizes ROI
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate automation venture strategy."""
         try:
@@ -188,6 +233,21 @@ class DataVentureStrategy(ReasoningStrategy):
     5. Maximizes data value
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate data venture strategy."""
         try:
@@ -228,6 +288,21 @@ class APIVentureStrategy(ReasoningStrategy):
     5. Maximizes API value
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate API venture strategy."""
         try:
@@ -268,6 +343,21 @@ class MarketplaceVentureStrategy(ReasoningStrategy):
     5. Maximizes transaction value
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate marketplace venture strategy."""
         try:
@@ -308,6 +398,21 @@ class VenturePortfolioStrategy(ReasoningStrategy):
     5. Maximizes portfolio value
     """
     
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+    
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Generate venture portfolio strategy."""
         try:
@@ -433,18 +538,36 @@ class VentureStrategy(ReasoningStrategy):
         super().__init__()
         self.config = config or {}
         
-        # Initialize component strategies
+        # Standard reasoning parameters
+        self.min_confidence = self.config.get('min_confidence', 0.7)
+        self.parallel_threshold = self.config.get('parallel_threshold', 3)
+        self.learning_rate = self.config.get('learning_rate', 0.1)
+        self.strategy_weights = self.config.get('strategy_weights', {
+            "LOCAL_LLM": 0.8,
+            "CHAIN_OF_THOUGHT": 0.6,
+            "TREE_OF_THOUGHTS": 0.5,
+            "META_LEARNING": 0.4
+        })
+        
+        # Initialize component strategies with shared config
+        strategy_config = {
+            'min_confidence': self.min_confidence,
+            'parallel_threshold': self.parallel_threshold,
+            'learning_rate': self.learning_rate,
+            'strategy_weights': self.strategy_weights
+        }
+        
         self.strategies = {
-            VentureType.AI_STARTUP: AIStartupStrategy(),
-            VentureType.SAAS: SaaSVentureStrategy(),
-            VentureType.AUTOMATION_SERVICE: AutomationVentureStrategy(),
-            VentureType.DATA_ANALYTICS: DataVentureStrategy(),
-            VentureType.API_SERVICE: APIVentureStrategy(),
-            VentureType.MARKETPLACE: MarketplaceVentureStrategy()
+            VentureType.AI_STARTUP: AIStartupStrategy(strategy_config),
+            VentureType.SAAS: SaaSVentureStrategy(strategy_config),
+            VentureType.AUTOMATION_SERVICE: AutomationVentureStrategy(strategy_config),
+            VentureType.DATA_ANALYTICS: DataVentureStrategy(strategy_config),
+            VentureType.API_SERVICE: APIVentureStrategy(strategy_config),
+            VentureType.MARKETPLACE: MarketplaceVentureStrategy(strategy_config)
         }
         
         # Portfolio strategy for multi-venture optimization
-        self.portfolio_strategy = VenturePortfolioStrategy()
+        self.portfolio_strategy = VenturePortfolioStrategy(strategy_config)
     
     async def reason(self, query: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """

team_management.py

@@ -486,7 +486,17 @@ class TeamManager:
 class Agent:
     def __init__(self, profile: Dict, reasoning_engine: UnifiedReasoningEngine, meta_learning: bool):
         self.profile = profile
-        self.reasoning_engine = reasoning_engine
+        self.reasoning_engine = reasoning_engine if reasoning_engine else UnifiedReasoningEngine(
+            min_confidence=0.7,
+            parallel_threshold=3,
+            learning_rate=0.1,
+            strategy_weights={
+                "LOCAL_LLM": 0.8,
+                "CHAIN_OF_THOUGHT": 0.6,
+                "TREE_OF_THOUGHTS": 0.5,
+                "META_LEARNING": 0.4
+            }
+        )
         self.meta_learning = meta_learning
         self.state = AgentState.IDLE