title: MiniMax M2.5 as Value King

insight: MiniMax M2.5 matches Opus 4.6 on SWE-bench (80.2%) at 1/20th the cost ($0.98 vs $20/MTok), making it the primary model for most Genesis coding workload

reasoning_chain: Analyzed 11 model profiles with pricing, context windows, and benchmark scores

reasoning_chain: MiniMax M2.5 released Feb 12, 2026 shows 80.2% SWE-bench Verified

reasoning_chain: Compared cost per token: MiniMax $0.98 vs Opus 4.6 $20.00

reasoning_chain: Conclusion: MiniMax should handle most Genesis coding immediately for massive cost savings

source_context: MiniMax M2.5 = value king — Matches Opus 4.6 on SWE-bench (80.2%) at 1/20th the cost ($0.98 vs $20/MTok). Should be handling most Genesis coding NOW.


title: GPT-4o Obsolete for Coding

insight: GPT-4o is objectively the worst value in the stack at 30.8% SWE-bench with $10/MTok output - should be dropped for all coding tasks

reasoning_chain: Compared all models on SWE-bench benchmark

reasoning_chain: GPT-4o scored only 30.8% vs competitors at 78-80%

reasoning_chain: GPT-4o costs $10/MTok output - highest among performers

reasoning_chain: Decision: Drop GPT-4o entirely except for OpenAI ecosystem compatibility (Custom GPTs, DALL-E)

source_context: GPT-4o is dead weight — At 30.8% SWE-bench and $10/MTok output, it is objectively the worst value in the entire stack. Every other model outperforms it on coding, and most cost less.


title: Optimal Model Routing Table

insight: Seven-task routing table assigns specific models based on cost-performance ratio: Opus 4.6 for orchestration, MiniMax M2.5 for complex code, Gemini 3 Flash for standard code, Kimi K2.5 for frontend, DeepSeek V3.2 for extraction, Haiku 4.5 for voice, MiniMax for browsing

reasoning_chain: Created 11-model profiles with benchmarks and pricing

reasoning_chain: Built optimal routing table mapping 17 task types to Primary/Fallback1/Fallback2

reasoning_chain: Identified each model's strongest use case based on benchmark leadership

reasoning_chain: Established cost-efficiency matrix with Intelligence-Per-Dollar rankings

source_context: Routing table: Orchestration → Opus 4.6, Complex code → MiniMax M2.5, Standard code → Gemini 3 Flash, Frontend → Kimi K2.5, Extraction → DeepSeek V3.2, Voice backend → Haiku 4.5, Web browsing → MiniMax M2.5


title: Auto-Respawn System Gap Discovery and Fix

insight: Auto-respawn system was 85% built but had P0 gap - SessionStart recovery hook was missing, meaning Claude would respawn but have no memory of prior work

reasoning_chain: Auto-respawn researcher found 7-layer defense system functional (StatusLine, Context Tracker, PreCompact, Autocompact, Session Heartbeat, Auto-Respawn, Stop State Flush)

reasoning_chain: Discovered critical gap: when Claude fires SessionStart after compaction/restart, NO hook reads handoff files to inject recovery context

reasoning_chain: PreCompact hooks CANNOT block compaction - only side effects allowed

reasoning_chain: Stop hooks CAN force Claude to continue via {"decision": "block"}

reasoning_chain: Solution: Built session_recovery_start.py SessionStart hook that reads handoff files and injects recovery context

source_context: The Genesis auto-respawn architecture is 85% built... The critical missing piece is a SessionStart recovery hook. When Claude Code fires SessionStart after compaction (source: 'compact') or after a respawn (source: 'startup' or 'resume'), there is NO hook that reads the handoff files and injects recovery context. This is the P0 gap.


title: PRD-Based Swarm Missions

insight: Swarm missions shifted from generic tasks to 102 atomic stories decomposed from 4 revenue-critical PRDs, expandable to 200 stories

reasoning_chain: Kinan directed: use master PRDs with atomic stories and test suites for agent swarms

reasoning_chain: PRD swarm missions agent decomposed 4 PRDs into atomic stories: Sunaiva Memory Vault (30), ReceptionistAI (28), Talking Widget MVP (21), Voice+Memory MVP (23)

reasoning_chain: Each story includes user story format, acceptance criteria, black box tests, white box tests, token estimate, model assignment

reasoning_chain: Added expansion plan: 37 more Kimi stories for infrastructure, 61 more MiniMax stories for marketing = 200 total

source_context: Kinan said swarm should work on master PRDs with atomic stories... The PRD mission designer agent will produce hive/SWARM_MISSIONS.md with 200 real stories from our 4 revenue-critical PRDs.


title: 200-Agent Swarm Cost Efficiency

insight: Full 200-agent swarm estimated at $1.30 on OpenRouter for 1.27M tokens - representing massive ROI compared to traditional development

reasoning_chain: Built 200-agent async orchestrator script with asyncio+aiohttp

reasoning_chain: Created 102 core stories from PRDs with token estimates (~685K tokens)

reasoning_chain: Added expansion stories totaling 200 agents

reasoning_chain: Calculated: 1.27M tokens at blended OpenRouter rates ≈ $1.30

reasoning_chain: Comparison: Traditional development would cost 100x more for equivalent throughput

source_context: Estimated total token budget: ~685,000 tokens for the 102 core stories, ~1.27M tokens for the full 200-agent swarm... Total token budget: ~1.27M tokens for 200 agents = roughly $1.30 on OpenRouter. Incredible ROI.


title: Genesis Commander tmux Launcher

insight: One-command tmux launcher (genesis-commander.sh) creates persistent 3-pane Command Centre: Claude (70%), auto-respawn watcher, live event logs

reasoning_chain: Identified need for persistent Command Centre across terminal disconnections

reasoning_chain: Designed tmux layout: Pane 0 Claude Code (70% width), Pane 1 watcher, Pane 2 live logs

reasoning_chain: Added --kill and --status modes for session management

reasoning_chain: Integrated session_recovery_start.py hook for automatic context injection on respawn

source_context: genesis-commander.sh -- One-command tmux launcher (Claude + watcher + log viewer). Pane 0: Claude Code (70% width), Pane 1: Auto-respawn watcher, Pane 2: Live event log


title: Gemini 3 Flash Kills Gemini 2.5 Pro

insight: Gemini 3 Flash outperforms Gemini 2.5 Pro on 18/20 benchmarks while being 3x faster and 69% cheaper - making 2.5 Pro obsolete for most use cases

reasoning_chain: Compared Gemini 3 Flash vs Gemini 2.5 Pro benchmarks

reasoning_chain: Gemini 3 Flash beats 2.5 Pro on 18/20 benchmarks

reasoning_chain: Only remaining use case for 2.5 Pro: 50% batch discount for massive async jobs

source_context: Gemini 3 Flash makes Gemini 2.5 Pro obsolete for most tasks. It beats 2.5 Pro on 18/20 benchmarks while being 3x faster and 69% cheaper. The only remaining case for 2.5 Pro is its 50% batch discount for massive async jobs.


title: SessionStart Recovery Hook Missing

insight: P0 blocker: Auto-respawn system could detect context limits, write handoffs, and restart Claude - but the new session wouldn't automatically load the handoff context

reasoning_chain: 7-layer auto-respawn defense was functional: StatusLine → auto_respawn.py → watcher → respawn

reasoning_chain: Gap: SessionStart hook (fires on startup/resume/compact) had no handler

reasoning_chain: Result: Claude would restart but have no memory of prior work

reasoning_chain: Required: session_recovery_start.py to read handoff files and inject context

source_context: The auto-respawn SYSTEM is 85% built, but there's a P0 gap: when Claude Code restarts after compaction or respawn, nothing reads the handoff files and injects recovery context.


title: 8-Layer Auto-Respawn Defense Pipeline

insight: Complete autonomous persistence pipeline: Context hits 70% → auto_respawn.py flushes handoff → watcher detects flag → kills/restarts Claude → session_recovery_start.py injects context → zero human intervention

reasoning_chain: StatusLine tracks context percentage continuously

reasoning_chain: auto_respawn.py PostToolUse hook: 50% warn, 65% flush handoff, 70% respawn flag

reasoning_chain: respawn_command_centre.sh watcher polls every 5 seconds for flag

reasoning_chain: On flag: kills Claude, restarts fresh instance

reasoning_chain: session_recovery_start.py fires on SessionStart, reads handoff files, injects via additionalContext

reasoning_chain: Result: Claude resumes autonomously with full mission context

source_context: Context hits 70% → auto_respawn.py writes handoff + flag → Watcher detects flag (5 sec) → Watcher kills + restarts Claude → SessionStart hook fires → session_recovery_start.py injects recovery context → Claude resumes autonomously