Replace quantum random number API with regular random numbers

- Remove ANU Quantum API dependency and all related configuration
- Replace quantum_numbers_queue with random_numbers_queue in app.py
- Simplify quantum_emotion_service.py to use standard random.random()
- Remove quantum API validation from parallel initialization
- Update emotional_agent.py to use regular random numbers
- Clean up environment variables (remove ANU_QUANTUM_API_KEY)
- Update documentation (README, DOCKER.md, Endpoints.md)
- Remove quantum config from models.yaml and app.json

All emotion randomness now uses Python's built-in random module
instead of making external API calls. Functionality remains the same
but without the external dependency.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git add:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.env.example

@@ -12,10 +12,5 @@ INFLECTION_AI_API_KEY=your_inflection_ai_api_key_here
 AZURE_TEXT_ANALYTICS_KEY=your_azure_text_analytics_key_here
 AZURE_TEXT_ANALYTICS_ENDPOINT=https://your-resource.cognitiveservices.azure.com/
 
-# ANU Quantum API Key (Optional - for quantum randomness)
-# If not provided, the app will use pseudo-random numbers
-# Get your key from: https://quantumnumbers.anu.edu.au/
-ANU_QUANTUM_API_KEY=your_quantum_api_key_here
-
 # Port (Optional - defaults to 7860 for Hugging Face Spaces)
 PORT=7860

DOCKER.md

@@ -71,7 +71,6 @@ docker build -t codejediondockerhub/digital-galatea:latest .
 
 - `AZURE_TEXT_ANALYTICS_KEY` - Azure Text Analytics key
 - `AZURE_TEXT_ANALYTICS_ENDPOINT` - Azure endpoint URL
-- `ANU_QUANTUM_API_KEY` - Quantum randomness API key
 - `PORT` - Server port (default: 7860)
 
 ## Running the Container

Endpoints.md

@@ -250,13 +250,12 @@ Renders an informative error page when the app is unavailable.
    - Sentiment Analyzer initialization
    - Gemini API validation
    - Inflection AI API validation
-   - Quantum API validation (optional)
 
 2. **Component Initialization** - After parallel init completes:
    - GalateaAI instance creation
    - DialogueEngine initialization
    - AvatarEngine initialization
-   - Quantum Emotion Service startup (if API key available)
+   - Random Emotion Service startup
 
 3. **Flask Server Start** - Only starts if all critical components are ready
 
@@ -267,7 +266,7 @@ Renders an informative error page when the app is unavailable.
 - **Inflection AI API**: Required
 
 ### Optional Components
-- **Quantum API**: Optional (falls back to pseudo-random)
+- None (all randomness uses standard pseudo-random numbers)
 
 ---
 
@@ -275,7 +274,6 @@ Renders an informative error page when the app is unavailable.
 
 ### Rate Limits
 - **Gemini API 429**: Treated as valid API key, initialization continues
-- **Quantum API 429**: Falls back to pseudo-random, initialization continues
 
 ### Critical Failures
 If any critical component fails to initialize, the application will:
@@ -289,7 +287,7 @@ If any critical component fails to initialize, the application will:
 
 Emotions are stored in `emotions.json` and persist across restarts. The system uses:
 - **Sentiment Analysis**: Updates emotions based on user message sentiment
-- **Quantum Influence**: Background service updates emotions every 10 seconds using quantum random numbers (if available)
+- **Random Influence**: Background service updates emotions every 10 seconds using random numbers
 - **Decay**: Emotions slowly decay over time (3% per interaction)
 
 ### Emotion Values
@@ -329,7 +327,7 @@ The frontend polls `GET /api/avatar` every 1 second to get real-time emotion upd
 - **Purpose**: Updates emotions even when the user is not chatting
 - **Updates Include**:
   - Sentiment-based emotion changes from user messages
-  - Quantum-influenced emotion changes (every 10 seconds)
+  - Random-influenced emotion changes (every 10 seconds)
   - Natural emotion decay over time
 
 ### Emotion Bar Update Function

README.md

@@ -74,7 +74,6 @@ These environment variables enhance functionality but are not required:
 |----------|-------------|------------------|
 | `AZURE_TEXT_ANALYTICS_KEY` | Azure Text Analytics API key for enhanced sentiment analysis | Falls back to NLTK VADER if not provided |
 | `AZURE_TEXT_ANALYTICS_ENDPOINT` | Azure Text Analytics endpoint URL | Required if `AZURE_TEXT_ANALYTICS_KEY` is set |
-| `ANU_QUANTUM_API_KEY` | ANU Quantum Random Numbers API key | Uses pseudo-random numbers if not provided |
 | `PORT` | Port number for the Flask server | Defaults to `7860` |
 
 ### Environment Variable Examples
@@ -105,9 +104,6 @@ INFLECTION_AI_API_KEY=your-inflection-key
 AZURE_TEXT_ANALYTICS_KEY=your-azure-key
 AZURE_TEXT_ANALYTICS_ENDPOINT=https://your-resource.cognitiveservices.azure.com/
 
-# Optional - Quantum Randomness
-ANU_QUANTUM_API_KEY=your-quantum-key
-
 # Optional - Port Configuration
 PORT=7860
 ```

agents/emotional_agent.py

@@ -25,10 +25,7 @@ class EmotionalStateAgent:
         
         # Slower learning rate for more gradual emotion changes
         self.learning_rate = 0.03
-        self.quantum_random_available = False
-        self.quantum_api_key = None
-        self._initialize_quantum()
-        
+
         # Save initial state to JSON
         self._save_to_json()
     
@@ -60,48 +57,16 @@ class EmotionalStateAgent:
         except Exception as e:
             logging.error(f"[EmotionalStateAgent] Error saving emotional state to JSON: {e}")
     
-    def _initialize_quantum(self):
-        """Initialize quantum randomness availability"""
-        quantum_key = os.getenv("ANU_QUANTUM_API_KEY")
-        if quantum_key:
-            self.quantum_api_key = quantum_key
-            self.quantum_random_available = True
-            logging.info("[EmotionalStateAgent] ✓ Quantum randomness available")
-        else:
-            logging.warning("[EmotionalStateAgent] Quantum randomness unavailable")
-    
-    def get_quantum_random_float(self, min_val=0.0, max_val=1.0):
-        """Get a quantum random float between min_val and max_val"""
-        if not self.quantum_random_available:
-            return random.uniform(min_val, max_val)
-        
-        try:
-            quantum_config = self.config.get('quantum', {}) if self.config else {}
-            url = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
-            headers = {"x-api-key": self.quantum_api_key}
-            params = {"length": 1, "type": "uint8"}
-            
-            response = requests.get(url, headers=headers, params=params, timeout=10)
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get('success') and 'data' in result and len(result['data']) > 0:
-                    normalized = result['data'][0] / 255.0
-                    return min_val + (max_val - min_val) * normalized
-        except Exception as e:
-            logging.warning(f"[EmotionalStateAgent] Quantum API failed: {e}")
-        
+    def get_random_float(self, min_val=0.0, max_val=1.0):
+        """Get a random float between min_val and max_val"""
         return random.uniform(min_val, max_val)
     
     def update_with_sentiment(self, sentiment_score):
         """Update emotional state based on sentiment"""
         # Slower decay factor to prevent emotions from crashing to minimum too fast
         # Changed from 0.9 to 0.97 (only 3% decay per interaction instead of 10%)
-        decay_factor = 0.97
-        if self.quantum_random_available:
-            quantum_decay_variation = self.get_quantum_random_float(0.95, 0.99)
-            decay_factor = quantum_decay_variation
-        
+        decay_factor = self.get_random_float(0.95, 0.99)
+
         for emotion in self.emotional_state:
             # Decay emotions more slowly (preserves emotional state longer)
             self.emotional_state[emotion] *= decay_factor
@@ -109,20 +74,16 @@ class EmotionalStateAgent:
             self.emotional_state[emotion] = max(0.0, min(1.0, self.emotional_state[emotion]))
 
         # Apply sentiment with slower learning rate for gradual changes
-        learning_rate = self.learning_rate
-        if self.quantum_random_available:
-            quantum_lr_variation = self.get_quantum_random_float(0.02, 0.04)
-            learning_rate = quantum_lr_variation
-        
+        learning_rate = self.get_random_float(0.02, 0.04)
+
         # Update emotions based on sentiment (slower, more gradual)
         self.emotional_state["joy"] += sentiment_score * learning_rate
         self.emotional_state["sadness"] -= sentiment_score * learning_rate
-        
-        # Add quantum randomness to curiosity (making responses more unpredictable)
-        if self.quantum_random_available:
-            quantum_curiosity_boost = self.get_quantum_random_float(-0.03, 0.03)
-            self.emotional_state["curiosity"] = max(0.0, min(1.0, 
-                self.emotional_state["curiosity"] + quantum_curiosity_boost))
+
+        # Add randomness to curiosity (making responses more unpredictable)
+        curiosity_boost = self.get_random_float(-0.03, 0.03)
+        self.emotional_state["curiosity"] = max(0.0, min(1.0,
+            self.emotional_state["curiosity"] + curiosity_boost))
 
         # Soft normalization - only normalize if emotions get too extreme
         # This prevents emotions from being forced to equal values

app.json

@@ -20,10 +20,6 @@
     "AZURE_TEXT_ANALYTICS_ENDPOINT": {
       "description": "Your Azure Text Analytics endpoint (optional)",
       "required": false
-    },
-    "ANU_QUANTUM_API_KEY": {
-      "description": "Your ANU Quantum API key (optional)",
-      "required": false
     }
   },
   "formation": {

app.py

@@ -80,10 +80,10 @@ deepseek_initialized = False
 max_init_retries = 3
 current_init_retry = 0
 
-# Quantum numbers queue for /api/avatar endpoint
-quantum_numbers_queue = deque(maxlen=100)
-quantum_queue_lock = Lock()
-quantum_filling = False
+# Random numbers queue for /api/avatar endpoint
+random_numbers_queue = deque(maxlen=100)
+random_queue_lock = Lock()
+random_filling = False
 
 # Check for required environment variables
 required_env_vars = ['DEEPSEEK_API_KEY']
@@ -132,7 +132,6 @@ init_status = {
     'sentiment_analyzer': {'ready': False, 'error': None},
     'deepseek_api': {'ready': False, 'error': None},
     'inflection_api': {'ready': False, 'error': None},
-    'quantum_api': {'ready': False, 'error': None},
 }
 
 def initialize_json_memory():
@@ -300,43 +299,6 @@ def validate_inflection_api():
         init_status['inflection_api']['ready'] = False
         return False
 
-def validate_quantum_api():
-    """Validate Quantum Random Numbers API key (optional component)"""
-    try:
-        logging.info("🔄 [Quantum API] Validating API key...")
-        print("🔄 [Quantum API] Validating API key...")
-        api_key = os.getenv("ANU_QUANTUM_API_KEY")
-        if not api_key:
-            logging.info("ℹ️  [Quantum API] API key not found (optional - will use pseudo-random)")
-            print("ℹ️  [Quantum API] API key not found (optional - will use pseudo-random)")
-            init_status['quantum_api']['ready'] = False
-            return True  # Not an error - optional component
-        url = "https://api.quantumnumbers.anu.edu.au"
-        headers = {"x-api-key": api_key}
-        params = {"length": 1, "type": "uint8"}
-        response = requests.get(url, headers=headers, params=params, timeout=10)
-        if response.status_code == 200:
-            logging.info("✓ [Quantum API] API key validated")
-            print("✓ [Quantum API] API key validated")
-            init_status['quantum_api']['ready'] = True
-            return True
-        elif response.status_code == 429:
-            # Rate limit - not an error, just unavailable temporarily
-            logging.info("ℹ️  [Quantum API] Rate limited (optional - will use pseudo-random)")
-            print("ℹ️  [Quantum API] Rate limited (optional - will use pseudo-random)")
-            init_status['quantum_api']['ready'] = False
-            return True  # Not an error - optional component
-        else:
-            logging.info(f"ℹ️  [Quantum API] Validation failed: {response.status_code} (optional - will use pseudo-random)")
-            print(f"ℹ️  [Quantum API] Validation failed: {response.status_code} (optional - will use pseudo-random)")
-            init_status['quantum_api']['ready'] = False
-            return True  # Not an error - optional component
-    except Exception as e:
-        # Any exception is not critical - quantum randomness is optional
-        logging.info(f"ℹ️  [Quantum API] Unavailable: {e} (optional - will use pseudo-random)")
-        print(f"ℹ️  [Quantum API] Unavailable: {e} (optional - will use pseudo-random)")
-        init_status['quantum_api']['ready'] = False
-        return True  # Not an error - optional component
 
 def run_parallel_initialization():
     """Run all initialization steps in parallel"""
@@ -358,7 +320,6 @@ def run_parallel_initialization():
         ("Sentiment Analyzer", initialize_sentiment_analyzer),
         ("DeepSeek API", validate_deepseek_api),
         ("Inflection AI", validate_inflection_api),
-        ("Quantum API", validate_quantum_api),
     ]
     
     completed_count = 0
@@ -719,103 +680,51 @@ def analyze_sentiment(text):
 # Track avatar updates with timestamp
 last_avatar_update = time.time()
 
-def fill_quantum_queue():
-    """Asynchronously fill the quantum numbers queue with 100 numbers"""
-    global quantum_filling, quantum_numbers_queue
-    
-    with quantum_queue_lock:
-        if quantum_filling:
+def fill_random_queue():
+    """Asynchronously fill the random numbers queue with 100 numbers"""
+    global random_filling, random_numbers_queue
+
+    with random_queue_lock:
+        if random_filling:
             return  # Already filling
-        quantum_filling = True
-    
+        random_filling = True
+
     def _fill_queue():
-        global quantum_filling
+        global random_filling
         try:
-            quantum_api_key = os.getenv("ANU_QUANTUM_API_KEY")
-            if not quantum_api_key:
-                logging.debug("[Quantum Queue] No API key, using pseudo-random")
-                import random
-                with quantum_queue_lock:
-                    while len(quantum_numbers_queue) < 100:
-                        quantum_numbers_queue.append(random.random())
-                return
-            
-            from config import MODEL_CONFIG
-            quantum_config = MODEL_CONFIG.get('quantum', {}) if MODEL_CONFIG else {}
-            api_endpoint = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
-            
-            headers = {"x-api-key": quantum_api_key}
-            params = {"length": 1, "type": "uint8"}
-            
-            numbers_fetched = 0
-            with quantum_queue_lock:
-                current_size = len(quantum_numbers_queue)
-            
-            while numbers_fetched < 100:
-                try:
-                    response = requests.get(api_endpoint, headers=headers, params=params, timeout=5)
-                    if response.status_code == 200:
-                        result = response.json()
-                        if result.get('success') and 'data' in result and len(result['data']) > 0:
-                            normalized = result['data'][0] / 255.0
-                            with quantum_queue_lock:
-                                quantum_numbers_queue.append(normalized)
-                            numbers_fetched += 1
-                        else:
-                            # Fallback to pseudo-random
-                            import random
-                            with quantum_queue_lock:
-                                quantum_numbers_queue.append(random.random())
-                            numbers_fetched += 1
-                    elif response.status_code == 429:
-                        # Rate limited - use pseudo-random
-                        import random
-                        with quantum_queue_lock:
-                            quantum_numbers_queue.append(random.random())
-                        numbers_fetched += 1
-                    else:
-                        # Error - use pseudo-random
-                        import random
-                        with quantum_queue_lock:
-                            quantum_numbers_queue.append(random.random())
-                        numbers_fetched += 1
-                except Exception as e:
-                    logging.debug(f"[Quantum Queue] Error fetching number: {e}, using pseudo-random")
-                    import random
-                    with quantum_queue_lock:
-                        quantum_numbers_queue.append(random.random())
-                    numbers_fetched += 1
-                
-                # Small delay to avoid rate limits
-                time.sleep(0.1)
-            
-            logging.info(f"[Quantum Queue] Filled queue with {numbers_fetched} numbers")
+            import random
+            logging.debug("[Random Queue] Filling with regular random numbers")
+            with random_queue_lock:
+                while len(random_numbers_queue) < 100:
+                    random_numbers_queue.append(random.random())
+
+            logging.info(f"[Random Queue] Filled queue with 100 random numbers")
         except Exception as e:
-            logging.error(f"[Quantum Queue] Error filling queue: {e}")
+            logging.error(f"[Random Queue] Error filling queue: {e}")
         finally:
-            with quantum_queue_lock:
-                quantum_filling = False
-    
+            with random_queue_lock:
+                random_filling = False
+
     # Start filling in background thread
     Thread(target=_fill_queue, daemon=True).start()
 
-def pop_quantum_number():
-    """Pop a quantum number from the queue, or return pseudo-random if empty"""
-    global quantum_numbers_queue
-    
-    with quantum_queue_lock:
-        if len(quantum_numbers_queue) > 0:
-            return quantum_numbers_queue.popleft()
+def pop_random_number():
+    """Pop a random number from the queue, or generate one if empty"""
+    global random_numbers_queue
+
+    with random_queue_lock:
+        if len(random_numbers_queue) > 0:
+            return random_numbers_queue.popleft()
         else:
-            # Queue is empty, use pseudo-random
+            # Queue is empty, generate on the fly
             import random
             return random.random()
 
 @app.route('/api/avatar')
 def get_avatar():
     """Endpoint to get the current avatar shape and state with enhanced responsiveness"""
-    global last_avatar_update, quantum_numbers_queue, quantum_filling
-    
+    global last_avatar_update, random_numbers_queue, random_filling
+
     if not is_initialized:
         return jsonify({
             'avatar_shape': 'Circle',
@@ -823,17 +732,17 @@ def get_avatar():
             'last_updated': last_avatar_update,
             'status': 'initializing'
         })
-    
+
     try:
-        # Check if quantum queue is empty, fill it asynchronously if needed
-        with quantum_queue_lock:
-            queue_empty = len(quantum_numbers_queue) == 0
-        
-        if queue_empty and not quantum_filling:
-            fill_quantum_queue()
-        
-        # Pop one quantum number to update emotions
-        quantum_num = pop_quantum_number()
+        # Check if random queue is empty, fill it asynchronously if needed
+        with random_queue_lock:
+            queue_empty = len(random_numbers_queue) == 0
+
+        if queue_empty and not random_filling:
+            fill_random_queue()
+
+        # Pop one random number to update emotions
+        random_num = pop_random_number()
         
         avatar_shape = avatar_engine.avatar_model if avatar_engine else 'Circle'
         
@@ -850,15 +759,15 @@ def get_avatar():
             
         # Force avatar update based on emotions if available
         if avatar_engine and galatea_ai:
-            # Apply quantum influence to emotions
+            # Apply random influence to emotions
             emotions = ["joy", "sadness", "anger", "fear", "curiosity"]
-            # Use quantum number to influence a random emotion
+            # Use random number to influence a random emotion
             import random
-            emotion_index = int(quantum_num * len(emotions)) % len(emotions)
+            emotion_index = int(random_num * len(emotions)) % len(emotions)
             selected_emotion = emotions[emotion_index]
-            
-            # Apply subtle quantum influence (-0.05 to +0.05)
-            influence = (quantum_num - 0.5) * 0.1
+
+            # Apply subtle random influence (-0.05 to +0.05)
+            influence = (random_num - 0.5) * 0.1
             current_value = galatea_ai.emotional_state[selected_emotion]
             new_value = max(0.05, min(1.0, current_value + influence))
             galatea_ai.emotional_state[selected_emotion] = new_value

docker-compose.yml

@@ -14,8 +14,6 @@ services:
       # Optional - Azure Text Analytics
       - AZURE_TEXT_ANALYTICS_KEY=${AZURE_TEXT_ANALYTICS_KEY:-}
       - AZURE_TEXT_ANALYTICS_ENDPOINT=${AZURE_TEXT_ANALYTICS_ENDPOINT:-}
-      # Optional - Quantum API
-      - ANU_QUANTUM_API_KEY=${ANU_QUANTUM_API_KEY:-}
       # Optional - Port (defaults to 7860)
       - PORT=${PORT:-7860}
     env_file:

galatea_ai.py

@@ -79,8 +79,7 @@ class GalateaAI:
         # Legacy compatibility
         self.deepseek_available = self.deepseek_agent.is_ready()
         self.inflection_ai_available = self.pi_agent.is_ready()
-        self.quantum_random_available = self.emotional_agent.quantum_random_available
-        
+
         logging.info("✓ All agents initialized and verified")
     
     def _check_pre_initialization(self):

models.yaml

@@ -56,16 +56,4 @@ conversation:
 system_prompts:
   galatea_identity: "You are Galatea, an AI assistant with emotional awareness and memory."
   response_style: "Respond in character, keeping responses concise (under 50 words)."
-  
-# Quantum Randomness Configuration
-quantum:
-  api_endpoint: "https://api.quantumnumbers.anu.edu.au"
-  default_length: 128
-  default_type: "uint8"
-  
-  # Usage settings
-  use_for_temperature: true
-  use_for_emotion_decay: true
-  use_for_learning_rate: true
-  use_for_curiosity: true
 

quantum_emotion_service.py

@@ -1,9 +1,9 @@
-"""Quantum Emotion Service - Background service for quantum-influenced emotion updates"""
+"""Random Emotion Service - Background service for random-influenced emotion updates"""
 import os
 import sys
 import time
 import logging
-import requests
+import random
 import threading
 from collections import deque
 
@@ -12,67 +12,33 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from config import MODEL_CONFIG
 
 class QuantumEmotionService:
-    """Background service that collects quantum random numbers and applies them to emotions"""
-    
+    """Background service that generates random numbers and applies them to emotions"""
+
     def __init__(self, emotional_agent, config=None):
         self.config = config or MODEL_CONFIG or {}
         self.emotional_agent = emotional_agent
-        self.quantum_api_key = os.getenv("ANU_QUANTUM_API_KEY")
         self.running = False
         self.thread = None
-        self.quantum_numbers = deque(maxlen=6)  # Store last 6 numbers
+        self.random_numbers = deque(maxlen=6)  # Store last 6 numbers
         self.last_update_time = time.time()
         self.update_interval = 10.0  # Update emotions every 10 seconds
-        self.call_interval = 1.0  # Call API once per second
-        
-        if not self.quantum_api_key:
-            logging.info("[QuantumEmotionService] Quantum API key not found - service will not run")
-            return
-        
-        quantum_config = self.config.get('quantum', {}) if self.config else {}
-        self.api_endpoint = quantum_config.get('api_endpoint', 'https://api.quantumnumbers.anu.edu.au')
-        
-        logging.info("[QuantumEmotionService] Initialized - will call API once per second")
+        self.generation_interval = 1.0  # Generate number once per second
+
+        logging.info("[RandomEmotionService] Initialized - will generate random numbers once per second")
     
-    def _fetch_quantum_number(self):
-        """Fetch a single quantum random number from the API"""
-        if not self.quantum_api_key:
-            return None
-        
-        try:
-            headers = {"x-api-key": self.quantum_api_key}
-            params = {"length": 1, "type": "uint8"}
-            
-            response = requests.get(self.api_endpoint, headers=headers, params=params, timeout=5)
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get('success') and 'data' in result and len(result['data']) > 0:
-                    # Normalize to 0-1 range
-                    normalized = result['data'][0] / 255.0
-                    return normalized
-            elif response.status_code == 429:
-                # Rate limited - return None, will use pseudo-random
-                logging.debug("[QuantumEmotionService] Rate limited, using pseudo-random")
-                return None
-            else:
-                logging.debug(f"[QuantumEmotionService] API returned {response.status_code}")
-                return None
-        except Exception as e:
-            logging.debug(f"[QuantumEmotionService] API call failed: {e}")
-            return None
-        
-        return None
+    def _generate_random_number(self):
+        """Generate a single random number"""
+        return random.random()
     
-    def _apply_quantum_emotions(self):
-        """Apply the collected 6 quantum numbers to influence emotion state"""
-        if len(self.quantum_numbers) < 6:
-            logging.debug(f"[QuantumEmotionService] Not enough numbers yet ({len(self.quantum_numbers)}/6)")
+    def _apply_random_emotions(self):
+        """Apply the collected 6 random numbers to influence emotion state"""
+        if len(self.random_numbers) < 6:
+            logging.debug(f"[RandomEmotionService] Not enough numbers yet ({len(self.random_numbers)}/6)")
             return
-        
+
         # Convert deque to list
-        numbers = list(self.quantum_numbers)
-        
+        numbers = list(self.random_numbers)
+
         # Map 6 numbers to 5 emotions + overall variation
         # numbers[0] -> joy
         # numbers[1] -> sadness
@@ -80,25 +46,25 @@ class QuantumEmotionService:
         # numbers[3] -> fear
         # numbers[4] -> curiosity
         # numbers[5] -> overall variation factor
-        
+
         emotions = ["joy", "sadness", "anger", "fear", "curiosity"]
         current_state = self.emotional_agent.get_state()
-        
-        # Apply quantum influence (subtle changes, -0.05 to +0.05 range)
+
+        # Apply random influence (subtle changes, -0.05 to +0.05 range)
         for i, emotion in enumerate(emotions):
             if i < len(numbers) and numbers[i] is not None:
                 # Convert 0-1 to -0.05 to +0.05 influence
                 influence = (numbers[i] - 0.5) * 0.1  # Scale to ±0.05
-                
+
                 # Apply with overall variation factor
                 if len(numbers) > 5 and numbers[5] is not None:
                     variation = (numbers[5] - 0.5) * 0.02  # Additional ±0.01 variation
                     influence += variation
-                
+
                 # Update emotion
                 new_value = current_state[emotion] + influence
                 current_state[emotion] = max(0.05, min(1.0, new_value))
-        
+
         # Soft normalization to keep emotions balanced (only if they get too extreme)
         total = sum(current_state.values())
         if total > 1.5 or total < 0.5:
@@ -110,74 +76,62 @@ class QuantumEmotionService:
             for emotion in emotions:
                 if current_state[emotion] < 0.05:
                     current_state[emotion] = 0.05
-        
+
         # Update the emotional agent's state
         self.emotional_agent.emotional_state = current_state
-        
-        # Save to JSON after quantum update
+
+        # Save to JSON after random update
         self.emotional_agent._save_to_json()
-        
-        logging.info(f"[QuantumEmotionService] Applied quantum influence: {current_state}")
+
+        logging.info(f"[RandomEmotionService] Applied random influence: {current_state}")
     
     def _service_loop(self):
-        """Main service loop - calls API once per second, updates emotions every 10 seconds"""
-        logging.info("[QuantumEmotionService] Service started")
-        
+        """Main service loop - generates random numbers once per second, updates emotions every 10 seconds"""
+        logging.info("[RandomEmotionService] Service started")
+
         while self.running:
             try:
-                # Fetch quantum number (once per second)
-                quantum_num = self._fetch_quantum_number()
-                
-                if quantum_num is not None:
-                    self.quantum_numbers.append(quantum_num)
-                    logging.debug(f"[QuantumEmotionService] Collected quantum number: {quantum_num:.4f}")
-                else:
-                    # Use pseudo-random as fallback
-                    import random
-                    pseudo_random = random.random()
-                    self.quantum_numbers.append(pseudo_random)
-                    logging.debug(f"[QuantumEmotionService] Using pseudo-random: {pseudo_random:.4f}")
-                
+                # Generate random number (once per second)
+                random_num = self._generate_random_number()
+                self.random_numbers.append(random_num)
+                logging.debug(f"[RandomEmotionService] Generated random number: {random_num:.4f}")
+
                 # Check if it's time to update emotions (every 10 seconds)
                 current_time = time.time()
                 if current_time - self.last_update_time >= self.update_interval:
-                    if len(self.quantum_numbers) >= 6:
-                        self._apply_quantum_emotions()
+                    if len(self.random_numbers) >= 6:
+                        self._apply_random_emotions()
                         self.last_update_time = current_time
-                        logging.info(f"[QuantumEmotionService] Updated emotions with {len(self.quantum_numbers)} quantum numbers")
-                
-                # Wait 1 second before next call
-                time.sleep(self.call_interval)
-                
+                        logging.info(f"[RandomEmotionService] Updated emotions with {len(self.random_numbers)} random numbers")
+
+                # Wait 1 second before next generation
+                time.sleep(self.generation_interval)
+
             except Exception as e:
-                logging.error(f"[QuantumEmotionService] Error in service loop: {e}")
-                time.sleep(self.call_interval)  # Wait before retrying
+                logging.error(f"[RandomEmotionService] Error in service loop: {e}")
+                time.sleep(self.generation_interval)  # Wait before retrying
     
     def start(self):
         """Start the background service"""
-        if not self.quantum_api_key:
-            logging.info("[QuantumEmotionService] Cannot start - no API key")
-            return False
-        
         if self.running:
-            logging.warning("[QuantumEmotionService] Already running")
+            logging.warning("[RandomEmotionService] Already running")
             return False
-        
+
         self.running = True
         self.thread = threading.Thread(target=self._service_loop, daemon=True)
         self.thread.start()
-        logging.info("[QuantumEmotionService] Background service started")
+        logging.info("[RandomEmotionService] Background service started")
         return True
-    
+
     def stop(self):
         """Stop the background service"""
         if not self.running:
             return
-        
+
         self.running = False
         if self.thread:
             self.thread.join(timeout=2.0)
-        logging.info("[QuantumEmotionService] Background service stopped")
+        logging.info("[RandomEmotionService] Background service stopped")
     
     def is_running(self):
         """Check if service is running"""