# OmniRoute Routing Strategies: Complete Guide to 20+ Dispatch Methods

> Explore OmniRoute routing strategies with our complete guide. Discover 20+ dispatch methods including priority, cost, latency, and ML-driven options for optimal delivery.

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

---

**OmniRoute supports 18 core routing strategies including priority-based, weighted, round-robin, cost-optimized, latency-aware, and ML-driven selectors, plus 6 auto-combo sub-strategies for dynamic provider selection.**

The **OmniRoute routing strategies** determine how incoming LLM requests are distributed across providers, accounts, and models. These strategies are defined centrally in [`src/shared/constants/routingStrategies.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/shared/constants/routingStrategies.ts) and exposed through the strategy registry in [`open-sse/services/autoCombo/routerStrategy.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/routerStrategy.ts). This guide covers every dispatch method available in the v3.8.51 release, with implementation details from the source code.

## Core Routing Strategies

OmniRoute's primary strategies are enumerated in `ROUTING_STRATEGY_VALUES` ([lines 2-21](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/routingStrategies.ts#L2-L21)) and surfaced to the UI via `ROUTING_STRATEGIES` ([lines 90-124](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/routingStrategies.ts#L90-L124)).

### Sequential and Deterministic Strategies

These strategies follow predictable patterns for provider selection:

- **priority** — Executes candidates in strict order, stopping at first success. Uses icon `sort`.
- **round-robin** — Cycles through candidates sequentially for even distribution. Uses icon `autorenew`.
- **fill-first** — Sends requests to the first candidate with sufficient token budget. Uses icon `vertical_align_top`.

### Probability-Based Strategies

Randomized selection methods with different sampling approaches:

- **weighted** — Picks candidates according to a weight-based probability distribution. Uses icon `percent`.
- **random** — Uniform random selection across all candidates. Uses icon `shuffle`.
- **strict-random** — Random selection excluding recently failed candidates. Uses icon `casino`.
- **p2c** (Power-of-Two-Choices) — Selects the better of two randomly sampled candidates. Uses icon `balance`.

### Cost and Quota Optimized Strategies

Intelligent selection based on financial and resource constraints:

- **cost-optimized** — Chooses the cheapest candidate meeting request constraints. Uses icon `savings`.
- **least-used** — Prefers candidates with lowest recent usage count. Uses icon `low_priority`.
- **headroom** — Selects candidates with most remaining quota headroom. Uses icon `battery_charging_full`.
- **reset-aware** — Considers each provider's reset window during selection. Uses icon `event_repeat`.
- **reset-window** — Strictly respects reset-window ordering to prevent quota overrun. Uses icon `schedule`.

### Context-Aware Strategies

Selection methods optimized for request characteristics:

- **context-relay** — Forwards full request context to next candidate on failure. Uses icon `sync_alt`.
- **context-optimized** — Optimizes based on request context window size. Uses icon `text_snippet`.
- **cache-optimized** — Prioritizes candidates with best cache-hit probability. Uses icon `cached`.

### Advanced ML and Pipeline Strategies

Complex routing for specialized use cases:

- **lkgp** (Least-Known-Good-Provider) — Uses historical performance heuristics for task-specific selection. Uses icon `verified`.
- **fusion** — Fans requests to multiple models in parallel, merging responses via a judge model. Uses icon `hub`.
- **pipeline** — Chains multiple models, feeding output of one as input to next. Uses icon `linear_scale`.

### Dynamic Selection

- **auto** — Dynamically selects optimal auto sub-strategy. Uses icon `auto_awesome`.

## Auto-Combo Sub-Strategies

When **auto** is selected as the top-level strategy, OmniRoute resolves one of six sub-strategies registered in [`open-sse/services/autoCombo/routerStrategy.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/routerStrategy.ts) ([lines 381-390](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/open-sse/services/autoCombo/routerStrategy.ts#L381-L390)). These are defined in `AUTO_ROUTING_STRATEGY_VALUES` ([lines 38-48](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/routingStrategies.ts#L38-L48)):

| Sub-Strategy | Alias | Purpose |
|-------------|-------|---------|
| **rules** | — | Classic rule-based selector with fallback to deterministic strategies |
| **score** | — | Ranks candidates by composite score (cost, latency, headroom) |
| **cost** | **eco** | Cheapest viable candidate selection |
| **latency** | **fast** | Lowest estimated response latency |
| **sla-aware** | **sla** | Enforces SLA constraints (guaranteed latency/uptime) |
| **lkgp** | — | Least-known-good-provider heuristic |

## Internal-Only Strategies

System-generated strategies never exposed in the UI are defined in `INTERNAL_ROUTING_STRATEGY_VALUES` ([lines 31-32](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/src/shared/constants/routingStrategies.ts#L31-L32)):

- **quota-share** — Automatically created for quota-share combos

## How Routing Strategies Execute

The **OmniRoute routing strategy** execution flow follows this path:

1. API handlers in [`src/app/api/v1/.../route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/.../route.ts) extract `strategy` from request payload (defaulting to `"priority"`)
2. The combo dispatcher in `open-sse/services/combo/*` consults the strategy registry
3. `strategy.select(pool, context)` is invoked ([routerStrategy.ts lines 416-420](https://github.com/diegosouzapw/OmniRoute/blob/release/v3.8.51/open-sse/services/autoCombo/routerStrategy.ts#L416-L420))
4. Returns ordered list of provider-account-model targets for execution

## Implementation Examples

### Creating a Cost-Optimized Combo

```typescript
import { projectCombo } from '@/open-sse/services/combo/comboBuilder';
import { applyCombo } from '@/open-sse/services/combo/executeCombo';

const myCombo = projectCombo({
  name: 'my-cost-combo',
  strategy: 'cost-optimized',
  models: [{ provider: 'openai', model: 'gpt-4o' }],
});

const result = await applyCombo(myCombo, requestPayload);

```

### Custom Auto Strategy with Latency Preference

```typescript
import { registerStrategy } from '@/open-sse/services/autoCombo/routerStrategy';

registerStrategy('auto', {
  name: 'auto',
  description: 'Auto routing preferring latency',
  select: (pool, ctx) => {
    const latencyStrategy = getStrategy('latency');
    return latencyStrategy.select(pool, ctx);
  },
});

```

## Key Source Files

| File | Role |
|------|------|
| [`src/shared/constants/routingStrategies.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/shared/constants/routingStrategies.ts) | Central constants, normalization, UI metadata |
| [`open-sse/services/autoCombo/routerStrategy.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/autoCombo/routerStrategy.ts) | Strategy name-to-implementation registry |
| `open-sse/services/combo/*` | Combo execution consuming selected strategy |
| `src/app/api/v1/*/route.ts` | API entry points parsing `strategy` field |

## Summary

- **18 core strategies** cover sequential, probabilistic, cost-optimized, context-aware, and advanced ML-driven routing patterns
- **6 auto sub-strategies** provide dynamic selection with aliases like `eco` (cost) and `fast` (latency)
- **1 internal strategy** (`quota-share`) for system-generated combos
- All strategies route through `strategy.select(pool, context)` in the combo dispatcher
- Default fallback is **priority** when no strategy is specified in the request payload

## Frequently Asked Questions

### What is the default routing strategy in OmniRoute?

OmniRoute defaults to **priority** routing when no strategy is explicitly specified in the request payload. This executes candidates in their configured order, stopping at the first successful response.

### How does the p2c (Power-of-Two-Choices) strategy work?

The **p2c** strategy randomly samples two candidates from the pool and selects the better option based on internal scoring. This balances load more effectively than pure random selection while avoiding the coordination overhead of global state tracking.

### Can I use multiple routing strategies together?

Yes. The **fusion** strategy fans requests to multiple models in parallel and merges responses, while **pipeline** chains models sequentially. For dynamic selection, set `strategy: 'auto'` and specify a sub-strategy like `latency` or `cost` to automatically adapt routing based on runtime conditions.