import { createHash } from 'crypto';

export interface RoutePayload {
  query: string;
  metadata: Record<string, unknown>;
  maxTokens: number;
}

export interface RouteDecision {
  targetTier: 'SLM' | 'HYBRID' | 'FRONTIER';
  confidence: number;
  estimatedLatencyMs: number;
  routingReason: string;
}

export class InferenceRouter {
  private readonly complexityThreshold = 0.72;
  private readonly latencyBudgetMs = 80;

  async evaluate(payload: RoutePayload): Promise<RouteDecision> {
    const complexityScore = await this.computeComplexity(payload.query);
    const isStructured = this.detectSchemaConstraints(payload.metadata);
    
    if (complexityScore < this.complexityThreshold && isStructured) {
      return {
        targetTier: 'SLM',
        confidence: 0.89,
        estimatedLatencyMs: 35,
        routingReason: 'Low complexity, structured output expected'
      };
    }

    if (complexityScore < 0.85) {
      return {
        targetTier: 'HYBRID',
        confidence: 0.76,
        estimatedLatencyMs: 65,
        routingReason: 'Moderate complexity, speculative decoding viable'
      };
    }

    return {
      targetTier: 'FRONTIER',
      confidence: 0.94,
      estimatedLatencyMs: 220,
      routingReason: 'High complexity or ambiguous intent requires frontier reasoning'
    };
  }

  private async computeComplexity(query: string): Promise<number> {
    // Production: Replace with embedding similarity or lightweight classifier
    const tokenCount = query.split(/\s+/).length;
    const hasAmbiguity = /[maybe|possibly|unclear|explain|why]/i.test(query) ? 0.15 : 0;
    return Math.min(1.0, (tokenCount / 50) + hasAmbiguity);
  }

  private detectSchemaConstraints(metadata: Record<string, unknown>): boolean {
    return Boolean(metadata.outputSchema || metadata.format === 'json' || metadata.task === 'e

xtraction'); } }

### Step 3: Configure the Quantized SLM Execution Layer
Deploy compact models using 4-bit quantization. Calibration on a representative dataset prevents accuracy collapse.

```typescript
export interface ModelConfig {
  modelId: string;
  quantization: 'none' | 'int8' | 'fp4' | 'nf4';
  maxContextLength: number;
  temperature: number;
  topP: number;
}

export class QuantizedSLMEngine {
  private readonly config: ModelConfig;

  constructor(config: ModelConfig) {
    this.config = config;
  }

  async generate(prompt: string): Promise<string> {
    // Production: Integrate with vLLM, Ollama, or TensorRT-LLM runtime
    const payload = {
      model: this.config.modelId,
      prompt,
      max_tokens: 256,
      temperature: this.config.temperature,
      top_p: this.config.topP,
      quantization: this.config.quantization
    };

    const response = await this.executeInference(payload);
    return this.parseOutput(response);
  }

  private async executeInference(payload: unknown): Promise<unknown> {
    // Simulated runtime call
    return { generated_text: 'Structured output placeholder' };
  }

  private parseOutput(raw: unknown): string {
    return typeof raw === 'object' && raw !== null && 'generated_text' in raw
      ? String(raw.generated_text)
      : '';
  }
}

Step 4: Implement Speculative Decoding Fallback

Speculative decoding accelerates generation by having a draft model propose tokens, which a verifier model validates. This pairs naturally with SLMs.

export class SpeculativeVerifier {
  private readonly draftEngine: QuantizedSLMEngine;
  private readonly verifierEngine: QuantizedSLMEngine;
  private readonly acceptanceThreshold = 0.88;

  constructor(draft: QuantizedSLMEngine, verifier: QuantizedSLMEngine) {
    this.draftEngine = draft;
    this.verifierEngine = verifier;
  }

  async generateWithVerification(prompt: string): Promise<string> {
    const draftTokens = await this.draftEngine.generate(prompt);
    const verificationScore = await this.scoreTokenAlignment(draftTokens, prompt);

    if (verificationScore >= this.acceptanceThreshold) {
      return draftTokens;
    }

    // Fallback to verifier-only generation
    return this.verifierEngine.generate(prompt);
  }

  private async scoreTokenAlignment(draft: string, prompt: string): Promise<number> {
    // Production: Compare log-probability distributions between draft and verifier
    return 0.91; // Placeholder for distribution similarity metric
  }
}

Architecture Decisions & Rationale

• Router-first dispatch: Prevents unnecessary frontier model calls. Semantic complexity scoring ensures routing decisions align with actual reasoning requirements rather than superficial keyword triggers.
• 4-bit quantization (NF4/FP4): Reduces VRAM footprint by ~60% while preserving perplexity within 1-2% of full precision. GPTQ calibration on domain-specific data prevents accuracy degradation on specialized terminology.
• Speculative decoding: Decouples latency from model size. The draft model runs on cheaper hardware; the verifier validates only when confidence drops. This yields 2–3x throughput without sacrificing output fidelity.
• Strict schema enforcement: SLMs excel when output format is constrained. JSON schema validation, regex post-processing, and retry loops with temperature decay prevent hallucination drift in structured tasks.

Pitfall Guide

1. Blind Quantization Without Calibration

Explanation: Applying 4-bit quantization directly to a base model without domain calibration causes accuracy collapse on specialized terminology or formatting tasks. Fix: Run a calibration pass using 500–1,000 representative samples from your production workload. Measure perplexity and task-specific accuracy before deployment.

2. Keyword-Based Routing Logic

Explanation: Routing based on simple string matching fails when user intent shifts or phrasing varies. This causes misrouted queries, increased fallback latency, and inconsistent output quality. Fix: Implement embedding-based similarity scoring or deploy a lightweight classifier (e.g., 1B-parameter model) trained on historical query logs to estimate semantic complexity.

3. Ignoring Context Window Constraints on Edge Hardware

Explanation: Mobile NPUs and edge GPUs are memory-bandwidth limited. Attempting to process long contexts on compact models causes decode stalls and timeout failures. Fix: Implement sliding window chunking or hierarchical summarization. Keep active context under 4K tokens for edge deployments; offload long-context analysis to cloud tiers.

4. Static Routing Thresholds

Explanation: Hardcoded confidence cutoffs do not adapt to traffic patterns, model drift, or changing latency budgets. This leads to either over-provisioning frontier models or under-serving complex queries. Fix: Implement dynamic thresholding that adjusts routing confidence based on real-time P95 latency, cost-per-query metrics, and error rates. Use exponential moving averages to smooth traffic spikes.

5. Treating SLMs as Drop-In Replacements Without Output Enforcement

Explanation: Compact models lack the implicit formatting discipline of frontier models. Without strict schema validation, they produce inconsistent JSON, broken markdown, or truncated responses. Fix: Enforce output schemas at the API boundary. Use structured generation libraries, implement retry logic with temperature decay, and validate responses against JSON Schema or Zod before downstream processing.

6. Over-Reliance on Synthetic Data Without Organic Filtering

Explanation: Training exclusively on synthetic data introduces distributional bias and reduces generalization within the target domain. Models become brittle when encountering edge-case phrasing. Fix: Blend synthetic augmentation with rigorously filtered organic data. Apply quality scoring, deduplication, and toxicity filtering. Validate fine-tuned models against a held-out organic test set.

7. Neglecting Token-Level Routing Research

Explanation: Query-level routing optimizes at the request boundary but misses opportunities to optimize within a single generation. Frontier models are often invoked for entire responses when only a few tokens require complex reasoning. Fix: Evaluate token-level routing architectures where an SLM generates tokens, and each token is scored against the frontier model's probability distribution. Accept tokens above a confidence threshold; escalate only low-probability tokens to the larger model.

Production Bundle

Action Checklist

• Audit current inference workloads and classify queries into Tier 1 (SLM), Tier 2 (Hybrid), and Tier 3 (Frontier)
• Deploy a semantic router using embedding similarity or a lightweight classifier; replace keyword-based logic
• Quantize target SLMs to 4-bit (NF4/FP4) and run domain calibration on representative production data
• Implement speculative decoding for Tier 2 workloads; configure draft/verifier model pairing
• Enforce strict output schemas with validation middleware; add retry logic with temperature decay
• Configure dynamic routing thresholds that adjust based on real-time latency and cost metrics
• Instrument observability: track routing distribution, P95 latency, token acceptance rates, and cost-per-query
• Establish fallback policies: automatic escalation to frontier models when SLM confidence drops below threshold

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
High-volume classification/extraction	Quantized SLM (Tier 1)	Structured output, low complexity, high throughput	10–15x reduction vs frontier
Real-time UI assistant (<100ms)	Speculative decoding + SLM	Eliminates cloud round-trip, draft/verify accelerates generation	60–70% lower VRAM cost
Regulated data processing (healthcare/finance)	On-prem SLM with strict schema	Data never leaves infrastructure; compliance guarantee	Zero egress fees; hardware amortization
Complex multi-step agent / novel reasoning	Frontier LLM (Tier 3)	Requires broad generalization, long context, open-ended synthesis	Higher per-query cost; justified by capability
Hybrid traffic with unpredictable distribution	Dynamic router + tiered dispatch	Captures 90% of capability at 15% of cost; adapts to query complexity	20–60% reduction in cloud token spend

Configuration Template

# inference-router-config.yaml
routing:
  complexity_threshold: 0.72
  latency_budget_ms: 80
  fallback_on_confidence_below: 0.65
  dynamic_adjustment:
    enabled: true
    window_seconds: 300
    metric: p95_latency

tiers:
  slm:
    model_id: "phi-4-mini-reasoning"
    quantization: "nf4"
    max_context: 4096
    temperature: 0.2
    top_p: 0.9
    speculative_draft: true
    output_schema_strict: true

  hybrid:
    model_id: "gemma-3-4b"
    quantization: "fp4"
    max_context: 8192
    temperature: 0.4
    top_p: 0.95
    verifier_model: "ministral-3b"
    acceptance_threshold: 0.88

  frontier:
    model_id: "gpt-4o"
    provider: "cloud"
    max_context: 128000
    temperature: 0.3
    top_p: 0.9
    fallback_enabled: true

observability:
  metrics:
    - routing_distribution
    - p95_latency
    - token_acceptance_rate
    - cost_per_query
    - schema_validation_failures
  alerting:
    latency_p95_threshold_ms: 120
    schema_fail_rate_threshold: 0.05

Quick Start Guide

1. Define your routing taxonomy: Map your top 10 query patterns to Tier 1, 2, or 3. Identify which tasks require structured output, low latency, or complex reasoning.
2. Deploy the router middleware: Integrate the InferenceRouter class into your API gateway or service mesh. Replace static model calls with dynamic dispatch based on evaluate() output.
3. Quantize and calibrate your SLM: Select a target architecture (e.g., Phi-4-mini, Gemma 3, Llama 3.2 3B). Apply 4-bit quantization and run calibration on 500 production samples. Validate accuracy against your baseline.
4. Enable speculative decoding for Tier 2: Pair a draft SLM with a verifier. Configure the acceptance threshold and test throughput gains under load. Monitor token alignment scores.
5. Instrument and iterate: Deploy observability dashboards tracking routing distribution, latency, and cost. Adjust dynamic thresholds weekly based on traffic patterns. Escalate misrouted queries and retrain the router classifier quarterly.

The shift from monolithic model deployment to tiered inference is not an optimization; it is an architectural requirement for sustainable AI systems. By routing intelligently, quantizing aggressively, and enforcing strict output contracts, engineering teams can deliver frontier-grade reliability at edge-grade economics.