Long-running agents and ScaleDown: the call

The call

LangChain announced the langchain-scaledown package and ScaleDown support in its LangSmith LLM Gateway on 13 October (vendor, LangChain; independent, Superpower Daily). It is not a new kind of agent. Deep Agents is LangChain’s existing harness for long tasks. The new piece is the layer that decides what the agent remembers.

What it is, and what it is not

What it is. Four ScaleDown models, each trained for one job: Summarize, Compress, Extract, and Classify. Each can only return answers its task allows, such as a label or spans of the input, which is why they can be small. Each takes up to a million tokens, and three take images and scanned PDFs. LangChain ships three middlewares: one replaces Deep Agents’ built-in summarisation, one compresses tool results when the model fills an optional compression_query on the tool call, and one extracts fields from the user’s messages into agent state. New accounts get 50 million free tokens (vendor, LangChain docs).

What it is not. It is not a replacement for your main model; LangChain itself says to keep a general-purpose model for code, replies, and planning. It is not independently benchmarked. The drift detector in the launch post is example code, not a shipped middleware. And the docs cover Python only.

The number nobody is quoting

The headline says 200 times faster and 467 times cheaper. That is ScaleDown’s own claim, on narrow tasks. Its benchmark page compares each model with the average of three OpenAI models and reports Summarize 41 times cheaper and Compress 138 times cheaper (vendor, ScaleDown). The method uses one public dataset per task, states no sample sizes, and does not describe how cost or latency were timed (vendor, ScaleDown methodology; our reading). Every figure is one call, not one agent run.

The launch post says compression cut a docs page by almost 90%. The note in its own trace says 18,402 characters to 3,110. That is 1 − 3,110 ÷ 18,402 = 83.1% (our maths). Still worth having. Not 90.

The saving that matters is what the agent stops re-reading. A tool result stays in context for every later turn.

Sixty-one cents per tool call, before prompt caching takes most of it back. The money is not the point. The window is: ten pages like this fill 46,000 tokens uncompressed and 7,780 compressed (our maths). An agent working in the smaller context stays on task longer. Measure that, not the invoice.

Missing

What ScaleDown has not told an enterprise buyer, as of 15 October:

• A price card. We found the 50 million free tokens and no per-token price.
• Data retention, residency, and sub-processors. Every middleware sends history, tool output, or user messages to ScaleDown.
• SOC 2 or an equivalent attestation.
• Self-hosted or private-cloud deployment.
• Independent benchmarks, and any figure for a complete agent run.
• A JavaScript or TypeScript package.
• A shipped drift breaker. The launch post shows it as custom code only.

Who owns what

The middleware is LangChain’s job. The failure mode is ours.

All three middlewares fail open: if ScaleDown is unreachable, rejects a call, or runs out of credits, the agent carries on as if the middleware were absent (vendor, LangChain docs). For summarisation that is right. For a drift breaker it means no brakes. The example breaker in the launch post calls the API with no timeout and no error handling, so a slow call stalls every turn and a failed one ends the run. Decide for each check whether it fails open or closed, set a timeout, and log every trip with its reason.

In a Salesforce service flow, Extract earns its place where the agent files a case: it copies the order number and email from the customer’s words instead of letting the main model retype them. The value still gets checked against the record before the callout writes it.

We run the same principle in our own content agent: one writing call, then deterministic checks, after we took out a recursive writer and reviewer loop. The expensive model writes; cheap, checkable steps police it.

Monday morning

1. Step 1. Find your biggest tool results. From traces, list every tool output over 10,000 characters and how many turns it stays in context. Owner: AI engineering lead.
2. Step 2. Compress those tools only, on internal agents. Run 200 tasks with compression and 200 without; compare pass rate and tokens per finished task. Owner: AI engineering lead.
3. Step 3. Build the drift breaker to fail closed. Timeout on every call, 0.8 threshold to start, every trip logged with its reason and reviewed weekly. Owner: head of AI platform.
4. Step 4. Send ScaleDown your security questionnaire. Retention, residency, sub-processors, attestation, and a price card. Owner: CIO or procurement.
5. Step 5. Price the alternative. Run the same summarise and compress jobs on a small model you already host, and compare cost per finished task. Owner: head of AI platform.

We move this to ADOPT for customer-data agents once ScaleDown publishes retention, residency, and an attestation. We move it to WATCH if pass rates drop with compression on.