"""Always-On Daemon — when not in use, the system keeps working. When the user isn't interacting: 1. The 5 agents talk to the LLM, creating a continuous learning loop 2. Jarvis creates skills from agent conversations 3. Conversation skill creation — patterns extracted from agent talks 4. Self-refinement engine optimizes speed and intelligence 5. Goals are progressed — agents pick up and work on pending goals 6. 100-project mode — auto-generates and works on 100 projects 24/7 7. First-run naming — greets user as Incentives Inc. LLM, asks for a name This creates a system that's always getting smarter, even when idle. Once it has enough skills, it enters 100-project mode and never stops working. Daemon loop: - Check if user is active (recent conversation < 60s ago) - If idle: trigger agent conversations, skill creation, refinement, project generation - If active: do nothing (don't interfere with user interactions) - Runs in a background thread, started with `python -m splitbit_llm daemon` """ from __future__ import annotations import logging import random import threading import time from typing import Any, Callable from .agent_manager import AgentManager from .self_refine import SelfRefinementEngine logger = logging.getLogger(__name__) class AlwaysOnDaemon: """Always-on daemon — keeps the system working when idle. When the user isn't interacting: - Agents have conversations with the LLM (continuous learning) - Jarvis creates skills from those conversations - Self-refinement engine optimizes speed and intelligence - Goals are progressed The daemon monitors activity and only runs when the system is idle. """ IDLE_THRESHOLD_S = 60.0 # consider idle after 60s of no user activity AGENT_TALK_INTERVAL_S = 30.0 # agents talk every 30s when idle REFINEMENT_INTERVAL_S = 120.0 # refine every 2 minutes SKILL_CREATION_INTERVAL_S = 60.0 # create skills every 60s PROJECT_CHECK_INTERVAL_S = 45.0 # check project count every 45s MESH_INTERVAL_S = 90.0 # conversation mesh every 90s TARGET_PROJECT_COUNT = 100 # maintain 100 active projects FAST_REPLY_SKILL_THRESHOLD = 50 # need 50+ skills for fast replies FAST_REPLY_HIT_RATE_THRESHOLD = 0.3 # need 30%+ cache hit rate AGENT_CONVERSATION_TOPICS = [ "What's the most efficient way to process data?", "How can I improve my response speed?", "What patterns have you noticed in recent conversations?", "How do you handle complex problem-solving?", "What's the best approach for learning new skills?", "How can we optimize our tool usage?", "What are common mistakes to avoid in coding?", "How do you break down large tasks into smaller ones?", "What makes a good user experience?", "How can we improve our memory recall?", "What's the most important skill for an AI to have?", "How do you prioritize tasks when everything is urgent?", "What's the relationship between speed and accuracy?", "How can we learn from our mistakes?", "What's the best way to structure a project?", ] def __init__(self, harness: Any) -> None: self.harness = harness self._running = False self._thread: threading.Thread | None = None # Components self.agent_manager = harness.agent_manager self.refinement = SelfRefinementEngine(harness=harness) # State self._last_user_activity = time.time() self._last_agent_talk = 0.0 self._last_skill_creation = 0.0 self._last_refinement = 0.0 self._last_project_check = 0.0 self._last_mesh = 0.0 self._conversation_count = 0 self._skills_created = 0 self._projects_generated = 0 self._projects_completed = 0 self._hundred_project_mode = False self._stats = { "daemon_uptime_s": 0.0, "idle_cycles": 0, "agent_conversations": 0, "skills_created": 0, "refinement_cycles": 0, "goals_progressed": 0, "projects_generated": 0, "projects_completed": 0, "hundred_project_mode": False, "fast_reply_ready": False, "mesh_conversations": 0, "mesh_categories_discovered": 0, "mesh_skills_pooled": 0, } def notify_user_activity(self) -> None: """Call this when the user interacts with the system.""" self._last_user_activity = time.time() def start(self) -> None: """Start the always-on daemon.""" if self._running: return self._running = True self._start_time = time.time() # Start agents self.agent_manager.start_all() # Start self-refinement self.refinement.start() # Start daemon loop self._thread = threading.Thread(target=self._run_loop, daemon=True, name="always-on") self._thread.start() logger.info("Always-on daemon started — 5 agents active, self-refinement running") def stop(self) -> None: """Stop the daemon.""" self._running = False self.refinement.stop() self.agent_manager.stop_all() if self._thread: self._thread.join(timeout=10) logger.info("Always-on daemon stopped (ran %d cycles, %d agent conversations, %d skills created)", self._stats["idle_cycles"], self._stats["agent_conversations"], self._stats["skills_created"]) def _run_loop(self) -> None: """Main daemon loop.""" while self._running: time.sleep(5) # check every 5 seconds now = time.time() idle_time = now - self._last_user_activity self._stats["daemon_uptime_s"] = now - self._start_time if idle_time < self.IDLE_THRESHOLD_S: continue # user is active, don't interfere # System is idle — do work self._stats["idle_cycles"] += 1 # 1. Agent conversations (every AGENT_TALK_INTERVAL_S) if now - self._last_agent_talk > self.AGENT_TALK_INTERVAL_S: self._run_agent_conversation() self._last_agent_talk = now # 2. Skill creation from conversations (every SKILL_CREATION_INTERVAL_S) if now - self._last_skill_creation > self.SKILL_CREATION_INTERVAL_S: self._create_skills_from_conversations() self._last_skill_creation = now # 3. Self-refinement (every REFINEMENT_INTERVAL_S) if now - self._last_refinement > self.REFINEMENT_INTERVAL_S: result = self.refinement.refine_once() if result.get("actions"): self._stats["refinement_cycles"] += 1 self._last_refinement = now # 4. Progress goals self._progress_goals() # 5. Check fast reply readiness self._check_fast_reply_ready() # 6. Multi-LLM conversation mesh — agents converse to build skills if now - self._last_mesh > self.MESH_INTERVAL_S: self._run_mesh_conversation() self._last_mesh = now # 7. 100-project mode — auto-generate and maintain projects if now - self._last_project_check > self.PROJECT_CHECK_INTERVAL_S: self._maintain_hundred_projects() self._last_project_check = now def _run_agent_conversation(self) -> None: """Have an agent talk to the LLM — creates training data and skills.""" topic = random.choice(self.AGENT_CONVERSATION_TOPICS) # Pick a random agent to ask the question agent_names = list(self.agent_manager.agents.keys()) asking_agent = random.choice(agent_names) # Generate a response from the LLM try: prompt = f"Agent {asking_agent} asks: {topic}" response = self.harness._agent_generate(prompt) # Store in persistent memory self.harness.persistent_memory.add_episodic( "agent", f"{asking_agent}: {topic} → {response[:100]}", channel="agent-self-talk", importance=0.4, tags=["self-talk", asking_agent] ) # Store in recursive link graph self.harness.link_graph.add_context( topic, response, session_id="agent-self-talk", channel="agent" ) self._stats["agent_conversations"] += 1 self._conversation_count += 1 logger.debug("Agent conversation #%d: %s asks '%s'", self._conversation_count, asking_agent, topic[:40]) except Exception as e: logger.error("Agent conversation failed: %s", e) def _create_skills_from_conversations(self) -> None: """Extract skills from recent agent conversations.""" try: factory = self.harness.skill_factory skill = factory.extract_skill() if skill: self.harness.skill_manager.create(skill) self._stats["skills_created"] += 1 self._skills_created += 1 logger.info("Created skill from agent conversations: %s", skill.name) # Also try meta-skill meta = factory.maybe_create_meta_skill(self.harness.skill_manager) if meta: self.harness.skill_manager.create(meta) self._stats["skills_created"] += 1 except Exception as e: logger.debug("Skill creation from conversations: %s", e) def _progress_goals(self) -> None: """Check if any goals can be progressed.""" try: active = self.harness.goal_memory.get_active_goals() pending = self.harness.goal_memory.list_goals(status="pending") if pending and not active: # Assign pending goals to agents for goal in pending[:2]: # assign up to 2 at a time self.harness.goal_memory.assign_agent(goal.id, "planner") self._stats["goals_progressed"] += 1 logger.info("Assigned pending goal to planner: %s", goal.title) except Exception as e: logger.debug("Goal progression: %s", e) def _check_fast_reply_ready(self) -> None: """Check if the system is ready for near-instant replies.""" try: skill_stats = self.harness.skill_manager.get_stats() total_skills = skill_stats.get("total_skills", 0) cache = getattr(self.harness, 'fast_cache', None) hit_rate = cache.get_hit_rate() if cache else 0.0 ready = (total_skills >= self.FAST_REPLY_SKILL_THRESHOLD and hit_rate >= self.FAST_REPLY_HIT_RATE_THRESHOLD) if ready and not self._stats["fast_reply_ready"]: logger.info("Fast reply mode activated! %d skills, %.0f%% cache hit rate", total_skills, hit_rate * 100) self._stats["fast_reply_ready"] = ready except Exception as e: logger.debug("Fast reply check: %s", e) def _run_mesh_conversation(self) -> None: """Run a multi-LLM conversation mesh — agents converse to build skills. All 5 agents talk to each other on a topic, creating: - Skill building pools (collaborative skills) - New skill categories (auto-discovered) - Cross-agent knowledge sharing """ try: mesh = self.harness.conversation_mesh result = mesh.run_conversation() self._stats["mesh_conversations"] += 1 self._stats["mesh_categories_discovered"] += len(result.get("categories", [])) if result.get("skill_pool"): self._stats["mesh_skills_pooled"] += 1 logger.info("Mesh conversation: %s on '%s' — %d messages, %d categories, skill=%s", result.get("mode", "?"), result.get("topic", "?")[:40], result.get("messages", 0), len(result.get("categories", [])), result.get("skill_pool", False)) except Exception as e: logger.debug("Mesh conversation failed: %s", e) def _maintain_hundred_projects(self) -> None: """Maintain 100 active projects — auto-generate new ones when count drops. Once the system has enough skills and knowledge, it enters 100-project mode and continuously generates and works on projects. It never stops — as soon as one project completes, a new one is created. """ try: goal_stats = self.harness.goal_memory.get_stats() active_count = goal_stats.get("active", 0) pending_count = goal_stats.get("pending", 0) total_active = active_count + pending_count # Check if we should enter 100-project mode skill_stats = self.harness.skill_manager.get_stats() total_skills = skill_stats.get("total_skills", 0) if not self._hundred_project_mode: if total_skills >= self.FAST_REPLY_SKILL_THRESHOLD: self._hundred_project_mode = True self._stats["hundred_project_mode"] = True logger.info("Entering 100-project mode! %d skills accumulated. " "Generating and working on projects 24/7.", total_skills) if not self._hundred_project_mode: return # Not ready yet — keep learning # Generate new projects to maintain TARGET_PROJECT_COUNT if total_active < self.TARGET_PROJECT_COUNT: needed = self.TARGET_PROJECT_COUNT - total_active generated = self._generate_projects(min(needed, 5)) # generate up to 5 at a time self._stats["projects_generated"] += generated self._projects_generated += generated if generated > 0: logger.info("Generated %d new projects (active: %d/%d)", generated, total_active + generated, self.TARGET_PROJECT_COUNT) # Track completed projects completed = goal_stats.get("completed", 0) if completed > self._projects_completed: new_completions = completed - self._projects_completed self._projects_completed = completed self._stats["projects_completed"] = completed logger.info("Projects completed: %d total (+%d new)", completed, new_completions) except Exception as e: logger.debug("100-project mode: %s", e) def _generate_projects(self, count: int) -> int: """Generate new project goals automatically. Projects are generated from a mix of: - Template projects (improvement, optimization, learning) - LLM-generated project ideas - Skill-gap analysis (what skills are missing?) """ project_templates = [ ("Optimize inference speed", "Analyze and optimize the LLM inference pipeline for faster responses", "high"), ("Improve memory recall", "Enhance the persistent memory system's recall accuracy and speed", "medium"), ("Create new skill: {topic}", "Develop a new skill for {topic} interactions", "medium"), ("Optimize tokenizer", "Improve tokenizer efficiency and vocabulary coverage", "medium"), ("Enhance agent coordination", "Improve how the 5 agents coordinate on multi-step goals", "high"), ("Build conversation cache", "Expand the fast reply cache for more instant responses", "high"), ("Refine quantization", "Experiment with quantization formats to improve accuracy/speed tradeoff", "medium"), ("Create tool: {topic}", "Build a new tool for {topic} operations", "medium"), ("Improve recursive links", "Enhance the recursive link graph for better context retrieval", "low"), ("Optimize skill matching", "Improve skill trigger matching for more accurate skill selection", "medium"), ("Expand semantic memory", "Extract more semantic facts from conversations", "low"), ("Enhance voice responses", "Improve TTS output formatting and voice adapter latency", "medium"), ("Build webhook integration", "Create webhook endpoints for external service notifications", "low"), ("Optimize image generation", "Improve image generation speed and quality", "low"), ("Create API connector", "Build a new API connector for external service integration", "medium"), ("Improve goal planning", "Enhance the goal planning system with better step decomposition", "medium"), ("Refine self-talk topics", "Generate better self-talk conversation topics for continuous learning", "low"), ("Build monitoring dashboard", "Create a monitoring dashboard for system stats and health", "medium"), ("Optimize SQLite queries", "Profile and optimize SQLite queries for memory and goal storage", "medium"), ("Enhance error handling", "Improve error handling and recovery across all system components", "high"), ] topics = ["data processing", "code review", "text summarization", "pattern matching", "cache optimization", "memory management", "search algorithms", "data compression", "natural language", "math operations", "file handling", "network requests", "image processing", "audio processing", "task scheduling", "resource monitoring"] generated = 0 for i in range(count): try: template = random.choice(project_templates) title = template[0].format(topic=random.choice(topics)) description = template[1].format(topic=random.choice(topics)) priority = template[2] self.harness.create_goal(title, description, priority=priority, tags=["auto-generated", "100-project"]) generated += 1 except Exception as e: logger.debug("Project generation failed: %s", e) break return generated def get_stats(self) -> dict[str, Any]: return { **self._stats, "running": self._running, "idle": (time.time() - self._last_user_activity) > self.IDLE_THRESHOLD_S, "idle_time_s": round(time.time() - self._last_user_activity, 1), "refinement": self.refinement.get_stats(), "agents": self.agent_manager.get_stats(), }