Claude vs. Codex vs. OpenCode: Navigating the AI Coding Assistant Landscape

[ Developer IDE ] 
         │
         ▼
┌──────────────────────────────────────────────┐
│         Semantic AI Code Gateway             │
│                                              │
│  1. Check Security & Compliance constraints   │
│  2. Analyze Ast/Complexity of prompt         │
│  3. Estimate Input/Output Token Costs        │
└──────────────────────┬───────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
  ┌───────────┐  ┌───────────┐  ┌───────────┐
  │  Claude   │  │   Codex   │  │ OpenCode  │
  │ (Complex) │  │  (Inline) │  │  (Local)  │
  └───────────┘  └───────────┘  └───────────┘

import { Anthropic } from '@anthropic-ai/sdk';
import { OpenAI } from 'openai';

// Initialize client SDKs
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const LOCAL_OLLAMA_URL = process.env.LOCAL_OLLAMA_URL || 'http://localhost:11434/api/generate';

interface CodeRequest {
  prompt: string;
  contextFiles: Array<{ filePath: string; content: string }>;
  isSensitive: boolean;
  userId: string;
}

interface RouterResponse {
  provider: 'CLAUDE' | 'CODEX' | 'OPENCODE';
  code: string;
  costSavedEst: number; // in USD
  executionTimeMs: number;
}

export class AICodingRouter {
  /**
   * Analyzes prompt and context files to assess complexity score (0.0 to 1.0)
   */
  private static analyzeComplexity(request: CodeRequest): number {
    let score = 0.1;

    // Elevate score based on context volume
    const totalContextLength = request.contextFiles.reduce((acc, f) => acc + f.content.length, 0);
    if (totalContextLength > 15000) score += 0.4; // Multi-file system context
    else if (totalContextLength > 4000) score += 0.2;

    // Elevate based on semantic keywords in prompt indicating deep architectural tasks
    const highComplexityKeywords = [
      'refactor', 'architect', 'race condition', 'memory leak',
      'optimize performance', 'database migration', 'thread-safe',
      'implement protocol', 'concurrency', 'abstract factory'
    ];
    
    const lowerPrompt = request.prompt.toLowerCase();
    const keywordMatches = highComplexityKeywords.filter(keyword => lowerPrompt.includes(keyword));
    score += keywordMatches.length * 0.15;

    return Math.min(score, 1.0);
  }

  /**
   * Routes and executes the LLM call depending on security, complexity, and cost variables
   */
  public async routeRequest(request: CodeRequest): Promise<RouterResponse> {
    const startTime = Date.now();
    const complexity = AICodingRouter.analyzeComplexity(request);

    // Rule 1: Strict compliance and privacy constraint
    if (request.isSensitive) {
      return this.executeOpenCodeLocal(request, startTime, 'Data privacy rule triggered local-only run.');
    }

    // Rule 2: High complexity tasks require Claude's multi-file reasoning
    if (complexity >= 0.6) {
      return this.executeClaude(request, startTime);
    }

    // Rule 3: Standard completions and boilerplate fall back to Codex (OpenAI)
    return this.executeCodex(request, startTime);
  }

  private async executeClaude(request: CodeRequest, startTime: number): Promise<RouterResponse> {
    try {
      // Construct dynamic system prompt with file context
      const systemPrompt = `You are an elite software architect. Context files provided:
${
        request.contextFiles.map(f => `--- FILE: ${f.filePath} ---
${f.content}`).join('
')
      }`;

      // Utilizing Claude 3.5 Sonnet with Prompt Caching configuration
      const response = await anthropic.beta.promptCaching.messages.create({
        model: 'claude-3-5-sonnet-20241022',
        max_tokens: 4096,
        system: [
          {
            type: 'text',
            text: systemPrompt,
            // Cache the large system prompt context to save up to 90% in cost
            cache_control: { type: 'ephemeral' }
          }
        ],
        messages: [{ role: 'user', content: request.prompt }],
      });

      const code = response.content[0].type === 'text' ? response.content[0].text : '';
      const duration = Date.now() - startTime;

      // Estimated savings compared to not utilizing Prompt Caching on Claude
      const costSavedEst = 0.03; // Realized from prompt cache hits

      return {
        provider: 'CLAUDE',
        code,
        costSavedEst,
        executionTimeMs: duration
      };
    } catch (error) {
      console.error('Claude API failed, falling back to local OpenCode:', error);
      return this.executeOpenCodeLocal(request, startTime, 'Claude fallback.');
    }
  }

  private async executeCodex(request: CodeRequest, startTime: number): Promise<RouterResponse> {
    try {
      const response = await openai.chat.completions.create({
        model: 'gpt-4o-mini', // Ultra-fast, low-latency code assistant
        messages: [
          {
            role: 'system',
            content: 'You are an efficient coding assistant. Provide clean, production-ready code blocks only.'
          },
          {
            role: 'user',
            content: `Context: ${JSON.stringify(request.contextFiles)}

Task: ${request.prompt}`
          }
        ],
        temperature: 0.1,
      });

      const code = response.choices[0].message.content || '';
      const duration = Date.now() - startTime;
      
      // Savings compared to running Claude 3.5 Sonnet for trivial task
      const costSavedEst = 0.015; 

      return {
        provider: 'CODEX',
        code,
        costSavedEst,
        executionTimeMs: duration
      };
    } catch (error) {
      console.error('Codex API failed, falling back to local OpenCode:', error);
      return this.executeOpenCodeLocal(request, startTime, 'Codex fallback.');
    }
  }

  private async executeOpenCodeLocal(request: CodeRequest, startTime: number, reason: string): Promise<RouterResponse> {
    // Target deepseek-coder:6.7b running locally on Ollama/vLLM
    const promptPayload = `### System:
You are a secure, local developer AI agent. Reason: ${reason}

### Context:
${
      JSON.stringify(request.contextFiles)
    }

### Instruction:
${request.prompt}

### Response:
`;

    const response = await fetch(LOCAL_OLLAMA_URL, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        model: 'deepseek-coder:6.7b',
        prompt: promptPayload,
        stream: false,
        options: { temperature: 0.2 }
      })
    });

    const data = await response.json();
    const duration = Date.now() - startTime;
    
    // Complete cost avoided as local hosting is used
    const costSavedEst = 0.05;

    return {
      provider: 'OPENCODE',
      code: data.response,
      costSavedEst,
      executionTimeMs: duration
    };
  }
}