Cut your AI token bill, without changing a thing
A drop-in proxy that compiles every prompt before it reaches the model: it removes the repeated content your app re-sends each turn, so you pay for fewer tokens and get the same answers. Lossless, accuracy-verified, and fast enough that you'll never notice it.
Honest about what this is: and isn't
No codec can shrink the tokens a model actually reads, that's fixed by the tokenizer. So we don't compress your bytes; we stop you re-sending the same thing. On unique prose or one-off code there's little to remove and we'll save you little, and we'll tell you so. The big wins are on the repetitive traffic that dominates real agent and chat workloads.
How it works
It removes repetition, not meaning
Coding agents and chat apps re-send the same system prompt, tool definitions, files and images on every turn. The compiler sends each one once and references it after, the model still receives every byte of information, just not three copies of it.
Lossless, and proven not to change answers
The transform is byte-reversible, and we verified on two independent models that the model answers exactly as well over a compiled prompt as over the original. Optional deeper (lossy) modes exist for images and templated data, off by default, each clearly flagged.
Drop-in, invisible
Point your app at the AT-1 endpoint instead of the provider's, one line. Works with the OpenAI and Anthropic APIs, your existing SDKs, and coding agents, with no change to how your team works.
PDFs and images, handled right
PDFs are routed to their cheap text layer and their repeated page furniture is removed; identical images are de-duplicated. A lossless image re-encode saves nothing, token cost is set by resolution, so we don't pretend otherwise.
How you pay
We meter the tokens we remove from every request and bill a fraction of the money that saves you (you keep the large majority). No savings, no charge, so it can never cost you more than it saves. A free tier covers your first block of saved tokens each month, and high-volume teams can switch to a flat per-seat plan.
Turn it off anytime
No lock-in, ever, it's always one step to switch off or remove:
- Skip a single request, add the header
X-AT1-Compile: offand that one call is sent through untouched. - Pause everything, set
AT1_PROMPTC_DISABLE=1and the proxy becomes an invisible pass-through, exactly like calling the AI provider directly. No redeploy. Unset it to turn back on. - Uninstall completely, point your app's endpoint back at the provider (it was only a one-line change), or stop the service /
npm uninstall. Your requests go straight to the model again, and we keep nothing of yours.
Common questions
- Can you compress an LLM prompt without changing the model's output?
- Yes, if the compression is lossless. Most published prompt-compression methods drop or paraphrase low-information tokens, which shrinks the prompt but can change the answer, they are typically reported with a small accuracy loss. AT-1's Prompt Compiler instead removes only repetition: the system prompt, tool definitions, files and images that get re-sent on every turn are sent once and referenced afterwards. The model still receives every byte of information, just not three copies of it, so the output is unchanged.
- Is prompt compression lossy or lossless?
- Both exist, and the difference matters. Token-dropping and summarisation methods are lossy: they decide which tokens the model can do without. A lossless method is byte-reversible, the original prompt can be reconstructed exactly. AT-1's default mode is lossless and byte-reversible, and was accuracy-verified on two independent models. Optional deeper lossy modes exist for images and templated data; they are off by default and each is clearly flagged.
- How much can you cut LLM token costs without losing quality?
- Measured with tiktoken cl100k_base: up to 62% fewer tokens on repeated chat context, about 5.5x cheaper on PDFs by routing the text layer instead of page images, and 50% saved when the same image is attached twice. The saving comes from repetition, so it is largest for coding agents and multi-turn chat and smallest for one-shot prose, on unique prose there is little repetition to remove and the honest answer is close to zero.
- What is the alternative to lossy prompt compression like LLMLingua?
- A lossless, repetition-removing proxy. Rather than deciding which tokens the model can survive without, it de-duplicates content the model has already been sent in the same session and references it instead. This gives a smaller ceiling than aggressive lossy compression but carries no accuracy risk, which is the trade regulated and production workloads generally want.
- Does prompt compression add latency or require changing my code?
- It adds under 1 millisecond and takes one line to adopt: point your app at the AT-1 endpoint instead of the provider's. It works with the OpenAI and Anthropic APIs, existing SDKs and coding agents. It is also one step to reverse, a header disables a single request, an environment variable makes the proxy an invisible pass-through, and removing it is just pointing the endpoint back.
What it saved, and where it saved nothing
The saving comes entirely from repetition. A long conversation resends the same context on every turn, and that is the part worth removing. Where a prompt is novel text, there is nothing to remove and the honest number is zero.
| Prompt shape | Tokens removed |
|---|---|
| Multi-turn conversation, context resent each turn | 32% |
| One file pasted again in a later turn | 8% |
| The same image attached three times | 50%, charged once |
| Prose | 0% |
| JSON payloads | 0% |
| Unique code | 0% |
The three zeros are the useful rows. If your traffic is mostly single-shot prose or novel code, this will not pay for itself and you should not install it. Point it at an agent loop or a chat product where the same context rides along on every call, and it will.
Nothing is summarised or paraphrased. Repeated content is replaced with a reference and put back before the model sees it, so the prompt the model receives is the prompt you wrote.