← Back to Blog

Reducing LLM response times through compression

Up to 49% faster time-to-first-token at 50% token reduction — and up to 63% at heavier compression — measured across 9 frontier models at 200K-token context

August 20269 models across 5 providers~50% token reductionbear-2 @ compression_ratio 0.5
200K tokensCompressed-49%3.8s saved at 200KFewer tokens means faster time-to-first-token and lower end-to-end latency

49%

Faster at 50% reduction

Qwen3-Next 80B, 200K

63%

Faster at 0.65 ratio

Heavier compression, 200K

3.8s

Saved per request

Qwen3-Next 80B, 200K

9

Frontier models

5 providers, 10 runs each

What we measured

Time-to-first-token (TTFT) is the wall-clock time from sending a request to receiving the LLM's first streamed token. For chatbots, coding assistants, and agents, this number determines how fast your product feels to users.

When you compress context before sending it to an LLM, two things happen: you pay a small overhead for compression, but the LLM processes fewer tokens — which means faster prefill and faster time-to-first-token. The question is whether the latency savings from shorter context outweigh the compression cost.

This benchmark measures both paths end-to-end. The baseline sends full context directly to each model's API. The compressed path runs context through the TTC /v1/compress endpoint at a fixed compression_ratio of 0.5 — a static setting that removes half the tokens on any content — then sends the compressed output to the same model. Accuracy under bear-2 compression is benchmarked separately — see CoQA and SEC filings.

Evaluation design

We measured streaming TTFT across four input sizes (10K to 200K estimated tokens) using 33 public-domain congressional hearing transcripts from govinfo.gov — long, real spoken-word documents representative of meeting, call, and support workloads. Each configuration ran 10 times from an EC2 instance in us-west-2; medians are reported.

The compressed path uses bear-2 at static compression ratio 0.5 (ratios 0.35 and 0.65 were also measured). Reasoning and thinking were set to their minimum on every model so results isolate prefill rather than thinking behavior. Nine current-generation models across OpenAI, Anthropic, Google, DeepSeek, and Alibaba were tested with identical text.

Document
bear-2 compression
Compressed context
LLM
First token

Results: 9 frontier models at 200K tokens

At 200K-token context with 50% token reduction, eight of nine models answered 29–49% faster. At the heavier 0.65 ratio the same models reached 40–63%. The slowest baselines gain the most: Qwen3-Next drops from 7.7s to 4.0s, Claude Opus 5 from 6.8s to 4.0s.

Compression also creates context headroom. A 200K-token document sits at the edge of Claude's window — denser documents of the same nominal size can tokenize past it and fail outright — while at ratio 0.5 the same content fits every model tested with half the window to spare for output and history.

Baseline (direct to LLM)With bear-2 compression (ratio 0.5)
02s4s6s8sQwen3-Next 80B7.7s4.0s-49%DeepSeek V4 Flash7.8s4.9s-37%Claude Opus 56.8s4.0s-42%Gemini 3.6 Flash6.3s3.7s-41%Claude Sonnet 54.7s2.9s-38%Claude Haiku 4.53.1s2.0s-36%GPT-5.6 Luna2.4s1.4s-43%GPT-5.6 Terra2.2s1.5s-29%Gemini 3.5 Flash-Lite1.9s2.7s+44%

200K-token context, median of 10 runs. Gemini 3.5 Flash-Lite is the disclosed exception: its prefill is already near-instant at these sizes, so the compressed path measured slower.

Scaling with input size: Claude Haiku 4.5

Savings grow with context length. On Claude Haiku 4.5, compression saves 180ms at 10K tokens and 1.1 seconds (36%) at 200K — because prefill time grows with input length while compression overhead barely does.

Baseline (direct to LLM)With bear-2 compression (ratio 0.5)
01s2s3s865ms685ms-21%10Ktokens1.1s974ms-15%50Ktokens1.9s1.2s-36%100Ktokens3.1s2.0s-36%200Ktokens

Scaling with input size: GPT-5.6 Luna

GPT-5.6 Luna shows the same pattern with lower absolute latencies: savings of 17–28% at 10K–100K tokens, rising to 43% (1.0 second) at 200K.

Baseline (direct to LLM)With bear-2 compression (ratio 0.5)
01s2s1.0s858ms-17%10Ktokens1.2s864ms-27%50Ktokens1.4s1.0s-28%100Ktokens2.4s1.4s-43%200Ktokens

10 runs per size per model. Full per-model, per-size, per-ratio tables available on request.

Compression API performance

The static-ratio compression calls used in this benchmark completed in 0.1–0.6 seconds median at every size from the same region — a small fraction of the seconds saved on the LLM side at large contexts.

The production fan-out path is faster still: our February 2026 measurement of bear-1.2 sustained up to 1.7M tokens per second with sub-120ms P50 latency at all sizes tested.

0500K1M1.5M2MInput size (tokens)250K tok/s10K455K tok/s25K714K tok/s50K1M tok/s100K1.7M tok/s200K

Compression overhead stays far below the savings

Whether via single static-ratio calls (0.1–0.6s median) or the fan-out path (sub-120ms P50), compression cost is consistently small relative to the 1–4 seconds of prefill it removes at long context.

Key findings

Savings scale with input size

At 10K tokens the effect is small; at 200K it reaches 29–49% at ratio 0.5 across eight of nine models. Prefill time grows with context length while compression overhead grows much more slowly.

The benefit holds across five providers

OpenAI, Anthropic, Google, DeepSeek, and Alibaba models all show the effect despite very different baseline latency profiles — it comes from reducing the fundamental work the LLM does, not from any provider-specific behavior.

Compression creates context headroom

Documents near a model's context limit can exceed it outright once tokenized — in earlier runs on denser prose, a nominal 200K-token document tokenized to 209K and Claude rejected it. Compressed at ratio 0.5, the same workloads fit comfortably, with window left over for output and conversation history.

Compression overhead is consistently low

Static-ratio calls complete in 0.1–0.6s median at up to 200K tokens; the fan-out path sustains sub-120ms P50. Compression is practical for real-time pipelines.

Methodology

Dataset

33 public-domain congressional hearing transcripts (govinfo.gov), sliced to 10K, 50K, 100K, and 200K estimated tokens

Measurement

10 runs per configuration, streaming time-to-first-token including all network overhead, from EC2 c5n.large in us-west-2

Configuration

bear-2 via /v1/compress at compression_ratio 0.5 (0.35 and 0.65 also measured). Reasoning/thinking at minimum on every model

Reproducibility

Public corpus, static content-independent compression setting, and per-model native APIs — the full pipeline can be reproduced with a TTC API key and provider keys

Limitations

  • All measurements were taken from a single region (us-west-2). Latency characteristics may differ from other locations.
  • Reasoning/thinking was set to its minimum on every model. Compression reduces prefill, not thinking: thinking-heavy configurations see smaller relative gains.
  • Gemini 3.5 Flash-Lite is the exception in the results: its prefill is already near-instant at these sizes and the compressed path measured slower at 200K. Models with ultra-fast prefill gain little.
  • Claude Fable 5 was excluded: its safety layer refuses a subset of compressed inputs, and its latency is dominated by internal deliberation that compression does not reduce.
  • 10 runs per configuration; medians are reported. Individual cells at smaller sizes sit within network variance.
  • Spoken-word transcripts compress predictably; highly structured or code-heavy inputs may behave differently.

Ready to try it?

Book a 30-minute call and we'll get you set up with an API key.