Report by The Next New Thing.
Scroll for the report ↓
Give it your free API keys from a pile of different AI providers and it presents them as a single service. A router picks a model for each request and moves to the next provider when one runs out.
View on GitHub →The project totals roughly 7.4 billion tokens a month across 34 providers and 635 free model endpoints, all behind one OpenAI-compatible URL.
Keys are stored encrypted, usage is tracked per key so you stay under each free cap, and a rate-limited provider hands off to the next one.
The repo describes it as for personal experimentation. Stacking free tiers this way can run against individual providers' own terms.
Free tiers from 34 providers are stacked behind one OpenAI-compatible endpoint, roughly 7.4 billion tokens a month.
Usage is tracked per key. When one provider rate-limits, the router moves the request to the next one.
Self-host with Docker or the desktop app. Keys are stored encrypted locally rather than on someone else's server.
The author's own words. Stacking free tiers can breach a provider's terms, and that risk is yours, not the tool's.
New models reach the free catalog a month after the $19-a-year feed, and free models vanish when providers end their tiers.
Instead of replacing your whole conversation with one generic recap, it condenses each of the assistant's old turns separately and leaves your own words untouched, so the agent still knows what it did and why.
View on GitHub →Built-in compaction flattens everything into one summary blob. This keeps user messages verbatim and summarizes only the old assistant turns around them.
Bulky finished tool calls become a short omission notice with an ID. The agent calls read_omitted_content to pull the original back when it needs it.
The author paused work in favor of Operator Memory, which will absorb context management. Magic Compact still installs and runs today.
Each earlier turn is condensed on its own instead of the whole session being replaced by one recap, so the reasoning survives.
Finished tool calls are replaced with an omission notice. The original is cached and the agent can fetch it back by ID.
Compaction happens once, on your command, not in the middle of the loop, so prompt caches are invalidated as little as possible.
The author has moved on to Operator Memory. It still works today, but do not expect fixes or new features here.
It cannot edit the live session, so it writes a new compacted one you /resume into. The stats command is OpenCode-only.
Think of it as a filter sitting between your agent and the AI. Logs, files and tool output get squeezed down on your own machine first, so the model gets the same meaning in far fewer tokens.
View on GitHub →Use it as a Python or TypeScript library, as a local proxy with no code changes, as an MCP server, or wrap an existing agent with one command.
A router detects what it is looking at and picks a compressor built for that type: one for JSON, one for source code, one for ordinary prose.
Compression runs locally and nothing is sent away to be compressed. Full versions are cached so the model can ask for one back.
Tool output, logs, files and RAG chunks are compressed locally. The README claims about 20% for coding agents, 60-95% for JSON.
JSON, source code and prose each get their own squeezer, chosen automatically by a router that detects what it is looking at.
Full versions are cached on your machine and the model can pull one back with headroom_retrieve when it needs the detail.
The 60-95% numbers are for JSON. If your context is mostly conversation and code, expect the small end of the range.
Library, proxy, wrap, MCP server, cross-agent memory and a learn command. More to configure than the single-purpose tools here.
Help your users connect the software you build to the apps they need.
zapier.com/sdkAn image costs the same number of tokens no matter how much text is crammed into it. This quietly renders the bulky parts of each request into a dense page of pixels before it leaves your computer.
View on GitHub →Code, JSON and tool output fit roughly 3.1 characters per image token against about 1 per text token, measured on real Claude Code traffic.
Run the proxy with npx pxpipe-proxy, then point Claude Code at it. A local dashboard shows tokens saved and every conversion side by side.
Exact hex strings were read 13 of 15 times on one model and 0 of 15 on another, and misses are silent. Recent turns deliberately stay as text.
An image's token cost depends on its pixel size, not what is in it, so dense text packs about three times tighter.
System prompt, tool docs and old history are rendered to PNG. Recent turns stay as text so the model can still copy exact values.
Every conversion is checked against a free count_tokens call and logged, so the savings you see are real ones.
Exact hex strings were read 0 of 15 times on one model. IDs, hashes and secrets must stay as text or they get confabulated.
On sparse prose it can cost more than it saves. A profitability gate decides per request, but the win is workload-dependent.
It helps you spend less on prompts without touching your code. You swap the line that imports OpenAI for its version, and it compresses the parts of each request that can survive being shortened.
View on GitHub →Code, stack traces and JSON pass through byte for byte. Documentation, logs and old turns get compressed. That routing is the whole idea.
The compression model runs on your own hardware under an MIT license, so prompts and user data never leave your infrastructure by default.
On 503 LongBench v2 questions it removed an extra 18.7% of tokens for 1.8 points of accuracy, with per-item records committed to the repo.
Code, stack traces, JSON and tool IDs pass through untouched. Docs, logs and old turns go through LLMLingua-2.
from leanctx import OpenAI replaces the client with the same interface and compressed requests. No other code changes.
The compression model is local and MIT-licensed, and makes no outbound calls except to the provider you already use.
1.8 points overall on LongBench v2, and 3.9 on the segments it actually compressed. Small, but not zero.
The LLMLingua-2 weights are big. Without them installed, leanctx quietly falls back to passing everything through.
When your agent reaches for a huge file it has already read, this refuses the request and hands back only what changed. It also remembers what the agent worked out, so it does not re-derive the same thing next session.
View on GitHub →Reads of very large files are denied outright, with the refusal naming the cached replacement. The same applies to Grep, Glob, Edit and shell commands.
Findings, decisions and dead ends accumulate as the agent works and come back when it touches the relevant file. No account, no telemetry, no hosted service.
A local dashboard separates verified savings from modeled ones and attributes traffic per client, so Codex, Claude Code and Gemini get separate rows.
A Read of a 200 KB file is denied, and the refusal names the cached, diffed replacement. Same for Grep, Glob, cat and grep -r.
A file you already read this session comes back as a diff. The README calls this the single biggest win.
Findings cost about 150 tokens to carry forward versus 5k-50k to work out again next session.
Denying Read, Grep and Edit is the whole mechanism. That is a lot of control to hand a plugin, and there is no off switch.
The dashboard separates verified from modeled savings honestly, which also means part of the headline is an estimate.
You can use it to stop tool results from ever landing in the conversation. Big dumps get held outside and indexed, the agent searches them, and only the matching lines come back.
View on GitHub →The project reports 315 KB of raw data becoming 5.4 KB, a 98% reduction, by keeping the bulk outside the context window.
File edits, git operations, tasks and errors go into SQLite, then get searched and returned selectively instead of dumped back in.
It ships under the Elastic License 2.0, which restricts offering it as a managed service. Fine for your own work, worth reading before commercial use.
Raw data is sandboxed and indexed with full-text search. Only matching lines come back. The README claims a 98% reduction.
Edits, git operations, tasks and errors go into SQLite and return through search instead of being dumped back into context.
Routing rules are applied through MCP plus hooks across 17 platforms, so the agent cannot quietly skip them.
Free to use, but not open source. You cannot offer it as a managed service. Read the license before commercial use.
The README's Microsoft, Google and Meta badges link to nothing. Judge it on the code, not the logos.
Think of it as a jaded senior developer sitting inside your agent. You ask for a date picker and, instead of installing a library and wrapping it, it reaches for the one browsers already have.
View on GitHub →Twelve feature tickets on a real FastAPI and React codebase, the same agent with and without the skill, scored on the diff it leaves behind.
That is the mean across those tasks. It reaches 94% where an agent over-builds and close to zero where the code was already minimal.
An earlier benchmark advertised a flat 80-94%. Against a fairer baseline he republished that as the per-task ceiling, not the average.
It is a skill, not a proxy. It pushes the agent to reuse what exists instead of building. Less code out, less to read back in.
About 54% less code and 22% fewer tokens across 12 tasks on a FastAPI + React codebase, versus the same agent with no skill.
Installs into Claude Code, Cursor, Codex and others as a skill or plugin. Nothing sits between you and the model.
54% less code, but only about 22% fewer tokens and 20% cheaper. The real win is code you never maintain.
The gains come from stopping over-building. If your agent is already terse, there is little left to cut.
You can use it to turn a project into a map your agent asks questions of. Instead of opening file after file to work out how two things connect, it traces the path between them.
View on GitHub →Source is parsed into a syntax tree by tree-sitter. It is deterministic and nothing leaves your machine; docs and PDFs get a separate semantic pass.
Connections are tagged EXTRACTED when they were explicit in the source or INFERRED when graphify worked them out, so you can tell them apart.
No embeddings and no vector store. You traverse real relationships, trace a path between two things, or ask it to explain one concept.
One graph traversal replaces opening ten files to work out how two things connect, which is where a lot of context goes.
tree-sitter parses the syntax tree locally and deterministically, so mapping the code itself costs zero tokens.
EXTRACTED means it was explicit in the source. INFERRED means graphify worked it out. You can tell which is which.
Only code is free. The semantic pass for docs, images and video runs through your assistant's model or an API key.
Y Combinator S26, with a paid platform in early access. Watch which features stay in the open-source skill.
Give it your accounts across a lot of AI providers and it becomes one local address your coding tools point at. When a provider runs out or fails, the next one picks the request up.
View on GitHub →Twelve engines run in order before a request leaves. The default pair is claimed at 78-95% on mixed prompts and tool logs.
Thirteen entries are marked avoid in its own terms-risk catalog, leaving the decision about a provider's rules to you.
The catalog is re-audited every two weeks and totals move both ways. Its README and GitHub description currently disagree on the provider count.
RTK then Caveman by default; LLMLingua-2 and image encoding are opt-in. Claimed 78-95% on mixed prompts and tool logs.
Four-tier fallback: subscription, then API key, then cheap, then free. Around 1.47 billion free tokens a month cataloged.
Claude Code, Cursor, Codex and Cline all point at localhost:20128 and share the same routing and compression.
Its own terms-risk catalog flags them. The call on a provider's rules is yours, not the router's.
356 providers, 19 routing strategies, an 86-command CLI, MCP, A2A and memory. Setup is not a two-minute job.