# How OmniRoute's Auto Model Variants (coding, fast, cheap, smart) Differ in Routing Behavior

> Explore OmniRoute auto model variants coding fast cheap and smart. Understand how each variant's scoring weights differ to optimize your routing behavior for quality speed or cost.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: deep-dive
- Published: 2026-08-10

---

**OmniRoute's `auto/*` model variants apply distinct scoring weight packs—`coding` for quality-first code tasks, `fast` for lowest latency, `cheap` for minimum token cost, and `smart` for quality with 10% exploration—to dynamically select the optimal provider-model combo at request time.**

OmniRoute's **Auto-Combo** feature lets you request models using the `auto/<variant>` prefix, where the suffix determines how the routing engine scores and selects a provider-model pair. Understanding these **OmniRoute auto model variants** helps you optimize for latency, cost, or output quality without hardcoding specific providers.

## How the Auto-Combo System Works

When you send a request with `auto/coding`, `auto/fast`, `auto/cheap`, or `auto/smart`, OmniRoute's **auto-routing handler** ([`src/sse/handlers/autoRouting.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/sse/handlers/autoRouting.ts)) performs three steps:

1. **Parses** the `model` string to extract the variant name
2. **Looks up** the variant in `AUTO_TEMPLATE_VARIANTS` (defined in [`open-sse/services/autoCombo/builtinCatalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/builtinCatalog.ts))
3. **Creates** a **virtual combo** via `createVirtualAutoCombo` and runs the 9-factor scoring engine

The selected provider-model pair is returned transparently to your application.

## Variant-by-Variant Comparison

### auto/coding: Quality-First for Code Generation

The **`auto/coding`** variant prioritizes **task-fit and stability** for programming workloads. It applies the `coding` weight pack, which emphasizes:

- High code completion accuracy
- Model stability for debugging tasks
- Strong performance on technical prompts

**Best for:** Programming, debugging, code completion, technical documentation.

```bash
curl -X POST https://your-omniroute.example.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
        "model": "auto/coding",
        "messages": [{ "role": "user", "content": "Write a Python function to compute Fibonacci numbers." }]
      }'

```

### auto/fast: Lowest Latency Selection

The **`auto/fast`** variant minimizes response time using the `ship-fast` weight pack. It scores providers by **inverse p95 latency plus health metrics**, selecting whichever endpoint can return a token fastest.

**Best for:** Time-critical chat, real-time assistants, streaming applications.

```bash
curl -X POST https://your-omniroute.example.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
        "model": "auto/fast",
        "messages": [{ "role": "user", "content": "What time is it in Tokyo?" }]
      }'

```

### auto/cheap: Minimum Token Cost

The **`auto/cheap`** variant (also aliased as `auto/floor`) applies the `cost-saver` weight pack to select the **cheapest per-token provider** that meets basic request requirements. It exhaustively ranks providers by price before considering quality signals.

**Best for:** Budget-constrained workloads, bulk processing, non-critical batch jobs.

```bash
curl -X POST https://your-omniroute.example.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
        "model": "auto/cheap",
        "messages": [{ "role": "user", "content": "Summarise this 10-page PDF." }]
      }'

```

### auto/smart: Quality with Exploration

The **`auto/smart`** variant uses the `quality-first` weight pack with a **10% exploration boost**. This allows the router to occasionally try newer or higher-tier models that may outperform current selections, preventing the system from getting stuck on stale optimal choices.

**Best for:** Creative tasks, research, cases where you want best results and are willing to accept occasional variance for discovery.

```bash
curl -X POST https://your-omniroute.example.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
        "model": "auto/smart",
        "messages": [{ "role": "user", "content": "Suggest a novel plot for a sci-fi thriller." }]
      }'

```

## Where Variants Are Defined

The `AUTO_TEMPLATE_VARIANTS` map in [`open-sse/services/autoCombo/builtinCatalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/builtinCatalog.ts) (lines 20–28 in release v3.8.50) binds each `auto/*` prefix to its internal variant name and weight configuration. This catalog is exposed to clients via the `/v1/models` endpoint through [`src/app/api/v1/models/catalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/models/catalog.ts), which returns `Object.keys(AUTO_TEMPLATE_VARIANTS)` for discovery.

| File | Purpose |
|------|---------|
| [`open-sse/services/autoCombo/builtinCatalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/builtinCatalog.ts) | Declares `AUTO_TEMPLATE_VARIANTS` mapping variants to weight packs |
| [`src/sse/handlers/autoRouting.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/sse/handlers/autoRouting.ts) | Parses `model` strings, looks up variants, builds virtual combos |
| [`src/app/api/v1/models/catalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/models/catalog.ts) | Exposes available auto-variants via `/v1/models` |
| [`src/app/api/combos/auto/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/combos/auto/route.ts) | Generates virtual combo payloads for REST API requests |
| [`docs/routing/AUTO-COMBO.md`](https://github.com/diegosouzapw/OmniRoute/blob/main/docs/routing/AUTO-COMBO.md) | Documents variant semantics and usage examples |

## Summary

- **`auto/coding`** — `coding` weight pack for highest code quality and stability
- **`auto/fast`** — `ship-fast` pack for minimum p95 latency
- **`auto/cheap`** — `cost-saver` pack for lowest token price (alias `auto/floor`)
- **`auto/smart`** — `quality-first` pack plus 10% exploration for discovery

All four variants use the same OpenAI-compatible endpoint; only the `model` field changes. The router resolves the virtual combo at request time according to the selected variant's scoring weights.

## Frequently Asked Questions

### What happens if no provider matches an auto variant's criteria?

OmniRoute falls back to the next-best scoring provider according to the variant's weight pack. If all providers fail health checks, the request queues or returns a 503 error depending on your configuration in [`src/sse/handlers/autoRouting.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/sse/handlers/autoRouting.ts).

### Can I create custom auto variants beyond the built-in four?

Yes. You can extend `AUTO_TEMPLATE_VARIANTS` in [`open-sse/services/autoCombo/builtinCatalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/builtinCatalog.ts) with custom weight packs, though this requires modifying the OmniRoute source and redeploying. The built-in variants cover the majority of routing needs.

### Does auto/smart's 10% exploration impact latency or cost significantly?

Occasionally. The exploration boost means roughly 10% of requests may route to non-optimal providers by pure quality scores, which could be slower or pricier. The trade-off enables continuous discovery of better provider-model combinations as the ecosystem evolves.