AI Codex Orchestrator v2 — Unified Multi-Agent Session Manager for Claude, Gemini & Codex

🚀 What If Your AI Assistants Could Pass the Baton Like a Relay Team?

Imagine three world-class specialists sitting in the same room, each with their own unique expertise. Now imagine they can whisper to each other, hand off unfinished work mid-task, and never repeat themselves. That is exactly what AI Codex Orchestrator v2 delivers — a single unified runtime that runs Claude, OpenAI Codex, and Google Gemini inside the same persistent session, with true cross-model cache sharing that eliminates 90% of redundant token spend.

This is not a wrapper. This is a delegation layer that treats each AI as a specialist you can dispatch into sub-tasks, then reassemble results without cold starts or API overhead duplication.

🔧 Key Features

True Cross-Model Cache – When Claude sees a prompt, Gemini and Codex can reuse its cached context without re-sending tokens
Session-Level Orchestration – One session.json controls all three models simultaneously
Cold Start Elimination – Pre-warmed context windows persist across invocations (server stays hot for 24 hours)
Token Waste Reduction – up to 90% fewer redundant token transmissions compared to traditional multi-model chaining
Responsive Dashboard UI – Real-time streaming of three parallel responses in one browser tab
Multilingual Prompt Routing – Send tasks in 50+ languages; the orchestrator auto-selects the best model for each language
24/7 Supervisor Mode – Background agent retries, backfills, and rebalances if one model fails or rate-limits
Plugin Architecture – Swap in custom API keys without touching core code; environment variable injection via .env.orchestrator

📊 Architecture Overview (Mermaid Diagram)

flowchart TD
    A[User CLI / HTTP Request] --> B{Orchestrator Router}
    B --> C[Claude Agent v3]
    B --> D[Codex Agent]
    B --> E[Gemini Agent]
    C --> F[Shared Context Cache]
    D --> F
    E --> F
    F --> G[Session State Manager]
    G --> H[Persistent Token Ledger]
    H --> I[Response Aggregator]
    I --> J[Unified Output Stream]
    J --> K[Web Dashboard / Terminal]
    
    L[.env.orchestrator] --> B
    M[plugin registry] --> B
    N[rebalance daemon] --> G

💻 OS Compatibility Table

Operating System	Supported (2026)	Architecture	Notes
🐧 Ubuntu 22.04+	✅ Full	x86_64, ARM64	Best performance with systemd persistence
🐧 Debian 12	✅ Full	x86_64	Slightly slower cache initialization
🍎 macOS Ventura+	✅ Full	Apple Silicon, Intel	Homebrew dependencies required
🪟 Windows 11 23H2+	✅ Partial	x86_64	WSL2 recommended for daemon mode
🪟 Windows 10 22H2	⚠️ Experimental	x86_64	No GUI dashboard on bare metal
🐧 Fedora 39+	✅ Full	x86_64	RPM-based installs supported via script
📱 Termux (Android)	❌ Not supported	ARM64	Incompatible with shared memory cache

🧪 Example Profile Configuration

Create a file named orchestrator.profile.yaml in your project root. This tells the Orchestrator how to delegate tasks among the three models.

profile: "code-review-sprint"
session_id: "sprint-2026-march"
models:
  claude:
    api_key_env: "ANTHROPIC_API_KEY"
    model_version: "claude-3-opus-20240229"
    priority: 1
    tasks: ["architecture review", "security audit", "documentation analysis"]
  codex:
    api_key_env: "OPENAI_API_KEY"
    model_version: "gpt-4-codex-2026"
    priority: 2
    tasks: ["refactoring suggestions", "test generation", "performance profiling"]
  gemini:
    api_key_env: "GOOGLE_GEMINI_KEY"
    model_version: "gemini-1.5-pro-2026"
    priority: 3
    tasks: ["localization check", "accessibility scan", "edge case exploration"]

cache:
  strategy: "cross-model-shared"
  ttl_seconds: 28800  
  warmup: true

rebalance:
  enabled: true
  max_retries: 3
  fallback_model: "claude"

🎯 Example Console Invocation

Once configured, launch the orchestrator from your terminal. Below are real-world invocations demonstrating multi-model delegation in action.

# Quick start with all default models
orchestrator run --profile code-review-sprint

# Explicitly route a complex task to three models in parallel
orchestrator run --profile code-review-sprint \
  --task "Refactor the authentication module, check for OWASP Top 10, and generate unit tests in 3 languages" \
  --parallel

# View real-time streaming output with token savings report
orchestrator run --profile code-review-sprint \
  --verbose \
  --token-report

# Run in daemon mode with background rebalancing (recommended for production)
orchestrator serve --daemon --port 8080 --cache-warmup

# Invoke a single model within the orchestration session
orchestrator invoke claude --prompt "Explain the cache strategy in simple terms"

# Demo mode (simulates all three models without API keys)
orchestrator demo --profile code-review-sprint --tasks 5

The terminal output will show three color-coded streams (blue for Claude, green for Codex, amber for Gemini) converging into a single response. A footer bar displays cumulative tokens saved compared to running each model independently.

🌐 Why This Matters in 2026

The era of single-model allegiance is over. Every developer knows that Claude excels at creative reasoning, Codex dominates in code generation speeds, and Gemini handles multilingual nuance better than the other two combined. Yet until now, teams had to choose one or build fragile glue code that duplicated context across APIs.

AI Codex Orchestrator v2 is the missing link — a session-level switchboard that treats each API as a service you can call from a shared memory space. The result is not just faster feedback loops but fundamentally different workflows: you can ask Claude to analyze architecture, then hand the same session to Codex for implementation, and finally let Gemini audit the output for internationalization issues, all without re-explaining the context.

📦 Getting Started

Prerequisites

Python 3.9 or higher (3.12 recommended for performance improvements in 2026)
Node.js 18+ (for the dashboard UI)
API keys for Anthropic, OpenAI, and Google Gemini
At least 4GB RAM for hot cache (8GB recommended for production workloads)

Quick Install

# Extract the archive
tar -xzf orchestrator-v2.tar.gz

# Run the one-command setup
cd orchestrator-v2 && ./install.sh

# Configure your API keys
cp .env.example .env.orchestrator
nano .env.orchestrator

# Verify installation
orchestrator --version
# Expected output: AI Codex Orchestrator v2.1.0 (2026-03)

Docker Deployment (Recommended for Production)

docker pull orchestator/ai-orchestrator:v2.1.0
docker run -d \
  -p 8080:8080 \
  -e ANTHROPIC_API_KEY=your_key \
  -e OPENAI_API_KEY=your_key \
  -e GOOGLE_GEMINI_KEY=your_key \
  orchestrator/ai-orchestrator:v2.1.0

🔐 API Key Management

The orchestrator never stores API keys in plain text. All keys are loaded from environment variables or an encrypted vault file. Use the built-in key manager to rotate credentials without restarting the session.

orchestrator keys add --provider claude --key-env ANTHROPIC_API_KEY
orchestrator keys verify --all
orchestrator keys rotate --provider codex --key-env OPENAI_API_KEY_NEW

The system automatically detects key expiry and falls back to available models when a specific provider is temporarily unavailable.

🧠 Smart Features That Set This Apart

Responsive UI Dashboard – The web dashboard adapts to any screen size. On mobile, it collapses to a single-stream view. On desktop, you see three parallel output panes with token usage graphs built directly into the interface.

Multilingual Prompt Routing – The orchestrator analyzes the language of your prompt before routing. If you write in Japanese, Gemini handles the primary reasoning. If you switch to Python code, Codex takes over. Claude serves as the fallback for mixed-language tasks. This language-aware routing happens in under 200ms per delegation.

24/7 Supervisor Daemon – In daemon mode, a background process monitors all three API health endpoints. If one provider rate-limits your requests, the supervisor redistributes the workload across the remaining two active models without dropping the user session. Exponential backoff is built-in and configurable.

Token Bill of Materials – After each session, the orchestrator generates a detailed report showing exactly how many tokens each model consumed, how many were saved through shared cache, and the estimated cost in 2026 API pricing. This is invaluable for teams with strict cloud spending budgets.

⚠️ Disclaimer

AI Codex Orchestrator v2 is an open-source tool that abstracts and combines third-party API services. The orchestrator itself does not generate AI responses — it delegates to the respective APIs (Anthropic, OpenAI, Google) which operate under their own terms of service and pricing models.

No Guarantee of Uptime – The orchestrator relies on external API availability. In daemon mode, it will retry and rebalance, but prolonged downtime from a provider cannot be bypassed.
Rate Limits Apply – Your API keys govern rate limits. The orchestrator does not bypass quota restrictions imposed by any provider.
Data Privacy – Shared cache stores prompt context in memory. For sensitive workloads, enable the --no-persist-cache flag to prevent any context from being written to disk.
Cost Responsibility – The token savings reported are estimates. Actual billing depends on the specific API pricing in effect at the time of use. Always monitor your API dashboards independently.
2026 Compatibility – While tested against API versions available as of early 2026, breaking changes from upstream providers may require updates to the orchestrator's adapter modules. We release patches quarterly.

📜 License

This project is licensed under the MIT License. You are free to use, modify, and distribute this software for both personal and commercial purposes, provided that the original copyright notice and permission notice are included in all copies or substantial portions of the software.

See the full LICENSE for details.

🔄 Final Download Link

AI Codex Orchestrator v2 – Because your AI assistants work better when they talk to each other. Architecture inspired by Claw v3 session delegation patterns. Built for 2026 workloads. Deploy today, save 90% on token waste tomorrow.

claw-multi-ai-orchestrator

Links

README