Lean any prompt — protected structure, fewer tokens.
Paste any prompt. FrootAI removes redundant wording while preserving detected guardrails, code, URLs, flags, and numeric constraints. Prompts with removable verbosity commonly save 11–35% of tokens; already-lean prompts may remain unchanged.
Lean your own prompt
Paste a prompt, agent, or instruction. FrootAI returns a leaner version — the same detected guardrails, parameters, code, and numeric constraints preserved exactly. Counts disclose their tokenizer basis in the result receipt.
Lean API
The playground above is the website experience. Sign in to create a personal fai_live_… key for the authenticated, versioned endpoint. Every signed-in account receives 20 API calls free, with exact token receipts and atomic account-level quota accounting.
Two candidates, protected-byte restoration, then conservative requirement-equivalence judging.
Set mode to lossless for deterministic whitespace compaction without a model call.
Rejected candidates fall back to lossless output; the receipt states the served flavor and verification result.
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.
Protected structure
Detected guardrails, parameters, code blocks, headings, flags, URLs, and numbers are checked byte-for-byte. A missing protected unit rejects the candidate.
Fewer tokens
FrootAI asks for tighter explanatory prose and serves it only when canonical token count falls. Tight inputs commonly fall back unchanged; every response identifies what was actually served.
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 follow the amount of removable prose, not a universal quota. Every request reports its measured before/after count and tokenizer basis. The ranges below describe observed cohorts, not an SLA.
The default example contains realistic repetition so the saving remains visible without assuming a universal result. Tight production instructions often have less removable text; that is expected. Every semantic result must pass protected-byte restoration and conservative requirement-equivalence judging. That is strong evidence, not mathematical proof of universal semantic equivalence.
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.