#!/usr/bin/env python3 """ Simple OpenRouter Swarm Launcher Backup script for firing agents when openrouter_swarm.py isn't suitable. """ import os import json import asyncio import aiohttp from datetime import datetime from pathlib import Path # Configuration OPENROUTER_API_KEY = "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" OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1/chat/completions" # Model IDs KIMI_MODEL = "moonshotai/kimi-k2.5" MINIMAX_MODEL = "minimax/minimax-m2.5" # Sunaiva task categories TASK_CATEGORIES = [ "AI Memory MCP - edge case testing, documentation, API hardening", "Talking Widget - error message sanitization, architecture hiding, widget.js optimization", "Marketing copy - social media posts, LinkedIn articles, blog content", "Partner onboarding - automated partner signup flow, commission tracking", "Customer onboarding - signup flow, Stripe checkout integration, welcome emails" ] async def fire_agent(session, model_id, task_prompt, agent_num): """Fire a single agent.""" headers = { "Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json", "HTTP-Referer": "https://github.com/genesis-system", "X-Title": "Genesis Swarm" } payload = { "model": model_id, "messages": [ { "role": "system", "content": "You are an expert developer and content strategist building Sunaiva products." }, { "role": "user", "content": task_prompt } ], "temperature": 0.7, "max_tokens": 4096 } try: async with session.post(OPENROUTER_BASE_URL, json=payload, headers=headers) as response: if response.status == 200: data = await response.json() result = { "agent_num": agent_num, "model": model_id, "status": "success", "response": data['choices'][0]['message']['content'], "usage": data.get('usage', {}), "timestamp": datetime.now().isoformat() } return result else: error_text = await response.text() return { "agent_num": agent_num, "model": model_id, "status": "failed", "error": f"HTTP {response.status}: {error_text}", "timestamp": datetime.now().isoformat() } except Exception as e: return { "agent_num": agent_num, "model": model_id, "status": "failed", "error": str(e), "timestamp": datetime.now().isoformat() } async def fire_swarm(num_kimi=100, num_minimax=100, output_dir="/mnt/e/genesis-system/swarm-output/session21"): """Fire the full swarm.""" print(f"\n{'='*80}") print("GENESIS SIMPLE SWARM LAUNCHER") print(f"{'='*80}") print(f"Firing {num_kimi} Kimi agents + {num_minimax} MiniMax agents = {num_kimi + num_minimax} total") print(f"Output directory: {output_dir}") print(f"{'='*80}\n") # Create output directory Path(output_dir).mkdir(parents=True, exist_ok=True) async with aiohttp.ClientSession() as session: tasks = [] # Fire Kimi agents (code/architecture tasks) print(f"🚀 Firing {num_kimi} Kimi K2.5 agents...") for i in range(num_kimi): category = TASK_CATEGORIES[i % len(TASK_CATEGORIES)] task_prompt = f"""Work on the following Sunaiva product area: {category} Your task: Generate production-ready code, tests, documentation, or content for this area. Be specific, actionable, and include working examples. Focus on shipping real value. Agent #{i+1} of {num_kimi} (Kimi K2.5 - Code/Architecture) """ tasks.append(fire_agent(session, KIMI_MODEL, task_prompt, i+1)) # Fire MiniMax agents (content/marketing tasks) print(f"🚀 Firing {num_minimax} MiniMax M2.5 agents...") for i in range(num_minimax): category = TASK_CATEGORIES[i % len(TASK_CATEGORIES)] task_prompt = f"""Work on the following Sunaiva product area: {category} Your task: Create compelling marketing copy, documentation, social media content, or customer-facing materials. Be persuasive, clear, and conversion-focused. Agent #{i+1} of {num_minimax} (MiniMax M2.5 - Content/Marketing) """ tasks.append(fire_agent(session, MINIMAX_MODEL, task_prompt, i+1)) # Execute all agents in parallel print(f"⚡ Executing {len(tasks)} agents in parallel...") results = await asyncio.gather(*tasks) # Save results kimi_results = [r for r in results if KIMI_MODEL in r['model']] minimax_results = [r for r in results if MINIMAX_MODEL in r['model']] kimi_file = f"{output_dir}/kimi_results.jsonl" minimax_file = f"{output_dir}/minimax_results.jsonl" with open(kimi_file, 'w') as f: for result in kimi_results: f.write(json.dumps(result) + '\n') with open(minimax_file, 'w') as f: for result in minimax_results: f.write(json.dumps(result) + '\n') # Calculate stats kimi_success = len([r for r in kimi_results if r['status'] == 'success']) minimax_success = len([r for r in minimax_results if r['status'] == 'success']) total_success = kimi_success + minimax_success total_failed = len(results) - total_success total_tokens = sum(r.get('usage', {}).get('total_tokens', 0) for r in results) # Estimate cost: $1.07/MTok for Kimi, $1.00/MTok for MiniMax kimi_tokens = sum(r.get('usage', {}).get('total_tokens', 0) for r in kimi_results) minimax_tokens = sum(r.get('usage', {}).get('total_tokens', 0) for r in minimax_results) kimi_cost = (kimi_tokens / 1_000_000) * 1.07 minimax_cost = (minimax_tokens / 1_000_000) * 1.00 total_cost = kimi_cost + minimax_cost # Print report print(f"\n{'='*80}") print("SWARM EXECUTION COMPLETE") print(f"{'='*80}") print(f"Total agents fired: {len(results)}") print(f" Kimi K2.5: {num_kimi}") print(f" MiniMax M2.5: {num_minimax}") print() print(f"Success: {total_success} ({total_success/len(results)*100:.1f}%)") print(f" Kimi: {kimi_success}/{num_kimi}") print(f" MiniMax: {minimax_success}/{num_minimax}") print() print(f"Failed: {total_failed}") print() print(f"Token usage:") print(f" Kimi: {kimi_tokens:,} tokens") print(f" MiniMax: {minimax_tokens:,} tokens") print(f" Total: {total_tokens:,} tokens") print() print(f"Cost estimate:") print(f" Kimi: ${kimi_cost:.4f}") print(f" MiniMax: ${minimax_cost:.4f}") print(f" Total: ${total_cost:.4f}") print() print(f"Output files:") print(f" {kimi_file}") print(f" {minimax_file}") print(f"{'='*80}\n") if __name__ == "__main__": import sys # Parse command line args num_kimi = int(sys.argv[1]) if len(sys.argv) > 1 else 100 num_minimax = int(sys.argv[2]) if len(sys.argv) > 2 else 100 asyncio.run(fire_swarm(num_kimi, num_minimax))