cost-saving · layer 3

Right-size every turn

Most coding sessions pay the same headline rate for every turn, even though many turns are mechanical and most of the conversation is old. Squeezy reshapes each turn so the cheap, repetitive work stays cheap and your model budget goes to the reasoning that needs it.

Tiered routing: send the easy turns to a smaller model

Not every request needs your main model. “Run the test suite,” “check out main,” “rename this symbol in that file,” “grep for TODOs”, these are well-specified, mechanical asks that a smaller, faster model from the same provider handles correctly at a fraction of the price. Squeezy looks at each turn before it runs and decides which rung of your provider's ladder it belongs on: the small, fast tier, a mid tier where your provider has one, or your main model.

The decision is conservative by design. Squeezy applies structural gates first: plan mode, images, large attachments, sticky post-escalation windows, providers without a cheaper rung, and sandbox-sensitive prompts stay on the parent model unless explicitly forced. Eligible turns then go to a JSON-constrained provider-local judge that returns a weak, medium, or strong rung plus whether the turn depends on prior context. If the judge is disabled, unclear, or says the turn depends on warm conversation state, Squeezy stays on the parent model. Routing never blocks your turn.

If a routed turn gets in over its head mid-turn, too many tool calls, repeated errors, or it signals it's unsure, Squeezy steps it up one rung at a time, from the small, fast tier to a mid tier where your provider has one, and on to your main model, and stays on the stronger model for the next few follow-ups so the work doesn't flap back down. The full conversation carries across each step: no restart, no lost context.

Routing always stays within your configured provider: an Anthropic session escalates between Anthropic models, an OpenAI session between OpenAI models. Squeezy never silently swaps you to a different vendor, and if your provider has no small/fast tier, the turn just runs on your main model.

/cheap, force the prompt that contains it onto the small/fast model.
/parent, force the next turn onto your main model, bypassing routing.
/router, turn automatic routing off for the session (explicit /cheap still works) or back on.
Same provider only: the cheap tier is always your vendor's smaller model, so credentials and conversation state carry over with no switch.

/cheap summarize this file  # this prompt → small/fast model
/parent                    # next turn → main model
/router                    # toggle automatic routing for the session

Compaction: stop paying for turns 1-29 on turn 30

A chat-style agent resends the whole conversation on every turn, so a long session's cost grows far faster than the work you did, turn 30 pays for everything said in turns 1 through 29, and old tool outputs (a file you read once, a search result, a build log) usually dominate that weight.

Squeezy folds the older part of a long conversation into a short, structured summary: what the goal is, what progress has been made, what was decided, and what comes next. Recent turns stay verbatim, so the model never loses its grip on the immediate working state, and important files you've read or changed are carried forward by name across each fold.

The result is that a deep session levels off instead of ballooning, and it keeps long sessions from hitting the model's hard context limit and stalling. Full summary folds happen automatically after a turn once the conversation gets large, or reactively after a provider context-window error. Mid-turn pressure is handled by a lighter trim pass that clears old bulky tool-output bodies while preserving tool-call structure, so a request near the ceiling can still continue without pretending the whole conversation was summarized mid-turn.

Compaction is a deliberate trade: the model gives up word-for-word recall of old tool output in exchange for a faithful summary plus a record of every file touched. If you ever need the original detail back, a fold can be undone to restore the verbatim earlier context.

Goal / Progress / Decisions / Next, the shape every summary preserves; prior decisions and next steps are never dropped.
Recent turns stay intact, the last several exchanges are kept verbatim, not summarized.
File history carries forward, paths you read and modified survive each fold.
Undo available, restore the pre-fold conversation if you need the original detail.

Shaped tool output: keep the part the model can act on

Tool output is the biggest thing flowing into a coding agent's context, and most of it is noise. A build dumps tens or hundreds of kilobytes of progress chatter around a handful of errors. A test run mixes a pass/fail summary into pages of harness output. A broad search returns thousands of near-identical lines. Left raw, every one of these pushes your context budget toward its limit for no benefit.

Squeezy understands the common tool families and trims each to its signal. A build or compiler run is reduced to the errors and warnings plus the final result. A test run collapses to a pass/fail count, with failing tests and their messages surfaced and tagged so the model can tie a failure back to its source. A search is capped per line and overall, with duplicate file hits folded together. An image is handed to the model as an image instead of being mangled into broken text.

This now reaches the everyday non-test families too, across most ecosystems a coding session touches: Rust, C/C++, the JVM (Java, Kotlin via Gradle), .NET, Go, JavaScript/TypeScript, Python, Ruby, Swift, git and GitHub, shell/PowerShell linting, and cloud/container tooling (AWS, Docker, kubectl). Git diffs get a stat-first summary with hunks capped per file instead of a raw unified diff; a clean push or pull collapses to one line instead of transport-progress spam; Maven and Gradle drop download chatter and per-task banners while a passing Surefire/Failsafe run collapses instead of tripping a false "fail" match; bare pytest (no plugin needed) and RSpec/Minitest/RuboCop get the same failure-grouped treatment JSON-only runners already had; AWS/Lambda/IAM responses have secret-bearing fields omitted outright, not just truncated. Each family keeps anything that looks like an error, warning, failure, or summary no matter what, and a command Squeezy can't safely recognize is passed through untouched, so the trimming only ever removes predictable noise.

Nothing is lost. When output is trimmed, the full original is saved for the session and the trimmed block tells the model exactly how to fetch it, so the model pays a small cost to see the summary on the common path, and only pays for the full bytes on the rare call where it needs them. A companion control, diff-only reads, restricts reads and searches to just the files you've changed, exactly what the post-edit verification loop needs.

Verbosity controls: match the answer to the task

Different tasks want different output budgets. A scripted edit should do the work, say “done,” and stop. A deep review wants the full rationale. Forcing one default across both wastes tokens on the short case and starves the long one, so Squeezy lets you set the dial per session.

Response verbosity controls how much the assistant writes back, concise produces short, direct answers; verbose includes fuller rationale. On providers that support it natively this rides on the API with zero extra prompt cost; elsewhere it's a small instruction. The default sits in the middle, so if you never touch it you pay nothing for the feature.

Tool-output verbosity controls how much of a command's output is shown inline in your transcript, compact, normal, or full. This is about what you read, not what the model is billed, but it keeps the transcript scannable; the full output is always one fetch away. Diffs are an exception: they render in full by default, because a diff is only useful when every hunk is visible.

/config or [tui].response_verbosity = "concise" | "normal" | "verbose" sets how much the assistant writes.
Tool-output detail is configured from /config.
Diffs stay full by default, every hunk visible; foldable when they get large.
Session-scoped, changes apply on the next turn.

Subagents: do the wide work somewhere else

Some questions touch a dozen files, “where is auth handled,” “review this whole change.” Done inline, that exploration floods your main conversation with a dozen tool calls and their output, and every later turn re-pays for all of it even though you only needed the conclusion.

Squeezy can push that work into a subagent: a separate, isolated run with its own conversation, its own model, and a toolset scoped to the task, a general worker that can edit and run under your permission policy, or a typed role restricted to reading and searching. The subagent does the digging, reading, searching, reasoning, and returns only a compact summary, plus a short trail of what it relied on, to your main thread. The intermediate dumps and chain of reasoning never enter your main context, so they never get re-sent.

Two savings stack. Your main conversation stays slim, so every later turn re-sends a small summary instead of the whole investigation; and the subagent itself runs lean, advertising only the handful of tools it needs and dropping to the cheaper model tier when one is available. Subagents run in parallel and are kept deliberately flat, one parent, many children, no deeper nesting, so cost stays predictable. The trade-off is clear: isolation pays off when the inline version would bloat every future turn, not for a single grep.