title: Unified MCP Gateway as Product AND Infrastructure

insight: Build one Genesis MCP server that any agent platform connects to and instantly gets full Genesis memory + tools - this IS the product AND the internal infrastructure simultaneously

reasoning_chain: 7 MCP servers already built (genesis-core, voice-bridge, supermemory, GHL, sequential-thinking, storm, patent-os)

reasoning_chain: Voice bridge MCP = best prototype connecting all 5 backends

reasoning_chain: Missing: unified gateway MCP + agent auto-discovery + cross-agent memory (Bloodstream)

reasoning_chain: Solution: One MCP server that exposes ALL capabilities - productizes the infrastructure itself

source_context: What exists: 7 MCP servers... What's missing: Unified gateway MCP... The play: Build one Genesis MCP server that any agent platform connects to


title: Gemini Agent Crash Root Cause

insight: Gemini agents crash because Rate Maximizer is configured for 2,000 RPM but actual Tier 1 limits are only 150-300 RPM - a 6-13x overconfiguration causing instant rate limit hits

reasoning_chain: Rate Maximizer config shows RPM = 2,000, TPM = 4,000,000

reasoning_chain: Actual Tier 1 API limits: 150-300 RPM, 1M TPM

reasoning_chain: When 10 concurrent Gemini agents launch, they instantly exceed real limits

reasoning_chain: This explains why Gemini agents keep crashing with 429 errors

reasoning_chain: Fix: Create real Tier 1 config file with accurate limits

source_context: Rate Maximizer only tracks 2 models... Configured RPM = 2,000 but actual Tier 1 = 150-300... 6-13x overconfigured - causes 429 errors


title: Jules Pro = 15 Free Parallel Coding Agents

insight: Jules Pro (included in $16.49/mo Google AI Pro) provides 100 tasks/day and 15 concurrent Gemini 3 Pro workers - massive capacity sitting completely idle that should be leveraged immediately

reasoning_chain: Google AI Pro subscription includes Jules Pro: 100 tasks/day, 15 concurrent

reasoning_chain: Jules runs in Google Cloud VMs, autonomous execution with auto-PR creation

reasoning_chain: Current usage: ZERO - all capacity sitting unused

reasoning_chain: Hybrid play: Claude Code decomposes tasks, dispatches to Jules for parallel execution

reasoning_chain: Cost: $0 extra - already paying for the subscription

source_context: Jules Pro = 15 FREE Gemini 3 Pro Agents... 100 tasks/day, 15 concurrent - currently at ZERO usage... Hybrid Play: I decompose complex tasks into 5-10 atomic stories, each becomes a Jules task


title: Claude Code + Jules Hybrid Orchestration

insight: Divide labor: Claude Code handles strategic orchestration, complex reasoning, memory integration while Jules handles batch work, unit tests, bug fixes, refactoring - 15 parallel workers at no extra cost

reasoning_chain: Claude Code: synchronous, local terminal, deep reasoning, memory integration, custom MCP access

reasoning_chain: Jules: asynchronous, cloud VM, batch work, autonomous PR creation

reasoning_chain: Jules limitation: cannot connect to custom self-hosted MCP servers (only 6 vetted)

reasoning_chain: Solution: Claude dispatches atomic tasks to Jules via CLI, reviews PRs, merges

reasoning_chain: Result: 15 parallel Gemini 3 Pro workers complementing Claude's strategic role

source_context: Jules handles (dispatch and forget): writing unit tests, bug fixes, refactoring, documentation... Claude Code handles: architecture decisions, complex orchestration, memory integration, real-time conversation


title: Rate Maximizer Critical Misconfiguration

insight: Six serious configuration problems: only tracks 2 of 5+ models used, configured limits 6-13x higher than actual, missing config file, budget tracking uses naive word-count estimation, Gemini 3 preview models have zero rate tracking

reasoning_chain: Problem 1: Rate Maximizer tracks only 2 models but Executor uses 5+

reasoning_chain: Problem 2: Configured RPM 2,000 vs actual Tier 1 = 150-300

reasoning_chain: Problem 3: Two API keys (Genesis + AgileAdapt) with unclear tier status

reasoning_chain: Problem 4: gemini_rate_limits.json doesn't exist - can't tune without editing source

reasoning_chain: Problem 5: Budget tracking counts words × 1.3, ignores actual API token_metadata

reasoning_chain: Problem 6: Gemini 3 preview models completely untracked

source_context: 6 Problems Found... Rate Maximizer only tracks 2 models but Executor uses 5+... Configured RPM = 2,000 but actual Tier 1 = 150-300


title: From API Calls to Memory-Powered Agents

insight: Transform dumb API calls into memory-powered agents via unified MCP - agents connect to Bloodstream (shared memory) instead of being stuffed with context, enabling intelligent cross-agent learning

reasoning_chain: Currently: Agents make API calls without memory

reasoning_chain: Bloodstream concept: agents draw from shared memory

reasoning_chain: Unified MCP gateway enables agent auto-discovery

reasoning_chain: Result: Agents become smarter over time by learning from each other via shared memory

source_context: Cross-agent memory - Bloodstream concept (agents draw from shared memory, not stuffed context)... Agent auto-discovery - agents connect and get tier-gated tools


title: Underutilized Resources Hidden in Plain Sight

insight: Discovery that $16.49/mo subscription includes 100 Jules tasks/day, 1000 images/day, 3 videos/day, 20 Deep Research reports/day - all completely unused while paying for 'Ferrari driving in first gear'

reasoning_chain: Google AI Pro ($19.99/mo, half-price promo) includes many features

reasoning_chain: Jules Pro: 100 tasks/day, 15 concurrent - ZERO usage

reasoning_chain: Image generation (Nano Banana): 1,000/day - NOT AT ALL

reasoning_chain: Video generation (Veo 3.1): 3/day - NOT AT ALL

reasoning_chain: Realization: massive capacity being paid for but completely unused

source_context: Massive Underutilization: 1,000 images/day, 3 videos/day, 20 Deep Research reports/day, 100 Jules tasks/day - all completely unused... We're paying for a Ferrari and driving it in first gear


title: Jules Activation Priority

insight: Immediate action required: Kinan must generate Jules API key at jules.google.com to enable 15 parallel coding agents - this directly unblocks massive throughput capacity

reasoning_chain: Jules requires personal Google account (not Workspace) - verified: sunvision07@gmail.com

reasoning_chain: API key generation needed: Settings → API keys (max 3)

reasoning_chain: Then CLI installation: npm install -g @google/jules

reasoning_chain: Then set up GitHub Action for auto bug assignment

reasoning_chain: Then start dispatching tasks - 60-100 tasks/day possible throughput

source_context: Activation Checklist (Kinan needs to do steps 1-2): 1. Sign into jules.google.com with sunvision07@gmail.com 2. Generate API key... Bottom line: We have 15 free parallel coding agents sitting idle


title: API Tier vs Subscription Confusion

insight: Critical distinction: Google AI Pro/Ultra subscription does NOT give higher API limits - API tiers are based on cumulative spend ($250 for Tier 2, $1,000+ for Tier 3)

reasoning_chain: Google AI Plans (Pro $19.99, Ultra $249.99) control app access

reasoning_chain: Gemini Developer API Tiers are separate - based on billing + cumulative spend

reasoning_chain: Pro subscription does NOT automatically give Tier 2 API limits

reasoning_chain: AI Pro $10 cloud credits CAN count toward Tier 2 qualification

reasoning_chain: This explains why rate limits are lower than expected despite paying for Pro

source_context: Your AI Pro subscription does NOT give higher API limits. API tiers are based on cumulative API spend: Tier 1 (billing enabled): 150-300 RPM, Tier 2 ($250+ spend): 500-2,000 RPM


title: MCP Gateway Architecture for Agent Platforms

insight: Design unified MCP to work with Claude Code, Gemini CLI, Jules, Cursor, OpenRouter agents - any agent platform can connect and get tier-gated Genesis tools + memory access

reasoning_chain: 7 MCP servers already exist across different domains

reasoning_chain: Unified gateway exposes ALL capabilities through single MCP server

reasoning_chain: Agent auto-discovery: agents connect and receive appropriate tool access

reasoning_chain: Tier gating: L1 agents get 2 tools, L4 agents get all 10

reasoning_chain: Cross-agent memory via Bloodstream: agents share learned knowledge

source_context: The play: Build one Genesis MCP server that any agent platform (Claude Code, Gemini CLI, Jules, Cursor, OpenRouter agents) connects to and instantly gets full Genesis memory + tools