Lean any prompt — same capability, fewer tokens.
Paste any prompt and FrootAI's semantic compression trims the bloat — typically 25–45% fewer tokens — while preserving every guardrail, parameter, and line of code exactly. Same behaviour, lighter context, lower cost.
Lean your own prompt
Paste a prompt, agent, or instruction. FrootAI returns a leaner version — the same instructions, fewer tokens, with code, parameters, and guardrails preserved exactly. Counts are exact o200k_base.
How it works
The compressor above rewrites your prompt live. Behind it, every FrootAI primitive also ships pre-leaned and fidelity-gated — measured exactly with the real tokenizer, never inflated.
Identical capability
Every guardrail, parameter, and code block is kept exactly — MUST/NEVER rules, defaults, and identifiers are copied byte-for-byte. Nothing that changes behaviour is ever removed.
Fewer tokens
FrootAI rewrites redundant prose, filler, and restated context into tighter phrasing — typically 25–50% fewer tokens on a bloated prompt, and near-zero on one that's already lean. Every count is exact, never inflated.
A receipt, not a promise
We publish the exact catalogue-wide totals — the honest measured saving, not a marketing headline. Every figure is reproducible from the committed catalog.
Savings depend on how much redundancy your prompt carries. FrootAI never pads a number — a tight prompt is left almost untouched, a bloated one is reclaimed hard. Measured with the exact o200k_base tokenizer on every request:
Every result preserves code, parameters, and MUST/NEVER guardrails byte-for-byte. The live tool above is the real benchmark — each result is computed exactly, in front of you.
The catalog benchmarkpre-leaned primitives · fidelity · cost
Separate from the live compressor above: these are the catalog's own pre-leaned primitives, compiled losslessly (whitespace and dead lines only), so the per-type saving is small by design. Each figure is the exact o200k_base count — the honest catalog footprint, never inflated.
Fidelity distribution
Every shipped Low-Calorie variant must clear the fidelity gate — guardrails, parameters, and code blocks preserved exactly. The bar at 10/10 is full because nothing ships below it.
Savings by primitive type
| Type | Compiled / total | Full tok | Low-Calorie tok | Saved | Saved % | Fidelity |
|---|---|---|---|---|---|---|
| Skills | 638 / 638 | 882,159 | 876,777 | −5,382 | −0.61% | 10/10 |
| Agents | 238 / 238 | 284,437 | 283,371 | −1,066 | −0.37% | 10/10 |
| Instructions | 176 / 176 | 336,672 | 334,845 | −1,827 | −0.54% | 10/10 |
| Hooks | 11 / 11 | 15,053 | 14,880 | −173 | −1.15% | 10/10 |
| Ecosystem | 1,063 / 1,063 | 1,518,321 | 1,509,873 | −8,448 | −0.56% | 10/10 |
What it costs you
Plug in your model's input price to see the catalogue's token cost — and what Low-Calorie trims off each full load. Figures come straight from the measured token counts above.
Honest math: the saving is savedTokens ÷ 1,000,000 × price × loads. It is small because today's Lean compiler is lossless — the dollars scale only with how often you load the full catalog. Presets are examples; enter your model's real input price.
How we measure
Every count is the exact o200k_base token count (the GPT-4o / GPT-4.1 vocabulary) — the same tokenizer the model sees. We never estimate from characters or bytes, which over- or under-counts depending on content.
A primitive's Full count is tokensLean + savedTokens — the exact pair the fidelity gate compared. We deliberately avoid mixing measurement bases, so a saving can never be inflated by a field measured a different way.
The compiler is deterministic and byte-faithful: whitespace, verbosity and duplication are reclaimed; nothing that changes behaviour is touched. That is why the savings are exact and modest by design, not a headline.
A Low-Calorie variant only ships if it preserves guardrails, parameters, and code blocks exactly — scored 10/10. Anything that loses meaning is served Full and counts as zero saving here, never a hidden win.
The numbers above are computed at build time from the published catalog by the same tested aggregator our CI pins — so this page can never disagree with the gate.
Why you can trust itvs the others · the fidelity moat
Lean vs the others
Everything can make a prompt shorter. Only one approach makes it shorter without giving up fidelity. Here’s the honest trade-off against the usual ways to fit more into the window.
Truncate
· the blunt cutChop the text when the window fills up.
Saves: As much as you want — just cut more.
Costs you: Loses whatever fell off the end: guardrails, parameters, the second half of a code block. Crude and silent.
Summarize
· the lossy rewriteAsk a model to rewrite the text into a shorter summary.
Saves: A lot — often 50%+.
Costs you: Paraphrases. Exact guardrails and parameters get reworded or dropped, it can hallucinate, and nothing verifies the result still means the same thing.
Buy more context
· the bigger billSkip compression — pay for a bigger window.
Saves: Nothing. You just move the ceiling up.
Costs you: No fidelity loss, but every token still costs money and every load is heavier than it needs to be.
FAI Lean
· fidelity-guarded compressionReclaim redundant prose semantically — while copying every guardrail, parameter, and code block byte-for-byte.
Saves: Real: typically 25–45% on a bloated prompt, near-zero on one that's already tight.
Costs you: Nothing that changes behaviour. Every result is measured exactly (o200k_base) and fidelity-checked before it's served.
Lean is the only row that loses nothingthat changes behaviour — real token savings with guardrails, parameters, and code preserved exactly.
Why you can trust the savings
Anyone can make a payload smaller. The hard part is making it smaller without changing what it means. Every Lean variant has to clear a fidelity gate before it ships — if it loses anything a model relies on, it doesn’t ship.
Guardrails preserved
Every guardrail line in the Full source survives into the Lean variant, verbatim. Lean can never quietly relax a safety rule.
Parameters preserved
Named parameters, defaults, and enums are kept exactly. The model gets the same instructions to act on — just with the redundant prose reclaimed.
Code blocks preserved
Fenced code is never reflowed or trimmed inside the fence. What compiles in Full compiles identically in Lean.
The distribution is flat on purpose: a Lean variant that drops a guardrail, parameter, or code block never makes it into the catalogue. That’s the moat — real savings, verified.
Catalog coverage & integrityper-category, measured
How much of each catalog ships a fidelity-gated Lean variant today — and what didn't clear the gate. Every number is exact o200k_base, never inflated.
agents
Catalog data integrity
Every hasLean entry carries its leanPath, a measured tokensLean and a fidelity score — the receipt the website serves against.
Fidelity distribution
Full-only — what didn't clear the gate
None — every agent has a fidelity-gated Lean variant.
skills
Catalog data integrity
Every hasLean entry carries its leanPath, a measured tokensLean and a fidelity score — the receipt the website serves against.
Fidelity distribution
Full-only — what didn't clear the gate
None — every skill has a fidelity-gated Lean variant.
instructions
Catalog data integrity
Every hasLean entry carries its leanPath, a measured tokensLean and a fidelity score — the receipt the website serves against.
Fidelity distribution
Full-only — what didn't clear the gate
None — every instruction has a fidelity-gated Lean variant.
hooks
Catalog data integrity
Every hasLean entry carries its leanPath, a measured tokensLean and a fidelity score — the receipt the website serves against.
Fidelity distribution
Full-only — what didn't clear the gate
None — every hook has a fidelity-gated Lean variant.