A terminal coding agent
squeezy inspects code, edits files, runs commands, plans work, and resumes sessions, all from your terminal and all tied to local evidence.
what does squeezy actually do?
Knowledge database 40+ languages · your repo, indexed locally and queryable · callers, definitions, exact file:line
Route cheapest capable model · simple turns run cheap, hard ones escalate · pin with /router cheap or /router main
Shape errors kept, filler dropped · output shaping for 200+ developer commands · the full log stays one fetch away
Receipt never pay twice · a repeated read returns a pointer, not the bytes again · stable context rides the provider cache
Subagent isolated context · explores in its own thread, hands back only the summary
Compact long sessions stay bounded · older turns fold reversibly, so turn 30 never re-buys turns 1 to 29 · stale bytes trim out mid-turn
Ledger every saving itemized · what you didn't spend, in provider USD, labeled by confidence · squeezy savings exports the report
60% of what another coding agent spent for the same answers · 15 languages, same model and the same grader on both sides
measured
so what changes on my bill?
at a glance
Languages & formats 40+ with local code understanding
Cost saving strategies 30+ across four saving layers
Providers 27 from cloud APIs to local runtimes
Platforms 3 macOS, Linux, Windows
the ratio is one published benchmark · the counts below are what ships
what it is
A full coding agent that costs less to run.
Everything you expect from a terminal coding agent: it reads code, edits files, runs commands, and verifies the result. Underneath sits the part that does the saving. squeezy indexes your repository on your machine, across 40+ languages and formats, so "who calls this?" is one query rather than a dozen file reads. A simple turn is routed to a cheaper model you configure, and steps back up when the work turns hard. Noisy command output is cut to its errors and its summary, for 200+ developer commands. And a savings ledger itemizes what each of those kept off the bill.
It reads your codebase
A local knowledge database across 40+ languages and formats maps your symbols, references, and call paths, so squeezy navigates your code's structure instead of guessing from text.
Your model, your machine, your rules
Bring your key for any of 27 providers, keep the work on your machine, and gate edits, shell, and web access behind permissions you set.
a coding agent first · the saving is how it is built, not a mode you switch on
how the saving happens
30+ cost saving strategies.
They group into four layers. Understanding your code locally is the first, not the whole story: it works alongside reusing stable context, right-sizing every turn, and giving you control of the bill.
01
Understand the code first
Before spending a token, squeezy reads your repository locally and works out which files and lines matter.
local code understandingcode knowledge database
02 Don't pay for the same bytes twice
Most of a coding session repeats: the same instructions, the same files, the same command output. squeezy keeps that out of the bill.
prompt cachingreceiptsdeferred tool schemasstale bytes
03 Right-size every turn
Not every turn deserves the biggest model or the longest history. squeezy matches the effort and the context to the task in front of it.
routingcompactionshaped outputsubagents
04 Control the bill, don't just watch it
Seeing where the tokens go only helps if you can act on it. squeezy turns the numbers into control: cap the spend, force a turn cheaper or stronger, and see exactly where it all went.
spend capmodel overridevisibility
four saving layers · they stack on a single turn
when it adds up
Token bills grow one turn at a time. So do savings.
Each strategy works on a single turn, and that is why it matters at scale: the same waste repeats across every session, every day. squeezy trims it before the request is sent, then books what it saved to a local ledger you can read and export, so the saving is a number you can check rather than a feeling.
Savings scale with usage
Re-read files, re-sent history, oversized output: the same waste repeats in almost every turn, and squeezy trims it every time. The saving grows with every session, every seat, every day.
A bill you can explain
Every mechanism that can be measured books its saving to the savings ledger, labeled by how it was derived, and exports a report. A guard that stops waste instead of shrinking a payload has no byte figure to book, and the ledger says so rather than inventing one. What was spent and what wasn't are both on the record.
The analysis runs on your machine
Reading and indexing your repository happens locally. The code that reaches a model is what the prepared request carries to the provider you configured, and edits, shell commands, and web access stay behind permissions you set.
the same waste repeats every turn · so does the trim
get started
Bring your own model. Start in two commands.
Run squeezy against 27 providers: first-party APIs, aggregators, cloud platforms, local runtimes, or any OpenAI-compatible endpoint. Bring an API key, your cloud's own credentials, or a Claude, ChatGPT, or GitHub Copilot subscription. Reading and indexing your repository happens on your machine, before the call.
bring your own model · the analysis runs on your machine