DEV Community: Eros De Grande (ErosLifeStyle)

Claude Code kept going down. So I built a router.

Eros De Grande (ErosLifeStyle) — Tue, 23 Jun 2026 18:53:14 +0000

The Hook

Last month, mid-sprint, my Claude subscription decided to take a vacation. Three days of "Service Unavailable" while I had a feature to ship. That's when I decided: no more single points of failure in my AI stack.

Background: Why Claude Code Alone Isn't Enough

Claude Code is excellent. The context window, the reasoning, the tool use. But it's a subscription service with its own limits: rate caps, availability windows, and that annoying moment when your plan doesn't cover what you need right now.

MiniMax offers a solid alternative, but their API behaves differently. Different endpoints, different parameters, different quirks. Switching manually between them is a workflow killer.

I needed a proxy that could sit in front of both, route intelligently based on what I'm doing, and fail over automatically when something breaks.

What I Built: Four Routing Modes

The router operates in four distinct modes:

Forced Claude - Everything goes to Claude. Use when you need maximum reasoning capability.
Forced MiniMax - Everything goes to MiniMax. Cheaper tasks, bulk processing.
Automatic - The proxy decides based on task complexity. Simple queries to MiniMax, complex ones to Claude.
Interactive (Smart Mode) - The proxy categorizes tasks in real-time and routes accordingly, with manual override available.

The interactive mode is where it gets interesting. I built a lightweight classifier that distinguishes between:

T0/T1 tasks: Quick edits, single-file changes, documentation updates
T2 tasks: Multi-file refactors, architecture decisions, complex debugging

Architecture: Three Services + One Proxy

The system runs as:

ai-router-proxy.py    # The HTTP proxy (port 8080)
ai-router-switcher.sh # Service switcher script
ai-health-checker.sh  # Health monitoring daemon

Each runs as a systemd service:

~/.config/systemd/user/ai-router-proxy.service
~/.config/systemd/user/ai-router-switcher.service
~/.config/user/ai-router-health-checker.service

The proxy listens locally, forwards to whichever backend is active, and handles the translation between API formats.

Smart Mode: How It Categorizes Tasks

The routing logic examines the incoming request to determine complexity:

Request length and structure
Presence of code patterns (imports, function definitions, class declarations)
Explicit mode hints in the request
Token count estimates

Simple prompts with minimal context go to MiniMax. Anything resembling a full refactor or complex reasoning task gets routed to Claude.

Triple Defense: Service Resilience

One service failing shouldn't break your workflow. The resilience stack:

systemd restart policies - Each service auto-restarts on failure with backoff
cron health checks - Every 5 minutes, a script verifies both backends and switches if needed
pre-request hooks - The proxy checks backend health before each request

If Claude goes down, the system detects it within 5 minutes (cron interval) or immediately (hook). If MiniMax fails, same story. You keep working.

The Core Proxy Logic

Here's the essential routing function from ai-router-proxy.py:

def handle_request(req_data, mode):
    if mode == "claude":
        return forward(req_data, CLAUDE_ENDPOINT)
    elif mode == "minimax":
        return forward(req_data, MINIMAX_ENDPOINT)
    elif mode == "auto":
        complexity = classify(req_data)
        target = CLAUDE_ENDPOINT if complexity > 0.7 else MINIMAX_ENDPOINT
        return forward(req_data, target)
    elif mode == "interactive":
        task_type = detect_task_type(req_data)
        if task_type in ["edit", "doc", "refactor"]:
            return forward(req_data, MINIMAX_ENDPOINT)
        return forward(req_data, CLAUDE_ENDPOINT)

Ten lines that handle four modes, with the complexity classifier being the real intelligence.

How it stacks up vs the alternatives

Real-World Use Cases

Documentation writing - MiniMax handles the bulk. When I need to explain an architecture decision, Claude takes over.
Bug hunting - Automatic mode detects the complexity and routes to Claude for the heavy lifting.
Code review - Interactive mode identifies review patterns and routes accordingly.
Bulk refactoring - Forced MiniMax mode for repetitive changes where I just need speed.

Performance and Results

After a month of daily use:

Switchover time when a backend fails: under 10 seconds
Routing accuracy in auto mode: approximately 85% (based on manual overrides)
Cost savings from MiniMax for simple tasks: roughly 40% compared to Claude-only
Zero workflow interruptions from backend issues: 31 days and counting

What I Learned

Building a resilient AI proxy taught me three things:

Failover is easy; failback is hard - Detecting when a service comes back and switching back requires careful state management.
Classification is the hard part - The routing logic is simple; knowing when to route is the actual problem.
Local proxies are underrated - A simple HTTP proxy solved what I thought would require a complex service mesh.

Links and Call to Action

The full project is open source:

Repository: https://github.com/eroslifestyle/ai-router-switch
Documentation: https://eroslifestyle.github.io/ai-router-switch/
Banner/Assets: https://github.com/eroslifestyle/ai-router-switch/tree/main/assets
Discussion: https://github.com/eroslifestyle/ai-router-switch/discussions/2

If you've been burned by AI service downtime, or if you want to optimize costs without sacrificing capability, clone the repo and run the installer. The setup script handles the systemd units, the proxy configuration, and the health checks.

Questions, contributions, and feature requests welcome in the discussions.

Claude Orchestrator: Transform Claude Code into a Team of 39 AI Agents

Eros De Grande (ErosLifeStyle) — Sat, 21 Feb 2026 16:20:51 +0000

A powerful multi-agent system that transforms Claude Code into a coordinated team of 39 specialized AI agents"
tags: ai, productivity, opensource, claude, automation
cover_image: https://raw.githubusercontent.com/eroslifestyle/Claude-Orchestrator-Plugin/main/docs/banner.svg

series: AI Tools

🤖 Claude Orchestrator: 39 AI Agents for Claude Code

The Problem

Claude Code is powerful, but complex projects require multiple expertise domains. One AI assistant can't be an expert in everything.

The Solution

Claude Orchestrator V10.1 ULTRA transforms Claude Code into a coordinated team of 39 specialized AI agents.

🎯 Why Use Claude Orchestrator?

The Challenge with Single AI

When you work on complex projects, you face multiple challenges:

Problem	Single AI	With Orchestrator
Context switching	Manual, error-prone	Automatic routing
Expertise depth	Generalist knowledge	Domain specialists
Parallel tasks	Sequential only	True parallelism
Quality consistency	Varies	Standardized patterns
Task decomposition	Manual effort	Automatic breakdown

Real-World Scenarios

Scenario 1: Building a Trading App

Need: Database optimization + Security + GUI + API + Testing
Single AI: Tries to do everything, loses context
Orchestrator: Routes to 5 different specialists automatically

Scenario 2: Security Audit

Need: OWASP knowledge + Code review + Penetration testing
Single AI: Generic security advice
Orchestrator: Security Expert + Offensive Security Expert + Reviewer

Scenario 3: Multi-Platform Development

Need: Desktop (Qt) + Mobile (Flutter) + Backend (Python)
Single AI: Context overload, forgets requirements
Orchestrator: Parallel teams for each platform

⚙️ What Does It Do?

Core Functionality

┌─────────────────┐
│  Your Request   │
│ "/orchestrator  │
│  Build REST API"│
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   ORCHESTRATOR  │
│  Analyzes task  │
│  Decomposes     │
│  Routes agents  │
└────────┬────────┘
         │
    ┌────┴────┬─────────┬─────────┐
    ▼         ▼         ▼         ▼
┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐
│API    │ │Security│ │Database│ │Tester │
│Builder│ │Auth   │ │Expert  │ │Expert │
└───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘
    │         │         │         │
    └─────────┴─────────┴─────────┘
                    │
                    ▼
         ┌─────────────────┐
         │  Final Report   │
         │  + Tests        │
         │  + Documentation│
         └─────────────────┘

Key Features

Feature	Description
39 Specialized Agents	GUI, Security, Trading, DevOps, Mobile, Database...
Intelligent Routing	Automatic task-to-agent matching based on context
Cross-Platform	Windows, macOS, Linux installers
Auto-Update	GitHub releases integration with rollback
Agent Teams	Parallel execution for complex tasks
Memory Integration	Context persistence across sessions
Health Checks	Automatic diagnostics and recovery
Observability	Real-time metrics dashboard

✅ Pros and ❌ Cons

✅ Pros

Advantage	Explanation
🎯 Specialization	Each agent is an expert in its domain, not a generalist
⚡ Parallelism	Independent tasks run simultaneously, not sequentially
🔄 Auto-Routing	No manual agent selection - intelligent keyword matching
💾 Memory	Context persists across sessions
🛡️ Safety	Automatic backups, rollback capability
📊 Observability	Real-time metrics, health checks, logging
🔧 Extensible	Easy to add new agents or modify routing
🌐 Cross-Platform	Works on Windows, macOS, Linux
🆓 Open Source	MIT license, free forever
🤝 Team Mode	Spawn coordinated agent teams for complex tasks

❌ Cons

Disadvantage	Mitigation
Learning Curve	Requires understanding the agent system
Token Usage	Multiple agents = more tokens consumed
Setup Required	One-time installation needed
Complexity	More moving parts than single AI
Overkill for Simple Tasks	Use `/orchestrator` only for complex tasks
Claude Code Dependency	Requires Claude Code installed

When NOT to Use It

Simple one-liner questions
Quick documentation lookups
Single-file edits
Casual conversations

When to Use It

Multi-file feature implementations
Security audits
Cross-platform development
API design + implementation
Code refactoring
Testing strategies
Complex debugging

🚀 Quick Start

Windows (PowerShell)

git clone https://github.com/eroslifestyle/Claude-Orchestrator-Plugin
cd Claude-Orchestrator-Plugin
./setup.ps1

Mac/Linux (Bash)

git clone https://github.com/eroslifestyle/Claude-Orchestrator-Plugin
cd Claude-Orchestrator-Plugin
chmod +x setup.sh
./setup.sh

📋 Available Agents (39 Total)

Core Agents (L0) - Always Available

Agent	Specialization
Analyzer	Codebase exploration, file search
Coder	Implementation, bug fixes
Reviewer	Code review, quality checks
Documenter	Documentation, changelogs
System Coordinator	Resource management, cleanup
Orchestrator	Task coordination

Expert Agents (L1) - Domain Specialists

Agent	Specialization
GUI Super Expert	PyQt5, Qt, NiceGUI, CSS
Security Unified Expert	Encryption, auth, OWASP
Database Expert	SQL, schema, migrations
DevOps Expert	CI/CD, Docker, deploy
AI Integration Expert	LLM, embeddings, RAG
Mobile Expert	iOS, Android, Flutter
Trading Strategy Expert	Risk management, position sizing
MQL Expert	MetaTrader, Expert Advisors
Architect Expert	System design, patterns
Integration Expert	API, REST, webhooks
Tester Expert	Testing, QA, debugging
N8N Expert	Workflow automation
Reverse Engineering Expert	Binary analysis, Ghidra
Offensive Security Expert	Pentesting, exploits
+ 7 more...

Specialist Agents (L2) - Deep Expertise

Agent	Specialization
Security Auth Specialist	JWT, sessions, OAuth
API Endpoint Builder	REST endpoints, CRUD
DB Query Optimizer	Query performance, indexing
Claude Prompt Optimizer	Token efficiency
GUI Layout Specialist	Qt layouts, responsive
Test Unit Specialist	Unit tests, mocks, pytest
+ 9 more...

💡 Usage Examples

Example 1: Feature Implementation

/orchestrator Create a REST API with JWT authentication and refresh tokens

What happens:

Task decomposed into: API design + Auth + Database + Tests
API Endpoint Builder creates REST structure
Security Auth Specialist implements JWT
Database Expert designs user schema
Test Unit Specialist writes tests
Final report with complete implementation

Example 2: Security Audit

/orchestrator Review the auth module for OWASP Top 10 vulnerabilities

What happens:

Security Unified Expert reviews encryption
Offensive Security Expert checks for exploits
Reviewer evaluates code quality
Comprehensive security report

Example 3: Multi-Platform Development

/orchestrator Build a trading dashboard with PyQt5 for desktop and Flutter for mobile

What happens:

Agent team spawned for parallel work
GUI Super Expert handles desktop
Mobile Expert handles Flutter
Trading Strategy Expert advises on features
Coordinated delivery

🔄 Auto-Update System

# Check for updates (rate limited: 1/hour)
./updater/check-update.ps1

# Install update with automatic backup
./updater/do-update.ps1

# Rollback if needed
./updater/do-update.ps1 -Version 10.0.0

📦 Project Structure

Claude-Orchestrator-Plugin/
├── core/
│   ├── skills/orchestrator/    # Main orchestrator skill
│   │   ├── SKILL.md            # 2000+ lines of logic
│   │   ├── routing-table.md    # Agent routing rules
│   │   └── ...
│   └── agents/                 # 39 agent definitions
│       ├── core/               # L0 agents
│       ├── experts/            # L1 + L2 agents
│       └── system/             # Coordination files
├── templates/                  # Config templates
├── updater/                    # Auto-update scripts
├── setup.ps1                   # Windows installer
└── setup.sh                    # Unix installer

🔗 Links

GitHub: eroslifestyle/Claude-Orchestrator-Plugin
License: MIT (Free, Open Source)
Version: 10.1.0 ULTRA
Size: ~3 MB

🤝 Contributing

Contributions welcome! Areas we need help:

New agent definitions
Documentation improvements
Bug fixes
Feature requests

Star ⭐ the repo if you find it useful!

Questions? Open an issue or start a discussion!