OmniRoute auto/* Model Variants: Zero-Configuration Routing Guide

OmniRoute's Auto Combo system provides zero-configuration routing through auto/ prefixed model IDs that dynamically create virtual combos using variant-specific scoring weights for quality, speed, cost, or reasoning.

OmniRoute (diegosouzapw/OmniRoute) implements a zero-configuration routing layer called Auto Combo that eliminates manual provider list management. By requesting models with the auto/ prefix—such as auto/coding or auto/fast—clients trigger on-demand materialization of virtual combos that apply specialized scoring strategies based on the selected variant.

How the auto/ Namespace Works

The Auto Combo architecture processes auto/ requests through a validation and factory pipeline defined in open-sse/services/autoCombo/.

• Auto Prefix Parser: The parseAutoPrefix() function in autoPrefix.ts validates incoming auto/… strings and extracts the variant identifier (e.g., coding, fast). It returns the specific variant or a default fallback.

• Builtin Catalog: builtinCatalog.ts maintains AUTO_TEMPLATE_VARIANTS as the canonical mapping of auto/* IDs to router configurations. It also defines AUTO_SUFFIX_VARIANTS and FLAT_TIER_OVERLAY_IDS to support tiered forms like auto/coding:cheap without catalog bloat.

• Virtual Combo Factory: createVirtualAutoCombo() in virtualFactory.ts materializes combos from active provider connections, applying the variant’s specific scoring weights from the MODE_PACKS configuration.

• Category-Tier Resolution: The resolveBuiltinAutoSpec() function handles both flat variants and category/tier overlays (e.g., auto/coding:pro), expanding the effective catalog dynamically.

When a request arrives at the handler (typically open-sse/handlers/chatCore.ts), the system checks isRecognizedBuiltinAuto(); upon validation, the virtual combo dispatches through the standard completion pipeline exactly like a manually configured combo.

Complete List of auto/ Model Variants

OmniRoute v3.8.51 ships with builtin variants optimized for specific operational constraints. Each maps to a unique mode pack in the 15-factor scoring matrix.

• auto/coding: Quality-first weights for general code generation. Use when accuracy matters more than speed or cost.

• auto/fast: Low-latency pool favoring responsive providers. Ideal for interactive IDE completions and REPL-style interfaces where sub-second response is critical.

• auto/cheap: Cost-optimized selection targeting low-price or free-tier models. Best for large-scale batch jobs and budget-constrained workloads.

• auto/offline: Prefers locally-hosted models that function without internet connectivity. Essential for edge deployments and air-gapped environments.

• auto/smart: Reasoning-focused weights for chain-of-thought tasks. Use for complex algorithm design, planning, or multi-step logical reasoning.

• auto/chaos: Parallel dispatch to the top-N stable models followed by judge-model synthesis (e.g., using gpt-5.5) to merge results. Suitable for high-risk code reviews requiring multiple perspectives.

• auto/lkgp (Least-Known-Good-Provider): Diversity-preserving strategy that spreads load across less-utilized providers to prevent dominant backend overload.

• auto/claude-opus and auto/claude-sonnet: Explicitly target the Claude model family while retaining variant-level scoring behavior for smart or coding tasks.

• auto/best-free and auto/thrifty: Aliases for the zero-cost tier, routing to the cheapest available free model for cost-free experimentation.

• auto/subscription: Restricts routing to plan-included connections only, avoiding free-tier fallbacks when consuming prepaid credits.

The system supports category-tier syntax combining categories with tiers: auto/coding:fast or auto/coding:cheap. The AUTO_SUFFIX_VARIANTS array in builtinCatalog.ts defines supported suffix overlays.

How Variants Influence Scoring

Each variant activates a mode pack that adjusts OmniRoute's 15-factor Auto-Combo scoring matrix defined in open-sse/services/autoCombo/scoring.ts.

• fast: Boosts latency weight while reducing cost priority. Selects low-latency providers including local models.

• cheap: Heavily discounts cost weight, modestly reducing quality weight. Prioritizes the cheapest viable provider regardless of slight quality trade-offs.

• smart: Increases reasoning and task-fit weights. Targets models with high performance on reasoning benchmarks and chain-of-thought capability.

• offline: Zeroes network-related weights, exclusively selecting locally-hosted endpoints to guarantee operation without external connectivity.

• chaos: Executes parallel fan-out to multiple candidates, then invokes a judge model for result synthesis, effectively creating a model ensemble.

Usage Examples

Request auto/ models through the Chat Completion endpoint at /v1/chat/completions:

// High-quality code generation
await fetch("http://localhost:20128/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "auto/coding",
    messages: [{ role: "user", content: "Write a Node.js file that reads a CSV." }],
  }),
});

// Low-latency REPL interaction
await fetch("/v1/chat/completions", {
  method: "POST",
  body: JSON.stringify({
    model: "auto/fast",
    messages: [{ role: "user", content: "Explain the difference between let and var." }],
  }),
});

// Tiered form for cheap coding models
await fetch("/v1/chat/completions", {
  method: "POST",
  body: JSON.stringify({
    model: "auto/coding:cheap",
    messages: [{ role: "user", content: "Generate a Python script that scrapes headlines." }],
  }),
});

// Multi-model consensus for security review
await fetch("/v1/chat/completions", {
  method: "POST",
  body: JSON.stringify({
    model: "auto/chaos",
    messages: [{ role: "user", content: "Review this pull request for security issues." }],
  }),
});

Implementation Architecture

According to the OmniRoute source code, the request lifecycle follows four stages across the open-sse/services/autoCombo/ directory:

1. Recognition: isRecognizedBuiltinAuto() in builtinCatalog.ts validates the auto/ prefix against the canonical catalog.

2. Resolution: resolveBuiltinAutoSpec() maps the string to either a flat variant or a category/tier overlay, consulting AUTO_TEMPLATE_VARIANTS and suffix definitions.

3. Creation: createVirtualAutoCombo() in virtualFactory.ts builds the combo instance using active provider connections and the variant’s mode pack.

4. Execution: The handler in chatCore.ts dispatches the virtual combo through the standard completion pipeline, applying the 15-factor scoring matrix adjustments defined in scoring.ts.

Summary

• OmniRoute's auto/* variants provide zero-configuration routing through on-demand virtual combo generation.
• Quality-focused variants like auto/coding prioritize correctness, while latency-focused variants like auto/fast optimize for responsive interaction.
• Cost-focused variants (auto/cheap, auto/best-free) minimize API spend, and reasoning-focused variants (auto/smart) target complex logical tasks.
• The category-tier syntax (auto/category:tier) enables granular control without requiring explicit catalog entries.
• The auto/chaos variant implements multi-model consensus through parallel dispatch and judge-model synthesis for high-confidence results.

Frequently Asked Questions

What is the difference between auto/coding and auto/fast?

auto/coding applies quality-first weights in the scoring matrix to prioritize output correctness and code accuracy, making it ideal for production software generation. auto/fast boosts latency weights to select the most responsive available providers, trading marginal quality for sub-second response times suitable for interactive development environments and live coding sessions.

Can I combine multiple constraints like speed and cost?

Yes. The category-tier syntax allows compound specifications such as auto/coding:cheap or auto/coding:fast. The resolveBuiltinAutoSpec() function in builtinCatalog.ts parses these colon-separated identifiers, applying both the base category's candidate pool and the tier-specific mode pack adjustments from scoring.ts.

How does auto/chaos work under the hood?

The auto/chaos variant triggers a parallel fan-out to the top-N stable models as determined by the candidate pool, then invokes a judge model (configured in the MODE_PACKS logic within scoring.ts) to synthesize or merge the multiple outputs into a single coherent response, effectively creating a model ensemble for high-confidence or safety-critical analysis.

Are custom auto/ variants supported?

The current OmniRoute v3.8.51 implementation relies on the builtin catalog defined in AUTO_TEMPLATE_VARIANTS within builtinCatalog.ts. While the virtual factory architecture in virtualFactory.ts supports extension patterns, adding new variants requires modifying the catalog and potentially scoring.ts to define corresponding mode packs and scoring weight adjustments.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}