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

> Discover OmniRoute's auto/* model variants for zero-configuration routing. Learn how dynamic combos optimize for quality, speed, and cost with variant-specific scoring.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: how-to-guide
- Published: 2026-08-28

---

**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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`:

```typescript
// 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." }],
  }),
});

```

```typescript
// 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." }],
  }),
});

```

```typescript
// 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." }],
  }),
});

```

```typescript
// 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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/virtualFactory.ts) builds the combo instance using active provider connections and the variant’s mode pack.

4. **Execution**: The handler in [`chatCore.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/chatCore.ts) dispatches the virtual combo through the standard completion pipeline, applying the 15-factor scoring matrix adjustments defined in [`scoring.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/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`](https://github.com/diegosouzapw/OmniRoute/blob/main/builtinCatalog.ts). While the virtual factory architecture in [`virtualFactory.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/virtualFactory.ts) supports extension patterns, adding new variants requires modifying the catalog and potentially [`scoring.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/scoring.ts) to define corresponding mode packs and scoring weight adjustments.