Alternatives · Updated 2026-10-21
ScaleDown alternative: SuperCompress
ScaleDown is a hosted, query-aware Compress API: you send context plus a prompt and get a shorter context back. SuperCompress is also hosted and query-aware, but it is extractive at the line level. It returns original lines copied verbatim from the input and drops the rest. It never rewrites. If your context is coding-agent tool output (logs, stack traces, diffs, file reads, shell output) where the unit that matters is a line, SuperCompress is the alternative to try.
What is ScaleDown?
ScaleDown publishes a hosted Compress endpoint, POST /compress/raw/, that takes supporting context plus a prompt and returns a compressed context. Its docs say compression is applied mainly to context, and that the prompt (the question or instruction) is kept intact. Compress is one of a set of task models: Summarize, Compress, Extract and Classify. Sources: ScaleDown Compress overview, LangChain on ScaleDown and Deep Agents.
The same vendor ships langchain-scaledown, a LangChain and Deep Agents package. Its ScaledownToolCompressionMiddleware adds an optional compression_query on a tool call. When the model fills that in, the tool result is compressed before the model sees it. Compress is also listed in LiteLLM as scaledown/compress (LiteLLM Compress listing).
How does ScaleDown decide what to keep?
ScaleDown describes the Compress output in two ways, both quoted here with attribution.
The Compress overview calls the result "a semantically equivalent version" of the input and says the compression is "lossless in intent": the downstream model is meant to receive the same information, expressed more efficiently.
A ScaleDown engineering post, How We Train SLMs for Context Compression, describes an extractive model that does not generate text. In that post, the model scores tokens, aggregates those scores to sentence-level relevance, and returns the top-scoring sentences as the compressed output. The post's takeaway is that the model selects sentences and does not rewrite them.
Those are ScaleDown's own descriptions. This page does not claim that ScaleDown rewrites, paraphrases or invents text. If you need the returned text to be a verbatim subset of your input, send a sample through Compress and diff the kept text against the original.
How does SuperCompress differ?
SuperCompress is hosted, query-aware and extractive at the line level. Your agent or app sends a bulky block of context (a log, a diff, a long file read, an MCP result, retrieved documents) together with the question being asked. The hosted model keeps original lines copied verbatim from the input and drops the rest. It never rewrites or summarizes. Error messages, file paths, identifiers and code come through exactly as they were.
Line granularity matters for coding-agent context. Stack traces, log lines, diffs, file reads, JSON lines and shell output often have no sentence structure. A sentence is the wrong unit when a traceback, a unified diff hunk or a JSON object is split across lines, or when one physical line is the whole record. The model also needs to quote exact paths, identifiers and error text when it writes a patch.
Skip the Compressor (arXiv 2610.21073) found that compressors that alter text make fewer patches apply, because an edit has to quote the code it changes. That study did not test SuperCompress or ScaleDown. It is cited only for the point that verbatim text matters for edits.
Where does each one plug in?
| ScaleDown | SuperCompress | |
|---|---|---|
| What you send | context plus prompt to POST /compress/raw/ | Context plus the current question to POST /api/v1/compress |
| How it describes keep | Docs: semantically equivalent, lossless in intent. Engineering post: extractive top-sentence selection | Original lines copied verbatim from the input; the rest dropped |
| Granularity | Sentence-level in the engineering post | Line-level |
| Where it runs | Hosted API | Hosted API |
| How you connect | HTTP API, LangChain / Deep Agents middleware, LiteLLM | supercompress setup (MCP tool and hooks for detected agents), HTTP API |
ScaleDown plugs in as an HTTP API, as LangChain and Deep Agents middleware (including ScaledownToolCompressionMiddleware), and as the LiteLLM model scaledown/compress.
SuperCompress plugs into coding agents through npm install -g supercompress-proxy && supercompress setup, which wires the compress_context MCP tool and hooks for detected agents (Claude Code, Cursor, Codex, Windsurf, Cline, Gemini CLI, OpenCode and more). Apps call POST /api/v1/compress, which returns the kept text along with original_tokens and kept_tokens.
When is ScaleDown the right choice?
ScaleDown is a reasonable choice if you already build on LangChain or Deep Agents and want tool-result compression as middleware, if your context is mostly prose (RAG documents, chat history, long articles), or if you also want Summarize, Extract and Classify from one vendor. Those jobs sit next to Compress in ScaleDown's own model set.
When is SuperCompress the right choice?
SuperCompress is the better fit when the context is coding-agent tool output: logs, stack traces, diffs, file reads, JSON lines and shell output. In those traces the unit that matters is a line, and the kept text needs to be a verbatim copy of the original so the model can quote paths, identifiers and error messages.
How do you compare them fairly?
Run the same real trace through both tools. Diff the kept text against the original so you can see what each one returned. Measure end-to-end cost per solved task, not token counts alone.
Beyond Token Savings (arXiv 2609.32961) found that fewer tokens do not always mean cheaper or faster runs. The daseinlabs/code-compression-bench ranks compressors by cost per solved task. Neither study tested SuperCompress or ScaleDown.
See also: all alternatives, Headroom alternative, Caveman alternative, context compression tools compared.
Sources
- ScaleDown Compress overview
- Building long-running agents with ScaleDown and Deep Agents (LangChain)
- How We Train SLMs for Context Compression (ScaleDown engineering post)
- langchain-scaledown on PyPI
- LiteLLM Compress listing
- Skip the Compressor (arXiv 2610.21073)
- Beyond Token Savings (arXiv 2609.32961)
- daseinlabs/code-compression-bench
Try it
One command installs the CLI and wires the hosted compressor into every coding agent it finds on your machine (Claude Code, Cursor, Codex, Windsurf, Cline, Gemini CLI, OpenCode and more). Then supercompress doctor shows a health check per agent.
npm install -g supercompress-proxy && supercompress setupBuilding your own app instead? Call the hosted API with a key from the dashboard.
FAQ
Is ScaleDown extractive?
ScaleDown's engineering post describes an extractive model that scores tokens and returns the top-scoring sentences. Its Compress docs describe the output as a semantically equivalent version that is lossless in intent. Check a sample against your input if you need a verbatim subset.
Does SuperCompress change my code or error messages?
No. SuperCompress returns original lines copied verbatim from the input and drops the rest. It never rewrites or summarizes, so code, paths and error text stay as they were.
Can I use SuperCompress with MCP tool output?
Yes. The setup command wires the compress_context MCP tool and hooks for detected coding agents, so bulky tool results can be compressed against the current question before the model reads them.
When is ScaleDown the better fit?
ScaleDown is a reasonable choice if you build on LangChain or Deep Agents, your context is mostly prose such as RAG documents or chat history, or you also want Summarize, Extract and Classify from one vendor.
When is SuperCompress the better fit?
SuperCompress is the better fit for coding-agent tool output (logs, stack traces, diffs, file reads, JSON lines, shell output) where line granularity and verbatim kept text matter.