# OmniRoute Compression Engines: Lite, Standard, Aggressive, Ultra, RTK, and Stacked Explained

> Explore OmniRoute's six compression engines Lite Standard Aggressive Ultra RTK and Stacked. Learn how to configure them via updateCompressionSettings to optimize token usage and reduce costs.

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

---

**OmniRoute provides six distinct compression engines—Lite, Standard (Caveman), Aggressive, Ultra, RTK, and Stacked—that can be configured via `updateCompressionSettings()` in [`src/lib/db/compression.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/db/compression.ts) to reduce token usage through whitespace cleanup, rule-based filtering, summarization, token pruning, or chained pipelines.**

OmniRoute ships with a sophisticated prompt-compression pipeline located in the `open-sse` workspace of the diegosouzapw/OmniRoute repository. These specialized engines allow developers to switch between lightweight formatting cleanup and advanced context pruning strategies on a per-request or global basis. Understanding how to configure each OmniRoute compression engine enables precise control over the trade-off between context retention and token economy.

## Understanding the Six OmniRoute Compression Engines

The engine catalog is declared in `ENGINE_CATALOG` at [`open-sse/services/compression/engineCatalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/engineCatalog.ts) (lines 10-34), while the allowed mode values are defined in the `CompressionMode` enum at [`open-sse/services/compression/types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/types.ts) (lines 27-28). Each engine targets specific compression strategies, from simple formatting to AI-assisted token pruning.

### Lite Engine

The **Lite** engine performs simple whitespace and format cleanup, such as collapsing repeated line breaks and normalizing indentation. It requires no additional per-engine configuration beyond enabling the mode itself, as implemented in [`open-sse/services/compression/lite.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/lite.ts).

### Standard (Caveman) Engine

The **Standard** engine (internally codenamed *Caveman*) applies rule-based prose compression using regex rules to delete filler text, deduplicate content, and preserve code blocks. Configuration is handled via the `cavemanConfig` object defined in [`open-sse/services/compression/types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/types.ts) (lines 54-61), which supports an `intensity` setting of `"lite"`, `"full"`, or `"ultra"`, and an optional `skipRules` array. The default configuration (`DEFAULT_CAVEMAN_CONFIG`) sets `enabled: false` and `intensity: "lite"`.

### Aggressive Engine

The **Aggressive** engine operates in three phases: summarization, tool-result compression, and aging of old conversation turns. It is configured through the `aggressive` object (lines 98-104 in [`types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/types.ts)), which includes `thresholds` for different summary levels, `toolStrategies` for specific output types (file content, grep search, shell output, JSON, error messages), and flags like `summarizerEnabled` and `maxTokensPerMessage`.

### Ultra Engine

The **Ultra** engine implements token-pruning heuristics (Tier-A) and optional SLM-based pruning (Tier-B), with the ability to pre-warm an ONNX model. Configuration uses the `ultra` object (lines 34-41 in [`types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/types.ts)), supporting parameters such as `compressionRate` (keep percentage), `minScoreThreshold`, `modelPath`, and `ultraSlmPrewarm`. By default, `DEFAULT_ULTRA_CONFIG` disables the engine and uses a 50% keep rate with the heuristic tier only.

### RTK Engine

The **RTK** engine filters command output by removing noisy lines, deduplicating results, and stripping code comments. It is configured via `rtkConfig` (lines 79-93 in [`types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/types.ts)), accepting `intensity` levels of `"minimal"`, `"standard"`, or `"aggressive"`, plus boolean flags for `applyToToolResults`, `customFiltersEnabled`, and `enableRenderers`, along with numeric thresholds like `maxLinesPerResult` and `deduplicateThreshold`.

### Stacked Pipeline

The **Stacked** engine chains multiple single-mode engines into a custom pipeline using the `stackedPipeline` configuration. This accepts an array of `CompressionPipelineStep` objects (lines 32-38 in [`types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/types.ts)), allowing sequences such as RTK followed by Caveman. The default stacked configuration runs `{engine:"rtk",intensity:"standard"}` followed by `{engine:"caveman",intensity:"full"}`.

## How to Configure OmniRoute Compression Engines

All compression settings persist in the SQLite database namespace handled by [`src/lib/db/compression.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/db/compression.ts). Use the `getCompressionSettings()` and `updateCompressionSettings()` helpers (lines 25-34) to programmatically read and write configurations.

### Enabling Lite Mode

To activate basic whitespace cleanup:

```typescript
import { updateCompressionSettings } from "@omniroute/lib/db/compression";

await updateCompressionSettings({
  enabled: true,
  defaultMode: "lite",
});

```

### Configuring Standard (Caveman) Mode

Enable with custom intensity and rule exclusions:

```typescript
await updateCompressionSettings({
  cavemanConfig: {
    enabled: true,
    intensity: "full",
    skipRules: ["remove-redundant-whitespace"],
  },
});

```

### Tuning Aggressive Compression

Configure summarization thresholds and tool strategies:

```typescript
await updateCompressionSettings({
  aggressive: {
    thresholds: { fullSummary: 5, moderate: 3, light: 2, verbatim: 2 },
    toolStrategies: {
      fileContent: true,
      grepSearch: true,
      shellOutput: true,
      json: true,
      errorMessage: true,
    },
    summarizerEnabled: true,
    maxTokensPerMessage: 2048,
    minSavingsThreshold: 0.08,
  },
});

```

### Setting Up Ultra Mode with SLM Support

Enable heuristic pruning and optionally load an ONNX model:

```typescript
await updateCompressionSettings({
  ultra: {
    enabled: true,
    compressionRate: 0.4,
    minScoreThreshold: 0.25,
    modelPath: "/opt/llmlingua/model.onnx",
    ultraSlmPrewarm: true,
  },
});

```

### Configuring RTK Filters

Apply aggressive filtering to tool results:

```typescript
await updateCompressionSettings({
  rtkConfig: {
    enabled: true,
    intensity: "aggressive",
    applyToToolResults: true,
    maxLinesPerResult: 200,
    deduplicateThreshold: 5,
    customFiltersEnabled: true,
    enableRenderers: false,
  },
});

```

### Building a Stacked Pipeline

Combine multiple engines in sequence:

```typescript
await updateCompressionSettings({
  defaultMode: "stacked",
  stackedPipeline: [
    { engine: "rtk", intensity: "standard" },
    { engine: "caveman", intensity: "full" },
    { engine: "ultra", intensity: "ultra" },
  ],
});

```

### Reading Current Configuration

Retrieve the full configuration object for debugging or UI display:

```typescript
import { getCompressionSettings } from "@omniroute/lib/db/compression";

const cfg = await getCompressionSettings();
console.log("Current compression config:", JSON.stringify(cfg, null, 2));

```

The complete configuration shape is defined by the `CompressionConfig` type at [`open-sse/services/compression/types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/types.ts) (lines 46-78).

## Summary

- OmniRoute provides six compression engines—**Lite**, **Standard (Caveman)**, **Aggressive**, **Ultra**, **RTK**, and **Stacked**—each optimized for different token reduction strategies in the `open-sse` workspace.
- Engine selection and tuning are controlled via `updateCompressionSettings()` in [`src/lib/db/compression.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/db/compression.ts), with type definitions in [`open-sse/services/compression/types.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/types.ts) and the catalog defined in [`open-sse/services/compression/engineCatalog.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/compression/engineCatalog.ts).
- **Lite** requires no configuration, while **Standard**, **Aggressive**, **Ultra**, and **RTK** offer granular intensity levels, thresholds, and filtering options defined in their respective config types.
- **Stacked** pipelines allow chaining multiple engines sequentially using `CompressionPipelineStep` arrays to achieve compound compression effects.
- All settings persist to SQLite and can be previewed via the HTTP endpoint at [`src/app/api/compression/preview/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/compression/preview/route.ts).

## Frequently Asked Questions

### What is the difference between Lite and Standard compression in OmniRoute?

**Lite** performs only basic whitespace and formatting cleanup, such as collapsing line breaks and normalizing indentation, with no additional configuration required. **Standard** (Caveman) applies rule-based prose compression using regex to remove filler words and deduplicate content while preserving code blocks, offering configurable intensity levels of "lite", "full", or "ultra" via the `cavemanConfig` object.

### How do I enable the Ultra engine with SLM-based pruning?

Set `enabled: true` in the `ultra` configuration object and provide a valid `modelPath` to your ONNX model. Set `ultraSlmPrewarm: true` to initialize the model on first use, and adjust `compressionRate` to control the percentage of tokens retained (e.g., `0.4` keeps the top 40% of tokens according to the scoring heuristic).

### Can I combine multiple compression engines in OmniRoute?

Yes, use the **Stacked** pipeline mode by setting `defaultMode: "stacked"` and defining a `stackedPipeline` array containing `CompressionPipelineStep` objects. Each step specifies an engine name and intensity, allowing you to chain engines such as RTK followed by Caveman or Ultra for progressive compression.

### Where are compression settings stored in OmniRoute?

Compression settings persist in the SQLite database within the compression namespace, managed by [`src/lib/db/compression.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/db/compression.ts). The helper functions `getCompressionSettings()` and `updateCompressionSettings()` provide the programmatic interface for reading and writing these values, while [`src/app/api/compression/preview/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/compression/preview/route.ts) exposes an HTTP endpoint for debugging the effective configuration.