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
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.
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.
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.
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.
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.
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.