feat(v8): KeyPool Multi-API Router — Gemini + SambaNova Primary LLMs

God Agent OS v8: KeyPool system with Gemini (6 keys) + SambaNova (9 keys), AIRouterV8, main_v8.py entry point, AI Router Panel UI

.github/workflows/deploy.yml

@@ -1,4 +1,4 @@
-name: 🚀 God Agent OS v7 — Auto Deploy
+name: 🚀 God Agent OS v8 — Auto Deploy
 
 on:
   push:
@@ -10,7 +10,7 @@ env:
   VERCEL_PROJECT: god-agent-os
 
 jobs:
-  # ── Build & Test ──────────────────────────────────────────────────────────
+  # ── Build & Syntax Check ──────────────────────────────────────────────────
   build-check:
     name: ✅ Build Check
     runs-on: ubuntu-latest
@@ -28,10 +28,12 @@ jobs:
           cd backend
           pip install -r requirements.txt
 
-      - name: Syntax check backend
+      - name: Syntax check backend (v8)
         run: |
           cd backend
-          python -m py_compile main_v7.py
+          python -m py_compile main_v8.py
+          python -m py_compile ai_router/router_v8.py
+          python -m py_compile ai_router/key_pool.py
           python -m py_compile agents/orchestrator_v7.py
           python -m py_compile agents/browser_agent.py
           python -m py_compile agents/file_agent.py
@@ -55,7 +57,7 @@ jobs:
         env:
           NEXT_PUBLIC_API_URL: ${{ secrets.NEXT_PUBLIC_API_URL || 'https://PYAE1994-autonomous-coding-system.hf.space' }}
 
-  # ── Deploy to Hugging Face Spaces ─────────────────────────────────────────
+  # ── Deploy to Hugging Face Spaces ────────────────────────────────────────
   deploy-huggingface:
     name: 🤗 Deploy to HF Spaces
     runs-on: ubuntu-latest
@@ -72,23 +74,24 @@ jobs:
           git config --global user.email "action@github.com"
           git config --global user.name "God Agent CI"
 
-      - name: Deploy backend to HF Space
+      - name: Deploy backend to HF Space (v8)
         env:
           HF_TOKEN: ${{ secrets.HF_TOKEN }}
         run: |
-          # Install HF CLI
           pip install huggingface_hub -q
 
-          # Clone HF space
           git clone https://pyae1994:$HF_TOKEN@huggingface.co/spaces/PYAE1994/autonomous-coding-system /tmp/hf-space
-          
+
           # Copy backend files
           cp -r backend/. /tmp/hf-space/
-          
-          # Create HF-specific README
+
+          # Use v8 Dockerfile
+          cp backend/Dockerfile.hf /tmp/hf-space/Dockerfile
+
+          # Create HF README with v8 metadata
           cat > /tmp/hf-space/README.md << 'EOF'
           ---
-          title: God Agent OS v7
+          title: God Agent OS v8
           emoji: 🤖
           colorFrom: indigo
           colorTo: purple
@@ -96,27 +99,23 @@ jobs:
           app_port: 7860
           pinned: true
           license: mit
-          short_description: Autonomous Engineering OS — Manus + Genspark + Devin
+          short_description: Autonomous Engineering OS v8 — KeyPool Multi-API (Gemini + SambaNova)
           ---
 
-          # 🤖 God Agent OS v7
-          **Autonomous Engineering Platform — Manus + Genspark + Devin (OneHand)**
+          # 🤖 God Agent OS v8
+          **KeyPool Multi-API Routing — Gemini + SambaNova Primary LLMs**
 
-          16-agent system for autonomous software engineering.
+          16-agent autonomous engineering OS with intelligent key pooling.
           EOF
 
-          # Use HF Dockerfile
-          cp backend/Dockerfile.hf /tmp/hf-space/Dockerfile
-
-          # Commit and push
           cd /tmp/hf-space
           git add -A
-          git diff --cached --quiet || git commit -m "🚀 God Agent OS v7 deploy $(date -u '+%Y-%m-%d %H:%M:%S UTC')"
+          git diff --cached --quiet || git commit -m "🚀 God Agent OS v8 deploy $(date -u '+%Y-%m-%d %H:%M:%S UTC')"
           git push origin main || git push origin master || true
-          
+
           echo "✅ Deployed to HF Space: https://huggingface.co/spaces/PYAE1994/autonomous-coding-system"
 
-  # ── Deploy to Vercel ───────────────────────────────────────────────────────
+  # ── Deploy to Vercel ─────────────────────────────────────────────────────
   deploy-vercel:
     name: ▲ Deploy to Vercel
     runs-on: ubuntu-latest

.gitignore

@@ -0,0 +1,48 @@
+# Dependencies
+node_modules/
+frontend/node_modules/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+
+# Build outputs
+frontend/.next/
+frontend/out/
+dist/
+build/
+*.egg-info/
+
+# Environment
+.env
+.env.local
+.env.production
+*.env
+
+# Logs
+*.log
+logs/
+
+# Database
+*.db
+*.sqlite
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Temporary
+tmp/
+temp/
+/tmp/
+
+# Python cache
+backend/__pycache__/
+backend/**/__pycache__/
+backend/ai_router/__pycache__/

README.md

@@ -1,5 +1,5 @@
 ---
-title: God Agent OS v7
+title: God Agent OS v8
 emoji: 🤖
 colorFrom: indigo
 colorTo: purple
@@ -7,24 +7,39 @@ sdk: docker
 app_port: 7860
 pinned: true
 license: mit
-short_description: Autonomous Engineering OS — Manus + Genspark + Devin (OneHand)
+short_description: Autonomous Engineering OS v8 — KeyPool Multi-API (Gemini + SambaNova)
 ---
 
-# 🤖 GOD AGENT OS v7
+# 🤖 GOD AGENT OS v8
 **Autonomous Engineering Operating System**
-*Manus + Genspark + Devin (OneHand) — Combined*
+*Manus + Genspark + Devin (OneHand) — KeyPool Multi-API Edition*
 
 [![GitHub](https://img.shields.io/badge/GitHub-god--agent--os-blue?logo=github)](https://github.com/pyaesonegtckglay-dotcom/god-agent-os)
-[![Version](https://img.shields.io/badge/version-7.0.0-indigo)](https://github.com/pyaesonegtckglay-dotcom/god-agent-os)
+[![Version](https://img.shields.io/badge/version-8.0.0-indigo)](https://github.com/pyaesonegtckglay-dotcom/god-agent-os)
+[![HF Space](https://img.shields.io/badge/HF%20Space-PYAE1994-orange)](https://huggingface.co/spaces/PYAE1994/autonomous-coding-system)
 
-## 🚀 What is God Agent OS?
+## 🚀 What is God Agent OS v8?
 
-God Agent OS is a fully autonomous AI engineering platform that combines:
-- **Manus** — Deep reasoning, multi-step planning, autonomous orchestration
-- **Genspark** — Repository-scale code generation, multi-model AI routing
-- **Devin/OneHand** — Self-healing code execution, browser control, file mastery
+God Agent OS v8 is a fully autonomous AI engineering platform with **KeyPool Multi-API Routing**:
+- **Gemini** (6 keys) — Google Gemini 1.5 Flash primary LLM
+- **SambaNova** (9 keys) — Meta Llama 3.3 70B primary LLM
+- **GitHub API** (9 keys) — Pooled Git operations
+- **Automatic failover** across 7 providers
 
-## 🤖 16-Agent Fleet (v7 NEW!)
+## 🔑 v8 KeyPool System
+
+```
+Priority Chain:
+SambaNova (9 keys) → Gemini (6 keys) → OpenAI → Groq → Cerebras → OpenRouter → Anthropic
+
+Each key pool:
+- Round-robin key selection
+- Failure tracking per key
+- Automatic cooldown (60s after 3 failures)
+- Real-time status dashboard in UI
+```
+
+## 🤖 16-Agent Fleet
 
 | Agent | Capability | Status |
 |-------|-----------|--------|
@@ -32,52 +47,61 @@ God Agent OS is a fully autonomous AI engineering platform that combines:
 | 📋 Planner | Task decomposition & planning | Core |
 | 💻 Coding | Production code generation | Core |
 | 🐛 Debug | Self-healing error resolution | Core |
-| 🌐 **Browser** | Web research & scraping | ⭐ NEW v7 |
-| 📁 **File** | File system & project scaffold | ⭐ NEW v7 |
-| 🔀 **Git** | Git ops & GitHub PR creation | ⭐ NEW v7 |
-| 🧪 **Test** | Auto test generation & execution | ⭐ NEW v7 |
-| 🎨 **Vision** | Design-to-code UI generation | ⭐ NEW v7 |
+| 🌐 Browser | Web research & scraping | v7 |
+| 📁 File | File system & project scaffold | v7 |
+| 🔀 Git | Git ops & GitHub PR creation | v7 |
+| 🧪 Test | Auto test generation & execution | v7 |
+| 🎨 Vision | Design-to-code UI generation | v7 |
 | 🖥️ Sandbox | Isolated code execution | Core |
 | 🚀 Deploy | Auto-deploy to cloud | Core |
 | 🔌 Connector | External integrations | Core |
 | 🧠 Memory | Long-term context | Core |
 | ⚙️ Workflow | n8n automation | Core |
+| 🔍 Reasoning | Deep reasoning & analysis | Core |
+| 🎨 UI | Real-time UI state | Core |
 
-## 🔑 Required API Keys
+## 🔑 API Keys Configuration
 
-Set these in Space Settings → Variables and Secrets:
+Set these in Hugging Face Space → Settings → Variables:
 
-| Variable | Description | Required |
-|----------|-------------|----------|
+| Variable | Description | Keys |
+|----------|-------------|------|
+| `GEMINI_API_KEYS` | Google Gemini (comma-separated) | 6 keys |
+| `SAMBANOVA_API_KEYS` | SambaNova (comma-separated) | 9 keys |
+| `GITHUB_API_KEYS` | GitHub API (comma-separated) | 9 keys |
 | `OPENAI_API_KEY` | GPT-4o | Optional |
-| `GROQ_API_KEY` | Llama 3.3 70B (Free!) | Recommended |
-| `OPENROUTER_API_KEY` | 100+ models | Optional |
+| `GROQ_API_KEY` | Llama 3.3 70B (Free) | Optional |
 | `ANTHROPIC_API_KEY` | Claude 3.5 | Optional |
-| `GITHUB_TOKEN` | Git operations | Optional |
-
-> **Note:** System works in demo mode without any keys. Add at least `GROQ_API_KEY` for full AI power (it's free!).
 
 ## 🌐 API Documentation
 
 - Interactive docs: `/api/docs`
 - Health check: `/health`
+- AI Router stats: `/api/v1/ai/stats`
+- Key pool status: `/api/v1/ai/pool-status`
 
 ## 📦 Architecture
 
 ```
 god-agent-os/
-├── backend/          # FastAPI backend (16 agents)
-│   ├── agents/       # All 16 specialized agents
-│   ├── ai_router/    # Multi-model AI router (5 providers)
-│   ├── api/          # REST + WebSocket endpoints
-│   ├── core/         # Task engine & models
-│   ├── memory/       # SQLite persistent memory
-│   └── connectors/   # External service connectors
-└── frontend/         # Next.js 14 UI (deployed on Vercel)
+├── backend/
+│   ├─��� agents/         # 16 specialized agents
+│   ├── ai_router/
+│   │   ├── key_pool.py    # KeyPool multi-key manager (NEW v8)
+│   │   ├── router_v8.py   # AIRouterV8 with KeyPool (NEW v8)
+│   │   └── router.py      # Legacy router (retained)
+│   ├── api/            # REST + WebSocket endpoints
+│   ├── core/           # Task engine & models
+│   ├── memory/         # SQLite persistent memory
+│   ├── connectors/     # External service connectors
+│   ├── main_v8.py      # v8 Entry point (NEW)
+│   └── Dockerfile.hf   # HF Spaces Docker
+└── frontend/           # Next.js 14 UI
+    └── components/
+        └── layout/
+            └── AIRouterPanel.tsx  # v8 Key pool status UI (NEW)
 ```
 
 ## 🔄 Auto-Deploy Pipeline
 
 GitHub Push → Build Check → HF Space Deploy + Vercel Deploy
-
-All automatic via GitHub Actions!

backend/Dockerfile.hf

@@ -22,6 +22,16 @@ ENV PORT=7860
 ENV WORKSPACE_DIR=/tmp/god_workspace
 ENV PYTHONPATH=/app
 
+# API Keys are configured via HF Space Secrets (Settings → Variables and Secrets)
+# Set these in your HF Space:
+#   GEMINI_API_KEYS      — comma-separated Gemini API keys
+#   SAMBANOVA_API_KEYS   — comma-separated SambaNova API keys
+#   GITHUB_API_KEYS      — comma-separated GitHub tokens
+#   GITHUB_TOKEN         — primary GitHub token
+#   OPENAI_API_KEY       — OpenAI API key (optional)
+#   GROQ_API_KEY         — Groq API key (optional, free)
+#   ANTHROPIC_API_KEY    — Anthropic API key (optional)
+
 EXPOSE 7860
 
-CMD ["uvicorn", "main_v7:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+CMD ["uvicorn", "main_v8:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

backend/agents/debug_agent.py

@@ -44,12 +44,12 @@ class DebugAgent(BaseAgent):
         messages = [
             {"role": "system", "content": DEBUG_SYSTEM},
             {"role": "user", "content": (
-                f"Debug and fix this issue (attempt {attempt}):\n\n"
-                f"{task}\n\n"
-                f"Provide:\n"
-                f"1. Root cause analysis\n"
-                f"2. Exact fix (code/config)\n"
-                f"3. Prevention strategy"
+                "Debug and fix this issue (attempt " + str(attempt) + "):\n\n"
+                + task + "\n\n"
+                "Provide:\n"
+                "1. Root cause analysis\n"
+                "2. Exact fix (code/config)\n"
+                "3. Prevention strategy"
             )},
         ]
 
@@ -71,14 +71,19 @@ class DebugAgent(BaseAgent):
 
     async def analyze_error(self, error_output: str, source_code: str = "", task_id: str = "", session_id: str = "") -> Dict:
         """Deep error analysis with structured output."""
+        if source_code:
+            source_section = "Source Code:\n```\n" + source_code[:1000] + "\n```"
+        else:
+            source_section = ""
+
         messages = [
             {"role": "system", "content": DEBUG_SYSTEM},
             {"role": "user", "content": (
-                f"Analyze this error and provide structured diagnosis:\n\n"
-                f"Error:\n{error_output[:2000]}\n\n"
-                f"{'Source Code:\\n```\\n' + source_code[:1000] + '\\n```' if source_code else ''}\n\n"
-                f"Respond with JSON:\n"
-                f'{{"error_type": "...", "root_cause": "...", "fix": "...", "prevention": "...", "severity": "low|medium|high|critical"}}'
+                "Analyze this error and provide structured diagnosis:\n\n"
+                "Error:\n" + error_output[:2000] + "\n\n"
+                + source_section + "\n\n"
+                "Respond with JSON:\n"
+                '{"error_type": "...", "root_cause": "...", "fix": "...", "prevention": "...", "severity": "low|medium|high|critical"}'
             )},
         ]
         raw = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=1000)
@@ -111,10 +116,10 @@ class DebugAgent(BaseAgent):
             messages = [
                 {"role": "system", "content": DEBUG_SYSTEM},
                 {"role": "user", "content": (
-                    f"Fix attempt {attempt}/{max_retries}:\n\n"
-                    f"Error: {current_error}\n\n"
-                    f"Code:\n```\n{current_code[:3000]}\n```\n\n"
-                    f"Return ONLY the fixed code."
+                    "Fix attempt " + str(attempt) + "/" + str(max_retries) + ":\n\n"
+                    "Error: " + current_error + "\n\n"
+                    "Code:\n```\n" + current_code[:3000] + "\n```\n\n"
+                    "Return ONLY the fixed code."
                 )},
             ]
 
@@ -143,7 +148,7 @@ class DebugAgent(BaseAgent):
             compile(code, "<string>", "exec")
             return {"valid": True, "error": ""}
         except SyntaxError as e:
-            return {"valid": False, "error": f"SyntaxError: {e}"}
+            return {"valid": False, "error": "SyntaxError: " + str(e)}
         except Exception as e:
             return {"valid": False, "error": str(e)}
 

backend/agents/reasoning_agent.py

@@ -1,24 +1,34 @@
 """
-🚀 GOD MODE+ v3 - Reasoning Agent
-Specialized agent for complex reasoning tasks using DeepSeek R1, Qwen QwQ, o1-mini
-Version: 3.0.0
+ReasoningAgent v7 — Complex reasoning, analysis, and multi-step problem solving
+GOD AGENT OS — Using DeepSeek R1, Qwen QwQ, o1-mini style reasoning
 """
 
 import asyncio
 import json
-from typing import Dict, Any, Optional
+from typing import Dict, Any, List, Optional
 
 import structlog
 
-from core.agent import BaseAgent
+from .base_agent import BaseAgent
 
 log = structlog.get_logger()
 
+REASONING_SYSTEM = """You are an elite autonomous reasoning and analysis agent.
+You excel at:
+- Multi-step reasoning with chain-of-thought
+- Complex problem decomposition and analysis
+- Mathematical and logical reasoning
+- Strategic planning and decision making
+- Root cause analysis
+
+Always think step by step, show your reasoning, and provide confident conclusions.
+"""
+
 
 class ReasoningAgent(BaseAgent):
     """
     Specialized agent for complex reasoning, analysis, and problem-solving tasks.
-    
+
     Capabilities:
     - Multi-step reasoning with chain-of-thought
     - Complex problem decomposition
@@ -27,259 +37,127 @@ class ReasoningAgent(BaseAgent):
     - Strategic planning
     """
 
-    def __init__(self, ws_manager, ai_router):
-        """Initialize Reasoning Agent."""
-        super().__init__(
-            name="ReasoningAgent",
-            color="🟦",
-            description="Complex reasoning and analysis",
-            ws_manager=ws_manager,
-            ai_router=ai_router,
-        )
-        self.reasoning_depth = 3  # Number of reasoning steps
+    def __init__(self, ws_manager=None, ai_router=None):
+        super().__init__("ReasoningAgent", ws_manager, ai_router)
+        self.reasoning_depth = 3
         self.max_reasoning_tokens = 16000
 
-    async def process(self, task: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Process reasoning task with multi-step reasoning.
-        """
-        user_message = task.get("content", "")
-        session_id = task.get("session_id", "")
-        context = task.get("context", {})
+    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
+        """Execute reasoning task."""
+        session_id = kwargs.get("session_id", "")
+        task_id = kwargs.get("task_id", "")
 
-        log.info("🧠 Reasoning Agent activated", message=user_message[:100])
+        await self.emit(task_id, "agent_start", {
+            "agent": "ReasoningAgent",
+            "task": task[:80],
+        }, session_id)
 
         try:
             # Step 1: Analyze the problem
-            analysis = await self._analyze_problem(user_message, context)
-            await self._broadcast(session_id, {
-                "type": "reasoning_step",
-                "step": "analysis",
-                "data": analysis,
-            })
-
-            # Step 2: Break down into sub-problems
-            sub_problems = await self._decompose_problem(user_message, analysis)
-            await self._broadcast(session_id, {
-                "type": "reasoning_step",
-                "step": "decomposition",
-                "data": sub_problems,
-            })
-
-            # Step 3: Solve each sub-problem
-            solutions = []
-            for i, sub_problem in enumerate(sub_problems):
-                solution = await self._solve_sub_problem(sub_problem, context)
-                solutions.append(solution)
-                await self._broadcast(session_id, {
-                    "type": "reasoning_step",
-                    "step": f"solution_{i+1}",
-                    "data": solution,
-                })
-
-            # Step 4: Synthesize final answer
-            final_answer = await self._synthesize_answer(
-                user_message,
-                analysis,
-                sub_problems,
-                solutions
-            )
-
-            await self._broadcast(session_id, {
-                "type": "reasoning_complete",
-                "answer": final_answer,
+            analysis = await self._analyze_problem(task, context, task_id, session_id)
+
+            # Step 2: Decompose if complex
+            if len(task.split()) > 30:
+                sub_problems = await self._decompose_problem(task, analysis, task_id, session_id)
+                solutions = []
+                for sub in sub_problems[:3]:
+                    sol = await self._solve_sub_problem(sub, context, task_id, session_id)
+                    solutions.append(sol)
+                result = await self._synthesize_answer(task, analysis, sub_problems, solutions, task_id, session_id)
+            else:
+                result = analysis
+
+            await self.emit(task_id, "reasoning_complete", {
+                "agent": "ReasoningAgent",
                 "reasoning_depth": self.reasoning_depth,
-            })
+            }, session_id)
 
-            return {
-                "success": True,
-                "agent": self.name,
-                "answer": final_answer,
-                "reasoning_steps": {
-                    "analysis": analysis,
-                    "sub_problems": sub_problems,
-                    "solutions": solutions,
-                },
-            }
+            return result
 
         except Exception as e:
-            log.error("❌ Reasoning Agent failed", error=str(e))
-            return {
-                "success": False,
-                "agent": self.name,
-                "error": str(e),
-            }
-
-    async def _analyze_problem(self, problem: str, context: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Analyze the problem using reasoning model.
-        """
-        prompt = f"""Analyze this problem and identify:
-1. Core problem statement
-2. Key constraints
-3. Required information
-4. Potential approaches
-
-Problem: {problem}
-
-Provide structured analysis."""
-
-        response = await self.ai_router.route(
-            prompt,
-            context={"task_type": "reasoning"},
-            optimize_for="quality"
-        )
-
-        return {
-            "problem_type": self._classify_problem(problem),
-            "complexity": self._estimate_complexity(problem),
-            "analysis": response.get("response", ""),
-        }
-
-    async def _decompose_problem(
-        self,
-        problem: str,
-        analysis: Dict[str, Any]
-    ) -> list:
-        """
-        Break down complex problem into manageable sub-problems.
-        """
-        prompt = f"""Based on this analysis, break down the problem into 3-5 specific sub-problems:
-
-Problem: {problem}
-Analysis: {json.dumps(analysis, indent=2)}
-
-List each sub-problem clearly and explain the dependencies."""
-
-        response = await self.ai_router.route(
-            prompt,
-            context={"task_type": "reasoning"},
-            optimize_for="quality"
+            log.error("ReasoningAgent failed", error=str(e))
+            return "Reasoning agent encountered an error: " + str(e)
+
+    async def _analyze_problem(self, problem: str, context: Dict, task_id: str, session_id: str) -> str:
+        """Analyze the problem using reasoning model."""
+        messages = [
+            {"role": "system", "content": REASONING_SYSTEM},
+            {"role": "user", "content": (
+                "Analyze this problem step by step:\n\n"
+                + problem + "\n\n"
+                "Provide:\n"
+                "1. Problem type and complexity\n"
+                "2. Key constraints and requirements\n"
+                "3. Step-by-step solution\n"
+                "4. Final answer/recommendation"
+            )},
+        ]
+        return await self.llm(
+            messages,
+            task_id=task_id,
+            session_id=session_id,
+            temperature=0.2,
+            max_tokens=self.max_reasoning_tokens,
         )
 
-        # Parse sub-problems from response
-        sub_problems = self._parse_sub_problems(response.get("response", ""))
-        return sub_problems
-
-    async def _solve_sub_problem(
-        self,
-        sub_problem: str,
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Solve individual sub-problem.
-        """
-        prompt = f"""Solve this sub-problem step by step:
-
-{sub_problem}
-
-Provide:
-1. Step-by-step solution
-2. Key insights
-3. Confidence level (0-100)"""
-
-        response = await self.ai_router.route(
-            prompt,
-            context={"task_type": "reasoning"},
-            optimize_for="quality"
-        )
+    async def _decompose_problem(self, problem: str, analysis: str, task_id: str, session_id: str) -> List[str]:
+        """Break down complex problem into sub-problems."""
+        messages = [
+            {"role": "system", "content": REASONING_SYSTEM},
+            {"role": "user", "content": (
+                "Break this complex problem into 3 specific sub-problems:\n\n"
+                + problem + "\n\n"
+                "Initial analysis: " + analysis[:500] + "\n\n"
+                "List each sub-problem on a new line starting with '1.', '2.', '3.'"
+            )},
+        ]
+        raw = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=2000)
+        # Parse numbered sub-problems
+        lines = raw.split("\n")
+        sub_problems = []
+        for line in lines:
+            line = line.strip()
+            if line and any(line.startswith(str(i) + ".") for i in range(1, 10)):
+                sub_problems.append(line)
+        return sub_problems if sub_problems else [problem]
 
-        return {
-            "sub_problem": sub_problem,
-            "solution": response.get("response", ""),
-            "model_used": response.get("model", "unknown"),
-        }
+    async def _solve_sub_problem(self, sub_problem: str, context: Dict, task_id: str, session_id: str) -> str:
+        """Solve individual sub-problem."""
+        messages = [
+            {"role": "system", "content": REASONING_SYSTEM},
+            {"role": "user", "content": "Solve this specific problem:\n\n" + sub_problem},
+        ]
+        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=4096)
 
     async def _synthesize_answer(
         self,
-        original_problem: str,
-        analysis: Dict[str, Any],
-        sub_problems: list,
-        solutions: list
+        original: str,
+        analysis: str,
+        sub_problems: List[str],
+        solutions: List[str],
+        task_id: str,
+        session_id: str,
     ) -> str:
-        """
-        Synthesize final answer from all reasoning steps.
-        """
-        synthesis_prompt = f"""Based on the analysis and solutions, provide a comprehensive answer:
-
-Original Problem: {original_problem}
-
-Analysis: {json.dumps(analysis, indent=2)}
-
-Solutions:
-{json.dumps(solutions, indent=2)}
-
-Provide a clear, well-reasoned final answer that:
-1. Directly addresses the original problem
-2. Integrates insights from all sub-problems
-3. Explains the reasoning clearly
-4. Suggests any follow-up actions if needed"""
-
-        response = await self.ai_router.route(
-            synthesis_prompt,
-            context={"task_type": "reasoning"},
-            optimize_for="quality"
+        """Synthesize final answer from all reasoning steps."""
+        solutions_text = "\n".join(
+            "Sub-problem " + str(i + 1) + ": " + sol[:300]
+            for i, sol in enumerate(solutions)
         )
-
-        return response.get("response", "Unable to synthesize answer")
-
-    def _classify_problem(self, problem: str) -> str:
-        """Classify problem type."""
-        problem_lower = problem.lower()
-        
-        if any(word in problem_lower for word in ["math", "calculate", "equation"]):
-            return "mathematical"
-        elif any(word in problem_lower for word in ["logic", "reason", "why"]):
-            return "logical"
-        elif any(word in problem_lower for word in ["plan", "strategy", "approach"]):
-            return "strategic"
-        elif any(word in problem_lower for word in ["analyze", "compare", "evaluate"]):
-            return "analytical"
-        else:
-            return "general"
-
-    def _estimate_complexity(self, problem: str) -> str:
-        """Estimate problem complexity."""
-        word_count = len(problem.split())
-        
-        if word_count < 20:
-            return "simple"
-        elif word_count < 100:
-            return "moderate"
-        else:
-            return "complex"
-
-    def _parse_sub_problems(self, response: str) -> list:
-        """Parse sub-problems from model response."""
-        # Simple parsing - can be enhanced
-        lines = response.split("\n")
-        sub_problems = []
-        
-        for line in lines:
-            line = line.strip()
-            if line and any(line.startswith(f"{i}.") for i in range(1, 10)):
-                sub_problems.append(line)
-        
-        return sub_problems if sub_problems else [response]
-
-    async def _broadcast(self, session_id: str, data: Dict[str, Any]):
-        """Broadcast reasoning progress to client."""
-        if self.ws_manager:
-            await self.ws_manager.broadcast(
-                room=f"chat:{session_id}",
-                message={
-                    "type": "agent_message",
-                    "agent": self.name,
-                    "color": self.color,
-                    **data,
-                }
-            )
+        messages = [
+            {"role": "system", "content": REASONING_SYSTEM},
+            {"role": "user", "content": (
+                "Original problem: " + original + "\n\n"
+                "Analysis: " + analysis[:800] + "\n\n"
+                "Solutions to sub-problems:\n" + solutions_text + "\n\n"
+                "Provide a comprehensive final answer that integrates all insights."
+            )},
+        ]
+        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=8192)
 
     def get_status(self) -> Dict[str, Any]:
         """Get agent status."""
         return {
             "name": self.name,
-            "color": self.color,
             "status": "ready",
             "capabilities": [
                 "Multi-step reasoning",
@@ -289,7 +167,6 @@ Provide a clear, well-reasoned final answer that:
                 "Strategic planning",
             ],
             "reasoning_depth": self.reasoning_depth,
-            "max_reasoning_tokens": self.max_reasoning_tokens,
         }
 
 

backend/ai_router/__init__.py

@@ -1,4 +1,6 @@
-# Multi-Model AI Router
+# Multi-Model AI Router — God Agent OS v8
 from .router import AIRouter
+from .router_v8 import AIRouterV8
+from .key_pool import KeyPool, KeyPoolRegistry
 
-__all__ = ["AIRouter"]
+__all__ = ["AIRouter", "AIRouterV8", "KeyPool", "KeyPoolRegistry"]

backend/ai_router/key_pool.py

@@ -0,0 +1,131 @@
+"""
+KeyPool — Multi-API Key Manager with Failover & Cooldown
+God Agent OS v8 — Supports Gemini, SambaNova, GitHub, OpenAI, Groq, etc.
+Each provider can have multiple comma-separated keys.
+"""
+
+import asyncio
+import time
+from collections import defaultdict
+from typing import Dict, List, Optional
+import structlog
+
+log = structlog.get_logger()
+
+COOLDOWN_SECONDS = 60   # Key cooling time after max failures
+MAX_FAILURES = 3        # Max fails before cooldown
+
+
+class KeyEntry:
+    def __init__(self, key: str):
+        self.key = key
+        self.failures = 0
+        self.cooldown_until = 0.0
+        self.calls = 0
+        self.last_used = 0.0
+
+    def is_available(self) -> bool:
+        if self.cooldown_until > time.time():
+            return False
+        return True
+
+    def mark_fail(self):
+        self.failures += 1
+        if self.failures >= MAX_FAILURES:
+            self.cooldown_until = time.time() + COOLDOWN_SECONDS
+            log.warning("Key cooldown activated", failures=self.failures)
+
+    def mark_success(self):
+        self.failures = max(0, self.failures - 1)
+        self.cooldown_until = 0.0
+        self.calls += 1
+        self.last_used = time.time()
+
+    def status(self) -> dict:
+        remaining = max(0, self.cooldown_until - time.time())
+        return {
+            "key_preview": self.key[:8] + "..." + self.key[-4:] if len(self.key) > 12 else "***",
+            "available": self.is_available(),
+            "failures": self.failures,
+            "calls": self.calls,
+            "cooldown_remaining_s": round(remaining, 1),
+        }
+
+
+class KeyPool:
+    """
+    Pool of API keys for a single provider.
+    Round-robins through available keys with failure tracking.
+    """
+
+    def __init__(self, provider: str, keys: List[str]):
+        self.provider = provider
+        self._keys: List[KeyEntry] = [KeyEntry(k.strip()) for k in keys if k.strip()]
+        self._index = 0
+
+    def __len__(self) -> int:
+        return len(self._keys)
+
+    def pick(self) -> Optional[str]:
+        """Pick the next available key (round-robin, skip cooling down keys)."""
+        if not self._keys:
+            return None
+        n = len(self._keys)
+        for _ in range(n):
+            entry = self._keys[self._index % n]
+            self._index = (self._index + 1) % n
+            if entry.is_available():
+                return entry.key
+        # All keys in cooldown — try the one with shortest cooldown
+        soonest = min(self._keys, key=lambda e: e.cooldown_until)
+        log.warning(
+            "All keys in cooldown, using soonest",
+            provider=self.provider,
+            cooldown_remaining=round(soonest.cooldown_until - time.time(), 1),
+        )
+        return soonest.key
+
+    def mark_fail(self, key: str):
+        for e in self._keys:
+            if e.key == key:
+                e.mark_fail()
+                return
+
+    def mark_success(self, key: str):
+        for e in self._keys:
+            if e.key == key:
+                e.mark_success()
+                return
+
+    def available_count(self) -> int:
+        return sum(1 for e in self._keys if e.is_available())
+
+    def status(self) -> dict:
+        return {
+            "provider": self.provider,
+            "total_keys": len(self._keys),
+            "available_keys": self.available_count(),
+            "keys": [e.status() for e in self._keys],
+        }
+
+
+# ─── Global Key Pool Registry ─────────────────────────────────────────────────
+
+class KeyPoolRegistry:
+    """Central registry for all provider key pools."""
+
+    def __init__(self):
+        self._pools: Dict[str, KeyPool] = {}
+
+    def register(self, provider: str, keys_csv: str):
+        """Register comma-separated keys for a provider."""
+        keys = [k.strip() for k in keys_csv.split(",") if k.strip()]
+        if keys:
+            self._pools[provider] = KeyPool(provider, keys)
+            log.info("KeyPool registered", provider=provider, count=len(keys))
+
+    def get(self, provider: str) -> Optional[KeyPool]:
+        return self._pools.get(provider)
+
+    def all_status(self) -> dict:
+        return {name: pool.status() for name, pool in self._pools.items()}

backend/ai_router/router_v8.py

@@ -0,0 +1,407 @@
+"""
+AIRouter v8 — God Agent OS
+Multi-provider AI router with KeyPool failover.
+Supports: Gemini, SambaNova, OpenAI, Groq, Cerebras, OpenRouter, Anthropic
+Primary LLMs: Gemini (6 keys) + SambaNova (9 keys) — fully pooled
+"""
+
+import asyncio
+import json
+import os
+import time
+from typing import Any, Dict, List, Optional
+
+import httpx
+import structlog
+
+from ai_router.key_pool import KeyPoolRegistry
+
+log = structlog.get_logger()
+
+# ─── Provider Definitions ─────────────────────────────────────────────────────
+
+PROVIDER_CONFIG = [
+    # Priority 1 — SambaNova (fast, free tier)
+    {
+        "name": "sambanova",
+        "key_env": "SAMBANOVA_API_KEYS",
+        "base_url": "https://api.sambanova.ai/v1",
+        "default_model": "Meta-Llama-3.3-70B-Instruct",
+        "type": "openai_compat",
+        "max_tokens": 4096,
+        "priority": 1,
+    },
+    # Priority 2 — Gemini (Google AI)
+    {
+        "name": "gemini",
+        "key_env": "GEMINI_API_KEYS",
+        "base_url": "https://generativelanguage.googleapis.com",
+        "default_model": "gemini-1.5-flash",
+        "type": "gemini",
+        "max_tokens": 8192,
+        "priority": 2,
+    },
+    # Priority 3 — OpenAI
+    {
+        "name": "openai",
+        "key_env": "OPENAI_API_KEY",
+        "base_url": os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
+        "default_model": os.environ.get("DEFAULT_MODEL", "gpt-4o"),
+        "type": "openai_compat",
+        "max_tokens": 4096,
+        "priority": 3,
+    },
+    # Priority 4 — Groq
+    {
+        "name": "groq",
+        "key_env": "GROQ_API_KEY",
+        "base_url": "https://api.groq.com/openai/v1",
+        "default_model": "llama-3.3-70b-versatile",
+        "type": "openai_compat",
+        "max_tokens": 4096,
+        "priority": 4,
+    },
+    # Priority 5 — Cerebras
+    {
+        "name": "cerebras",
+        "key_env": "CEREBRAS_API_KEY",
+        "base_url": "https://api.cerebras.ai/v1",
+        "default_model": "llama3.1-70b",
+        "type": "openai_compat",
+        "max_tokens": 4096,
+        "priority": 5,
+    },
+    # Priority 6 — OpenRouter
+    {
+        "name": "openrouter",
+        "key_env": "OPENROUTER_API_KEY",
+        "base_url": "https://openrouter.ai/api/v1",
+        "default_model": "meta-llama/llama-3.3-70b-instruct:free",
+        "type": "openai_compat",
+        "max_tokens": 4096,
+        "priority": 6,
+    },
+    # Priority 7 — Anthropic
+    {
+        "name": "anthropic",
+        "key_env": "ANTHROPIC_API_KEY",
+        "base_url": "https://api.anthropic.com/v1",
+        "default_model": "claude-3-5-sonnet-20241022",
+        "type": "anthropic",
+        "max_tokens": 4096,
+        "priority": 7,
+    },
+]
+
+
+class AIRouterV8:
+    """
+    God Agent OS v8 AI Router.
+    - KeyPool-based multi-key management per provider
+    - Gemini + SambaNova as primary LLMs
+    - Full failover chain
+    - Streaming support via WebSocket
+    """
+
+    def __init__(self, ws_manager=None):
+        self.ws = ws_manager
+        self._registry = KeyPoolRegistry()
+        self._stats: Dict[str, Dict] = {}
+        self._setup_pools()
+
+    def _setup_pools(self):
+        """Initialize key pools from environment variables."""
+        for cfg in PROVIDER_CONFIG:
+            env_val = os.environ.get(cfg["key_env"], "")
+            if env_val:
+                self._registry.register(cfg["name"], env_val)
+                self._stats[cfg["name"]] = {"calls": 0, "errors": 0, "latency": []}
+            elif cfg["name"] not in self._stats:
+                self._stats[cfg["name"]] = {"calls": 0, "errors": 0, "latency": []}
+
+    def _get_available_providers(self) -> List[Dict]:
+        """Return providers with at least one available key, sorted by priority."""
+        available = []
+        for cfg in sorted(PROVIDER_CONFIG, key=lambda x: x["priority"]):
+            pool = self._registry.get(cfg["name"])
+            # Also check single-key env vars (for backward compat)
+            env_val = os.environ.get(cfg["key_env"], "")
+            if (pool and pool.available_count() > 0) or (env_val and not pool):
+                # Register single keys on-the-fly if not pooled
+                if not pool and env_val:
+                    self._registry.register(cfg["name"], env_val)
+                    if cfg["name"] not in self._stats:
+                        self._stats[cfg["name"]] = {"calls": 0, "errors": 0, "latency": []}
+                available.append(cfg)
+        return available
+
+    # ─── Main Entry Point ──────────────────────────────────────────────────────
+
+    async def complete(
+        self,
+        messages: List[Dict],
+        task_id: str = "",
+        session_id: str = "",
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        preferred_model: str = "",
+        stream: bool = True,
+    ) -> str:
+        """Route request through available providers with KeyPool failover."""
+        providers = self._get_available_providers()
+
+        if not providers:
+            return await self._demo_stream(messages, task_id, session_id)
+
+        last_error = None
+        for cfg in providers:
+            pool = self._registry.get(cfg["name"])
+            if not pool:
+                continue
+
+            key = pool.pick()
+            if not key:
+                continue
+
+            try:
+                start = time.time()
+                result = await self._call_provider(
+                    cfg, key, messages, task_id, session_id,
+                    temperature, max_tokens, preferred_model
+                )
+                elapsed = time.time() - start
+                pool.mark_success(key)
+                self._stats[cfg["name"]]["calls"] += 1
+                self._stats[cfg["name"]]["latency"].append(elapsed)
+                log.info("AIRouter v8 success", provider=cfg["name"], ms=round(elapsed * 1000))
+                return result
+            except Exception as e:
+                last_error = e
+                pool.mark_fail(key)
+                self._stats[cfg["name"]]["errors"] += 1
+                log.warning("AIRouter v8 failover", provider=cfg["name"], error=str(e)[:200])
+                continue
+
+        log.error("All AI providers failed", error=str(last_error))
+        return await self._demo_stream(messages, task_id, session_id)
+
+    async def _call_provider(
+        self, cfg: Dict, key: str, messages: List[Dict],
+        task_id: str, session_id: str, temperature: float,
+        max_tokens: int, preferred_model: str
+    ) -> str:
+        """Dispatch to the correct call method based on provider type."""
+        ptype = cfg["type"]
+        if ptype == "gemini":
+            return await self._gemini_call(cfg, key, messages, task_id, session_id, temperature, max_tokens, preferred_model)
+        elif ptype == "anthropic":
+            return await self._anthropic_call(cfg, key, messages, task_id, session_id, temperature, max_tokens)
+        else:
+            return await self._openai_compat_call(cfg, key, messages, task_id, session_id, temperature, max_tokens, preferred_model)
+
+    # ─── Gemini API ────────────────────────────────────────────────────────────
+
+    async def _gemini_call(
+        self, cfg: Dict, key: str, messages: List[Dict],
+        task_id: str, session_id: str, temperature: float,
+        max_tokens: int, preferred_model: str
+    ) -> str:
+        model = preferred_model or cfg["default_model"]
+        url = f"{cfg['base_url']}/v1beta/models/{model}:streamGenerateContent?key={key}&alt=sse"
+
+        # Convert messages to Gemini format
+        system_instruction = None
+        contents = []
+        for m in messages:
+            if m["role"] == "system":
+                system_instruction = {"parts": [{"text": m["content"]}]}
+            else:
+                role = "user" if m["role"] == "user" else "model"
+                contents.append({"role": role, "parts": [{"text": m["content"]}]})
+
+        payload: Dict[str, Any] = {
+            "contents": contents,
+            "generationConfig": {
+                "temperature": temperature,
+                "maxOutputTokens": max_tokens,
+            },
+        }
+        if system_instruction:
+            payload["systemInstruction"] = system_instruction
+
+        full_text = ""
+        async with httpx.AsyncClient(timeout=120) as client:
+            async with client.stream("POST", url, json=payload, headers={"Content-Type": "application/json"}) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line.startswith("data:"):
+                        continue
+                    chunk_str = line[5:].strip()
+                    if not chunk_str or chunk_str == "[DONE]":
+                        continue
+                    try:
+                        data = json.loads(chunk_str)
+                        for cand in data.get("candidates", []):
+                            for part in cand.get("content", {}).get("parts", []):
+                                delta = part.get("text", "")
+                                if delta:
+                                    full_text += delta
+                                    await self._emit_chunk(delta, task_id, session_id)
+                    except Exception:
+                        pass
+        return full_text
+
+    # ─── OpenAI-compatible ─────────────────────────────────────────────────────
+
+    async def _openai_compat_call(
+        self, cfg: Dict, key: str, messages: List[Dict],
+        task_id: str, session_id: str, temperature: float,
+        max_tokens: int, preferred_model: str
+    ) -> str:
+        model = preferred_model or cfg["default_model"]
+        headers = {
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+        }
+        if cfg["name"] == "openrouter":
+            headers["HTTP-Referer"] = "https://god-agent.ai"
+            headers["X-Title"] = "God Agent OS"
+
+        payload = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        full_text = ""
+        async with httpx.AsyncClient(timeout=120) as client:
+            async with client.stream(
+                "POST", f"{cfg['base_url']}/chat/completions",
+                headers=headers, json=payload
+            ) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line.startswith("data:"):
+                        continue
+                    chunk = line[6:].strip()
+                    if chunk == "[DONE]":
+                        break
+                    try:
+                        data = json.loads(chunk)
+                        delta = data["choices"][0]["delta"].get("content", "")
+                        if delta:
+                            full_text += delta
+                            await self._emit_chunk(delta, task_id, session_id)
+                    except Exception:
+                        pass
+        return full_text
+
+    # ─── Anthropic ─────────────────────────────────────────────────────────────
+
+    async def _anthropic_call(
+        self, cfg: Dict, key: str, messages: List[Dict],
+        task_id: str, session_id: str, temperature: float, max_tokens: int
+    ) -> str:
+        headers = {
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "Content-Type": "application/json",
+        }
+        system = ""
+        filtered = []
+        for m in messages:
+            if m["role"] == "system":
+                system = m["content"]
+            else:
+                filtered.append(m)
+        payload: Dict[str, Any] = {
+            "model": cfg["default_model"],
+            "max_tokens": max_tokens,
+            "messages": filtered,
+            "stream": True,
+            "temperature": temperature,
+        }
+        if system:
+            payload["system"] = system
+        full_text = ""
+        async with httpx.AsyncClient(timeout=120) as client:
+            async with client.stream(
+                "POST", f"{cfg['base_url']}/messages",
+                headers=headers, json=payload
+            ) as resp:
+                resp.raise_for_status()
+                async for line in resp.aiter_lines():
+                    if not line.startswith("data:"):
+                        continue
+                    try:
+                        data = json.loads(line[5:].strip())
+                        if data.get("type") == "content_block_delta":
+                            delta = data["delta"].get("text", "")
+                            if delta:
+                                full_text += delta
+                                await self._emit_chunk(delta, task_id, session_id)
+                    except Exception:
+                        pass
+        return full_text
+
+    # ─── Demo Stream ───────────────────────────────────────────────────────────
+
+    async def _demo_stream(self, messages: List[Dict], task_id: str, session_id: str) -> str:
+        last_user = next((m["content"] for m in reversed(messages) if m["role"] == "user"), "Hello")
+        response = (
+            "🤖 **God Agent OS v8** (Demo Mode)\n\n"
+            f"Received: *{last_user[:100]}*\n\n"
+            "To enable full AI power, set API keys in environment variables:\n"
+            "- `GEMINI_API_KEYS` (Google Gemini — multiple keys supported)\n"
+            "- `SAMBANOVA_API_KEYS` (SambaNova — multiple keys supported)\n"
+            "- `OPENAI_API_KEY`, `GROQ_API_KEY`, `ANTHROPIC_API_KEY`\n\n"
+            "**Active Capabilities:**\n"
+            "- ⚡ 16-agent autonomous orchestration\n"
+            "- 🔑 Multi-key pool with automatic failover\n"
+            "- 🧠 Persistent memory system\n"
+            "- 🔌 Connector ecosystem\n"
+            "- 📡 Real-time WebSocket streaming\n"
+        )
+        full_text = ""
+        for word in response.split():
+            chunk = word + " "
+            full_text += chunk
+            await asyncio.sleep(0.02)
+            await self._emit_chunk(chunk, task_id, session_id, demo=True)
+        return full_text
+
+    # ─── Emit Helper ───────────────────────────────────────────────────────────
+
+    async def _emit_chunk(self, chunk: str, task_id: str, session_id: str, demo: bool = False):
+        if not self.ws:
+            return
+        payload = {"chunk": chunk, "demo": demo}
+        if task_id:
+            await self.ws.emit(task_id, "llm_chunk", payload, session_id=session_id)
+        elif session_id:
+            await self.ws.emit_chat(session_id, "llm_chunk", payload)
+
+    # ─── Stats ─────────────────────────────────────────────────────────────────
+
+    def get_stats(self) -> Dict:
+        result = {}
+        for cfg in PROVIDER_CONFIG:
+            name = cfg["name"]
+            s = self._stats.get(name, {"calls": 0, "errors": 0, "latency": []})
+            pool = self._registry.get(name)
+            lat = s["latency"][-20:]
+            avg_lat = round(sum(lat) / max(len(lat), 1) * 1000, 1) if lat else 0
+            result[name] = {
+                "calls": s["calls"],
+                "errors": s["errors"],
+                "avg_latency_ms": avg_lat,
+                "available": bool(os.environ.get(cfg["key_env"], "")),
+                "key_count": len(pool) if pool else 0,
+                "available_keys": pool.available_count() if pool else 0,
+                "priority": cfg["priority"],
+            }
+        return result
+
+    def get_pool_status(self) -> Dict:
+        return self._registry.all_status()

backend/main_v8.py

@@ -0,0 +1,326 @@
+"""
+🚀 GOD AGENT OS v8 — Autonomous Engineering Operating System
+Manus + Genspark + Devin (OneHand) Combined
+Version: 8.0.0 — KeyPool Multi-API Routing (Gemini + SambaNova Primary LLMs)
+"""
+
+import asyncio
+import json
+import os
+import time
+import uuid
+from contextlib import asynccontextmanager
+from typing import Optional
+
+import structlog
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.responses import JSONResponse
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+
+from api.routes import tasks, chat, memory, github, health
+from api.routes import connectors, agents as agents_router
+from api.websocket_manager import WebSocketManager
+from core.task_engine import TaskEngine
+from memory.db import init_db
+
+# ─── v8 AI Router (KeyPool-based) ─────────────────────────────────────────────
+from ai_router.router_v8 import AIRouterV8
+
+# ─── Agent Ecosystem ──────────────────────────────────────────────────────────
+from agents.orchestrator_v7 import GodAgentOrchestratorV7
+from agents.chat_agent import ChatAgent
+from agents.planner_agent import PlannerAgent
+from agents.coding_agent import CodingAgent
+from agents.debug_agent import DebugAgent
+from agents.memory_agent import MemoryAgent
+from agents.connector_agent import ConnectorAgent
+from agents.deploy_agent import DeployAgent
+from agents.workflow_agent import WorkflowAgent
+from agents.sandbox_agent import SandboxAgent
+from agents.ui_agent import UIAgent
+from agents.reasoning_agent import ReasoningAgent
+from agents.browser_agent import BrowserAgent
+from agents.file_agent import FileAgent
+from agents.git_agent import GitAgent
+from agents.test_agent import TestAgent
+from agents.vision_agent import VisionAgent
+from connectors.manager import ConnectorManager
+
+# ─── Structured Logging ───────────────────────────────────────────────────────
+structlog.configure(
+    processors=[
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.stdlib.add_log_level,
+        structlog.processors.StackInfoRenderer(),
+        structlog.dev.ConsoleRenderer(),
+    ]
+)
+log = structlog.get_logger()
+
+limiter = Limiter(key_func=get_remote_address)
+
+# ─── Global Managers ──────────────────────────────────────────────────────────
+ws_manager = WebSocketManager()
+task_engine = TaskEngine(ws_manager)
+ai_router = AIRouterV8(ws_manager)
+connector_manager = ConnectorManager()
+
+
+def build_orchestrator() -> GodAgentOrchestratorV7:
+    orchestrator = GodAgentOrchestratorV7(ws_manager=ws_manager, ai_router=ai_router)
+    orchestrator.register_agent("chat",       ChatAgent(ws_manager, ai_router))
+    orchestrator.register_agent("planner",    PlannerAgent(ws_manager, ai_router))
+    orchestrator.register_agent("coding",     CodingAgent(ws_manager, ai_router))
+    orchestrator.register_agent("debug",      DebugAgent(ws_manager, ai_router))
+    orchestrator.register_agent("memory",     MemoryAgent(ws_manager, ai_router))
+    orchestrator.register_agent("connector",  ConnectorAgent(ws_manager, ai_router))
+    orchestrator.register_agent("deploy",     DeployAgent(ws_manager, ai_router))
+    orchestrator.register_agent("workflow",   WorkflowAgent(ws_manager, ai_router))
+    orchestrator.register_agent("sandbox",    SandboxAgent(ws_manager, ai_router))
+    orchestrator.register_agent("ui",         UIAgent(ws_manager, ai_router))
+    orchestrator.register_agent("reasoning",  ReasoningAgent(ws_manager, ai_router))
+    orchestrator.register_agent("browser",    BrowserAgent(ws_manager, ai_router))
+    orchestrator.register_agent("file",       FileAgent(ws_manager, ai_router))
+    orchestrator.register_agent("git",        GitAgent(ws_manager, ai_router))
+    orchestrator.register_agent("test",       TestAgent(ws_manager, ai_router))
+    orchestrator.register_agent("vision",     VisionAgent(ws_manager, ai_router))
+    log.info("🤖 GOD AGENT v8 Ecosystem initialized", agents=16)
+    return orchestrator
+
+
+orchestrator = build_orchestrator()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    log.info("🚀 Starting GOD AGENT OS v8 — KeyPool Multi-API Edition...")
+    await init_db()
+    await task_engine.start()
+    asyncio.create_task(ws_manager.heartbeat_loop())
+    # Print router status
+    stats = ai_router.get_stats()
+    active = [name for name, s in stats.items() if s["available"]]
+    log.info("✅ GOD AGENT v8 — 16 agents online")
+    log.info(f"🔑 Active AI providers: {active}")
+    log.info("🌐 AI Routing: SambaNova → Gemini → OpenAI → Groq → Cerebras → OpenRouter → Anthropic")
+    yield
+    log.info("🛑 Shutting down GOD AGENT v8...")
+    await task_engine.stop()
+
+
+app = FastAPI(
+    title="🤖 GOD AGENT OS v8",
+    description="Autonomous Engineering OS — Gemini + SambaNova KeyPool Multi-API Routing",
+    version="8.0.0",
+    lifespan=lifespan,
+    docs_url="/api/docs",
+    redoc_url="/api/redoc",
+)
+
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+app.state.ws_manager = ws_manager
+app.state.task_engine = task_engine
+app.state.ai_router = ai_router
+app.state.orchestrator = orchestrator
+app.state.connector_manager = connector_manager
+
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start = time.time()
+    response = await call_next(request)
+    ms = round((time.time() - start) * 1000, 2)
+    log.info("HTTP", method=request.method, path=request.url.path, status=response.status_code, ms=ms)
+    return response
+
+
+# ─── REST Routers ─────────────────────────────────────────────────────────────
+app.include_router(health.router,        prefix="/api/v1",            tags=["health"])
+app.include_router(tasks.router,         prefix="/api/v1/tasks",      tags=["tasks"])
+app.include_router(chat.router,          prefix="/api/v1",            tags=["chat"])
+app.include_router(memory.router,        prefix="/api/v1/memory",     tags=["memory"])
+app.include_router(github.router,        prefix="/api/v1/github",     tags=["github"])
+app.include_router(connectors.router,    prefix="/api/v1/connectors", tags=["connectors"])
+app.include_router(agents_router.router, prefix="/api/v1/agents",     tags=["agents"])
+
+
+# ─── WebSocket Endpoints ──────────────────────────────────────────────────────
+@app.websocket("/ws/tasks/{task_id}")
+async def ws_task(websocket: WebSocket, task_id: str):
+    await ws_manager.connect(websocket, room=f"task:{task_id}")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            msg = json.loads(data)
+            if msg.get("type") == "ping":
+                await websocket.send_json({"type": "pong", "timestamp": time.time()})
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, room=f"task:{task_id}")
+
+
+@app.websocket("/ws/logs")
+async def ws_logs(websocket: WebSocket):
+    await ws_manager.connect(websocket, room="logs")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            msg = json.loads(data)
+            if msg.get("type") == "ping":
+                await websocket.send_json({"type": "pong", "timestamp": time.time()})
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, room="logs")
+
+
+@app.websocket("/ws/chat/{session_id}")
+async def ws_chat(websocket: WebSocket, session_id: str):
+    await ws_manager.connect(websocket, room=f"chat:{session_id}")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            msg = json.loads(data)
+            if msg.get("type") == "ping":
+                await websocket.send_json({"type": "pong", "timestamp": time.time()})
+            elif msg.get("type") == "chat_message":
+                asyncio.create_task(orchestrator.orchestrate(
+                    user_message=msg.get("content", ""),
+                    session_id=session_id,
+                    context=msg.get("context", {}),
+                ))
+            elif msg.get("type") == "task_message":
+                from core.models import TaskCreateRequest
+                req = TaskCreateRequest(goal=msg.get("content", ""), session_id=session_id)
+                asyncio.create_task(task_engine.submit(req))
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, room=f"chat:{session_id}")
+
+
+@app.websocket("/ws/agent/status")
+async def ws_agent_status(websocket: WebSocket):
+    await ws_manager.connect(websocket, room="agent_status")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            msg = json.loads(data)
+            if msg.get("type") == "ping":
+                await websocket.send_json({"type": "pong", "timestamp": time.time()})
+            elif msg.get("type") == "get_status":
+                await websocket.send_json({"type": "agent_status", "data": orchestrator.get_status()})
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, room="agent_status")
+
+
+@app.websocket("/ws/sandbox/{session_id}")
+async def ws_sandbox(websocket: WebSocket, session_id: str):
+    await ws_manager.connect(websocket, room=f"sandbox:{session_id}")
+    sandbox = orchestrator.get_agent("sandbox")
+    try:
+        while True:
+            data = await websocket.receive_text()
+            msg = json.loads(data)
+            if msg.get("type") == "ping":
+                await websocket.send_json({"type": "pong", "timestamp": time.time()})
+            elif msg.get("type") == "execute" and sandbox:
+                cmd = msg.get("command", "")
+                result = await sandbox.execute(cmd, session_id=session_id)
+                await websocket.send_json({"type": "terminal_output", "command": cmd, "output": result, "timestamp": time.time()})
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
+
+
+# ─── v8 Key Pool & AI Router Status Endpoints ─────────────────────────────────
+@app.get("/api/v1/ai/stats")
+async def get_ai_stats():
+    return {"stats": ai_router.get_stats()}
+
+
+@app.get("/api/v1/ai/pool-status")
+async def get_pool_status():
+    return {"pools": ai_router.get_pool_status()}
+
+
+@app.post("/api/v1/browser/research")
+async def browser_research(request: Request):
+    body = await request.json()
+    browser = orchestrator.get_agent("browser")
+    if not browser:
+        raise HTTPException(status_code=503, detail="BrowserAgent not available")
+    result = await browser.run(body.get("query", ""), session_id=body.get("session_id", ""))
+    return {"result": result}
+
+
+@app.get("/api/v1/files/workspace")
+async def list_workspace():
+    file_agent = orchestrator.get_agent("file")
+    if not file_agent:
+        return {"workspace": "/tmp/god_workspace", "files": [], "total": 0}
+    return file_agent.list_workspace()
+
+
+@app.post("/api/v1/git/pr")
+async def create_pr(request: Request):
+    body = await request.json()
+    git_agent = orchestrator.get_agent("git")
+    if not git_agent:
+        raise HTTPException(status_code=503, detail="GitAgent not available")
+    result = await git_agent.create_github_pr(
+        repo_owner=body.get("owner", ""),
+        repo_name=body.get("repo", ""),
+        title=body.get("title", ""),
+        body=body.get("body", ""),
+        head_branch=body.get("head_branch", "main"),
+        base_branch=body.get("base_branch", "main"),
+    )
+    return result
+
+
+@app.post("/api/v1/vision/generate")
+async def generate_ui(request: Request):
+    body = await request.json()
+    vision = orchestrator.get_agent("vision")
+    if not vision:
+        raise HTTPException(status_code=503, detail="VisionAgent not available")
+    result = await vision.run(body.get("prompt", ""), context=body.get("context", {}), session_id=body.get("session_id", ""))
+    return {"result": result}
+
+
+# ─── Root ─────────────────────────────────────────────────────────────────────
+@app.get("/")
+async def root():
+    cs = connector_manager.get_summary()
+    status = orchestrator.get_status()
+    stats = ai_router.get_stats()
+    active_providers = [name for name, s in stats.items() if s["available"]]
+    return {
+        "name": "🤖 GOD AGENT OS v8",
+        "version": "8.0.0",
+        "status": "operational",
+        "mode": "autonomous_engineering_os",
+        "description": "KeyPool Multi-API Routing — Gemini + SambaNova Primary LLMs",
+        "agents": status["agents"],
+        "total_agents": status["total_agents"],
+        "ai_providers": active_providers,
+        "connectors": {"connected": cs["connected"], "total": cs["total"]},
+        "docs": "/api/docs",
+        "v8_features": [
+            "🔑 KeyPool multi-key management (Gemini 6 keys + SambaNova 9 keys)",
+            "🔄 Automatic key failover with cooldown tracking",
+            "⚡ SambaNova → Gemini → OpenAI → Groq → Cerebras chain",
+            "📊 Per-key usage stats & health monitoring",
+            "🤖 16-agent autonomous fleet",
+            "🌐 Real-time streaming via WebSocket",
+        ],
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run("main_v8:app", host="0.0.0.0", port=port, reload=False, workers=1)

frontend/app/page.tsx

@@ -13,6 +13,7 @@ import ConnectorsPanel from '@/components/layout/ConnectorsPanel'
 import SandboxPanel from '@/components/layout/SandboxPanel'
 import FileExplorer from '@/components/layout/FileExplorer'
 import BrowserPanel from '@/components/layout/BrowserPanel'
+import AIRouterPanel from '@/components/layout/AIRouterPanel'
 import { Zap } from 'lucide-react'
 
 export default function HomePage() {
@@ -39,8 +40,9 @@ export default function HomePage() {
           <Zap size={28} className="text-indigo-400" />
         </div>
         <h2 className="text-lg font-bold mb-1" style={{ color: 'var(--text-primary)' }}>GOD AGENT OS</h2>
-        <p className="text-sm mb-1" style={{ color: 'var(--text-muted)' }}>Autonomous Engineering Platform v7.0</p>
-        <p className="text-xs mb-4" style={{ color: 'var(--text-muted)' }}>Manus + Genspark + Devin</p>
+        <p className="text-sm mb-1" style={{ color: 'var(--text-muted)' }}>Autonomous Engineering Platform v8.0</p>
+        <p className="text-xs mb-1" style={{ color: 'var(--text-muted)' }}>Manus + Genspark + Devin</p>
+        <p className="text-xs mb-4" style={{ color: '#6366f1' }}>KeyPool: Gemini × 6 + SambaNova × 9</p>
         <div className="flex gap-1.5 justify-center">
           {[0, 1, 2].map(i => (
             <div key={i} className="typing-dot" style={{ animationDelay: `${i * 0.16}s` }} />
@@ -59,6 +61,7 @@ export default function HomePage() {
       case 'sandbox':    return <SandboxPanel />
       case 'files':      return <FileExplorer />
       case 'browser':    return <BrowserPanel />
+      case 'ai_router':  return <AIRouterPanel />
       default:           return <ExecutionTimeline />
     }
   }

frontend/components/layout/AIRouterPanel.tsx

@@ -0,0 +1,268 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useAgentStore } from '@/hooks/useAgentStore'
+import { Cpu, Key, RefreshCw, CheckCircle2, XCircle, AlertCircle, Zap, Activity } from 'lucide-react'
+
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:7860'
+
+interface ProviderStat {
+  calls: number
+  errors: number
+  avg_latency_ms: number
+  available: boolean
+  key_count: number
+  available_keys: number
+  priority: number
+}
+
+interface KeyInfo {
+  key_preview: string
+  available: boolean
+  failures: number
+  calls: number
+  cooldown_remaining_s: number
+}
+
+interface PoolStatus {
+  provider: string
+  total_keys: number
+  available_keys: number
+  keys: KeyInfo[]
+}
+
+const PROVIDER_ICONS: Record<string, string> = {
+  sambanova: '⚡',
+  gemini: '✨',
+  openai: '🤖',
+  groq: '🦙',
+  cerebras: '🧠',
+  openrouter: '🔀',
+  anthropic: '🪄',
+}
+
+const PROVIDER_COLORS: Record<string, string> = {
+  sambanova: '#f97316',
+  gemini: '#4285f4',
+  openai: '#10a37f',
+  groq: '#f59e0b',
+  cerebras: '#8b5cf6',
+  openrouter: '#6366f1',
+  anthropic: '#d97706',
+}
+
+export default function AIRouterPanel() {
+  const { locale } = useAgentStore()
+  const [stats, setStats] = useState<Record<string, ProviderStat>>({})
+  const [pools, setPools] = useState<Record<string, PoolStatus>>({})
+  const [loading, setLoading] = useState(true)
+  const [expandedProvider, setExpandedProvider] = useState<string | null>(null)
+  const [lastRefresh, setLastRefresh] = useState<Date | null>(null)
+
+  const load = async () => {
+    setLoading(true)
+    try {
+      const [statsRes, poolRes] = await Promise.all([
+        fetch(`${API_URL}/api/v1/ai/stats`).then(r => r.json()).catch(() => ({})),
+        fetch(`${API_URL}/api/v1/ai/pool-status`).then(r => r.json()).catch(() => ({})),
+      ])
+      setStats(statsRes.stats || {})
+      setPools(poolRes.pools || {})
+      setLastRefresh(new Date())
+    } catch {}
+    setLoading(false)
+  }
+
+  useEffect(() => {
+    load()
+    const interval = setInterval(load, 30000)
+    return () => clearInterval(interval)
+  }, [])
+
+  const sortedProviders = Object.entries(stats).sort(
+    ([, a], [, b]) => (a.priority || 99) - (b.priority || 99)
+  )
+
+  const activeCount = sortedProviders.filter(([, s]) => s.available).length
+  const totalCalls = sortedProviders.reduce((sum, [, s]) => sum + s.calls, 0)
+
+  return (
+    <div className="flex flex-col h-full" style={{ background: 'var(--bg-2)' }}>
+      {/* Header */}
+      <div className="flex items-center justify-between px-4 py-2.5 border-b shrink-0"
+        style={{ borderColor: 'var(--border)', background: 'var(--bg-3)' }}>
+        <div className="flex items-center gap-2">
+          <Cpu size={14} className="text-indigo-400" />
+          <span className="text-sm font-semibold" style={{ color: 'var(--text-primary)' }}>
+            {locale === 'my' ? 'AI Router v8' : 'AI Router v8'}
+          </span>
+          <span className="text-[10px] px-1.5 py-0.5 rounded-full"
+            style={{
+              background: activeCount > 0 ? 'rgba(34,197,94,0.15)' : 'rgba(239,68,68,0.15)',
+              color: activeCount > 0 ? '#4ade80' : '#f87171',
+              border: `1px solid ${activeCount > 0 ? 'rgba(34,197,94,0.3)' : 'rgba(239,68,68,0.3)'}`,
+            }}>
+            {activeCount} active
+          </span>
+        </div>
+        <button onClick={load} disabled={loading}
+          className="p-1.5 rounded-lg hover:bg-white/5 transition-colors" title="Refresh">
+          <RefreshCw size={12} style={{ color: 'var(--text-muted)' }}
+            className={loading ? 'animate-spin' : ''} />
+        </button>
+      </div>
+
+      {/* Summary */}
+      <div className="px-3 py-2 border-b flex gap-3 text-xs"
+        style={{ borderColor: 'var(--border)', background: 'rgba(99,102,241,0.05)' }}>
+        <div className="flex items-center gap-1">
+          <Activity size={10} className="text-indigo-400" />
+          <span style={{ color: 'var(--text-muted)' }}>Total calls:</span>
+          <span className="font-mono font-semibold" style={{ color: 'var(--text-primary)' }}>{totalCalls}</span>
+        </div>
+        <div className="flex items-center gap-1">
+          <Key size={10} className="text-indigo-400" />
+          <span style={{ color: 'var(--text-muted)' }}>Providers:</span>
+          <span className="font-mono font-semibold" style={{ color: 'var(--text-primary)' }}>
+            {activeCount}/{sortedProviders.length}
+          </span>
+        </div>
+        {lastRefresh && (
+          <div className="ml-auto text-[10px]" style={{ color: 'var(--text-muted)' }}>
+            {lastRefresh.toLocaleTimeString()}
+          </div>
+        )}
+      </div>
+
+      {/* Provider List */}
+      <div className="flex-1 overflow-y-auto">
+        {loading && sortedProviders.length === 0 ? (
+          <div className="flex items-center justify-center h-24">
+            <div className="flex gap-1">
+              {[0, 1, 2].map(i => (
+                <div key={i} className="w-1.5 h-1.5 rounded-full animate-bounce"
+                  style={{ background: 'var(--brand)', animationDelay: `${i * 0.15}s` }} />
+              ))}
+            </div>
+          </div>
+        ) : sortedProviders.length === 0 ? (
+          <div className="p-4 text-center text-xs" style={{ color: 'var(--text-muted)' }}>
+            No providers configured
+          </div>
+        ) : (
+          <div className="p-2 flex flex-col gap-1.5">
+            {sortedProviders.map(([name, stat]) => {
+              const pool = pools[name]
+              const icon = PROVIDER_ICONS[name] || '🔌'
+              const color = PROVIDER_COLORS[name] || '#6366f1'
+              const isExpanded = expandedProvider === name
+              const successRate = stat.calls > 0
+                ? Math.round(((stat.calls - stat.errors) / stat.calls) * 100)
+                : 100
+
+              return (
+                <div key={name}
+                  className="rounded-xl border overflow-hidden cursor-pointer hover:border-opacity-60 transition-all"
+                  style={{
+                    borderColor: stat.available ? `${color}40` : 'var(--border)',
+                    background: stat.available ? `${color}08` : 'var(--bg-3)',
+                  }}
+                  onClick={() => setExpandedProvider(isExpanded ? null : name)}>
+
+                  {/* Provider Header */}
+                  <div className="flex items-center gap-2 px-3 py-2">
+                    <span className="text-sm">{icon}</span>
+                    <div className="flex-1 min-w-0">
+                      <div className="flex items-center gap-2">
+                        <span className="text-xs font-semibold capitalize" style={{ color: 'var(--text-primary)' }}>
+                          {name}
+                        </span>
+                        {stat.priority <= 2 && (
+                          <span className="text-[9px] px-1 py-0.5 rounded font-bold"
+                            style={{ background: `${color}25`, color }}>
+                            PRIMARY
+                          </span>
+                        )}
+                      </div>
+                      <div className="flex items-center gap-2 mt-0.5">
+                        <span className="text-[10px]" style={{ color: 'var(--text-muted)' }}>
+                          {stat.calls} calls · {stat.avg_latency_ms}ms avg
+                        </span>
+                        {pool && (
+                          <span className="text-[10px]" style={{ color: 'var(--text-muted)' }}>
+                            · {pool.available_keys}/{pool.total_keys} keys
+                          </span>
+                        )}
+                      </div>
+                    </div>
+                    <div className="flex items-center gap-1.5">
+                      {/* Success Rate Bar */}
+                      {stat.calls > 0 && (
+                        <div className="w-12 h-1.5 rounded-full overflow-hidden"
+                          style={{ background: 'var(--bg-0)' }}>
+                          <div className="h-full rounded-full transition-all"
+                            style={{
+                              width: `${successRate}%`,
+                              background: successRate > 80 ? '#4ade80' : successRate > 50 ? '#fbbf24' : '#f87171',
+                            }} />
+                        </div>
+                      )}
+                      {stat.available ? (
+                        <CheckCircle2 size={12} style={{ color: '#4ade80' }} />
+                      ) : (
+                        <XCircle size={12} style={{ color: '#f87171' }} />
+                      )}
+                    </div>
+                  </div>
+
+                  {/* Expanded Key Pool */}
+                  {isExpanded && pool && pool.keys.length > 0 && (
+                    <div className="px-3 pb-3 border-t" style={{ borderColor: 'var(--border)' }}>
+                      <div className="pt-2 text-[10px] font-semibold mb-2" style={{ color: 'var(--text-muted)' }}>
+                        KEY POOL ({pool.available_keys}/{pool.total_keys} available)
+                      </div>
+                      <div className="flex flex-col gap-1">
+                        {pool.keys.map((k, i) => (
+                          <div key={i} className="flex items-center gap-2 px-2 py-1 rounded-lg"
+                            style={{ background: k.available ? 'rgba(34,197,94,0.05)' : 'rgba(239,68,68,0.05)' }}>
+                            <Key size={9} style={{ color: k.available ? '#4ade80' : '#f87171' }} />
+                            <span className="font-mono text-[10px] flex-1" style={{ color: 'var(--text-secondary)' }}>
+                              {k.key_preview}
+                            </span>
+                            <span className="text-[9px]" style={{ color: 'var(--text-muted)' }}>
+                              {k.calls} calls
+                            </span>
+                            {k.failures > 0 && (
+                              <span className="text-[9px]" style={{ color: '#fbbf24' }}>
+                                {k.failures} fails
+                              </span>
+                            )}
+                            {!k.available && k.cooldown_remaining_s > 0 && (
+                              <span className="text-[9px] px-1 rounded"
+                                style={{ background: 'rgba(239,68,68,0.15)', color: '#f87171' }}>
+                                {Math.round(k.cooldown_remaining_s)}s
+                              </span>
+                            )}
+                          </div>
+                        ))}
+                      </div>
+                    </div>
+                  )}
+                </div>
+              )
+            })}
+          </div>
+        )}
+      </div>
+
+      {/* Footer Info */}
+      <div className="px-3 py-2 border-t text-[10px]"
+        style={{ borderColor: 'var(--border)', color: 'var(--text-muted)', background: 'var(--bg-3)' }}>
+        <div className="flex items-center gap-1">
+          <Zap size={9} className="text-indigo-400" />
+          <span>Priority: SambaNova → Gemini → OpenAI → Groq → Cerebras → Anthropic</span>
+        </div>
+      </div>
+    </div>
+  )
+}

frontend/components/layout/Sidebar.tsx

@@ -17,6 +17,7 @@ const PANELS: { id: ActivePanel; icon: React.ElementType; labelEn: string; label
   { id: 'browser',    icon: Globe,          labelEn: 'Browser',     labelMy: 'ဘရောင်ဇာ',  badge: 'v7' },
   { id: 'memory',     icon: Brain,          labelEn: 'Memory',      labelMy: 'မှတ်ဉာဏ်' },
   { id: 'connectors', icon: Plug,           labelEn: 'Connectors',  labelMy: 'ချိတ်ဆက်မှု' },
+  { id: 'ai_router',   icon: Cpu,            labelEn: 'AI Router',   labelMy: 'AI Router',    badge: 'v8' },
 ]
 
 const AGENT_META: Record<string, { icon: React.ElementType; color: string; label: string; isNew?: boolean }> = {
@@ -128,7 +129,7 @@ export default function Sidebar() {
         <div className="flex items-center gap-2 px-2 py-1.5 rounded-lg text-[10px]"
           style={{ background: 'rgba(99,102,241,0.08)', border: '1px solid rgba(99,102,241,0.2)' }}>
           <Bot size={10} className="text-indigo-400" />
-          <span style={{ color: 'var(--text-muted)' }}>God Agent OS v7.0</span>
+          <span style={{ color: 'var(--text-muted)' }}>God Agent OS v8.0</span>
           <div className="ml-auto w-1.5 h-1.5 rounded-full bg-green-400 animate-pulse" />
         </div>
       </div>

frontend/hooks/useAgentStore.ts

@@ -9,7 +9,7 @@ import { nanoid } from './nanoid'
 export type Theme = 'dark' | 'light' | 'amoled' | 'neon' | 'glass'
 export type Locale = 'en' | 'my'
 export type AgentName = 'chat' | 'planner' | 'coding' | 'debug' | 'memory' | 'connector' | 'deploy' | 'workflow' | 'sandbox' | 'ui' | 'browser' | 'file' | 'git' | 'test' | 'vision' | 'reasoning'
-export type ActivePanel = 'timeline' | 'tasks' | 'memory' | 'connectors' | 'sandbox' | 'files' | 'browser'
+export type ActivePanel = 'timeline' | 'tasks' | 'memory' | 'connectors' | 'sandbox' | 'files' | 'browser' | 'ai_router'
 
 export interface Message {
   id: string