Entroly — Cut AI context cost and prove nothing was lost.

⚡ Live Token Savings

Live metric	Meaning	Source of truth
Tokens saved	Cumulative tokens reduced by the active Entroly workload	Local value ledger plus entroly.proxy.tokens.saved / entroly_proxy_tokens_saved_total
Estimated cost avoided	Modeled USD value of provider-bound input reduction using configured pricing	Local value ledger; provider invoice remains billing truth
Compression tokens saved	Canonical whole-request savings excluding measured tool-schema deferral	entroly.proxy.tokens.compression_saved / entroly_proxy_compression_tokens_saved_total
Tool-schema tokens deferred	Savings from a caller explicitly limiting the active tool set with X-Entroly-Active-Tools	entroly.proxy.tokens.tool_schema_saved / entroly_proxy_tool_schema_tokens_saved_total

Live means measured by Entroly, not a fabricated global number. Exact totals stay in each installation's local Value Receipt. Separately opted-in proxy installations may contribute a conservative community lower bound: every provider-bound delta is rounded down to whole 1,000-token units and whole cents before upload, with no prompt, content, model, price, or exact per-request value. It is not an exact worldwide total or provider invoice. Run entroly value, entroly value --json, or open entroly dashboard for your exact local cumulative totals. For the public-counter contract and proxy metrics, see Live tokenomics and Metrics & Monitoring.

Tool schemas are never hidden by a relevance guess. To opt in for a request, send a comma-separated active set such as X-Entroly-Active-Tools: search_files,read_file. Forced tool choices and unnamed provider tools remain available; an invalid or non-matching set leaves the request unchanged.

---

---

Integration hub

Use Entroly at the SDK, framework, proxy, MCP, plugin or agent boundary. A listed name is not automatically a claim that hosted subscription inference is intercepted; provider-bound savings exist only when the request traverses an Entroly-controlled route.

Direct, tested paths	Guided or bounded paths
Vercel AI SDK middleware · OpenAI SDK · Anthropic SDK	Agno · Strands Agents · CrewAI · AutoGen
LangChain · LiteLLM · MCP	Claude Code on Vertex AI · Claude Code on Azure AI Foundry
OpenClaw · OpenCode	Claude Code in VS Code · VS Code Copilot · Grok

Open the complete verified integration and operations hub →

---

What is Entroly? (in plain English)

AI coding assistants have a memory limit. Hand one your whole codebase and it gets slow, expensive, and distracted — like giving someone a 500-page manual when they only needed page 47.

Entroly finds page 47.

It sits between your code and the AI, reads everything, and passes along only the parts that matter for the question actually being asked. Three things make that safe to do:

💰 Your bill goes down	Fewer words sent to the AI means a smaller invoice. How much depends on the job — see the real numbers below.
🔍 Nothing is lost	Whatever Entroly sets aside is kept and can be pulled back exactly as it was, character for character.
🧾 You can check its work	Every decision comes with a receipt: what was kept, what was left out, and why.
Do I have to change my code? No. Entroly works with the tools you already
use — Claude Code, Cursor, Copilot and 30+ others — and runs in the background.

Do I need to pay for anything to try it? No. The two commands in the Install section below run on your own machine, with no API key, and show you real numbers on your own project before you connect anything paid. (They will install the native engine from PyPI if it is missing — see the note under Install.)

---

Install

Not sure which one? Pick Python. It's the complete version and what most people use. The others are alternate ways to run the same engine. | Platform | Install | What you get | |---|---|---| | 🐍 Python (pip) — recommended | pip install -U entroly | Everything: the command-line tool, the server your AI editor talks to, and the code library | | 📦 Node / npm | npm install -g entroly | The same engine, nothing Python required | | 🦀 Rust (source build) | cd entroly-core && cargo build --release --bin entroly-rs --features proxy | One self-contained program, no Python or Node needed | | 🍺 Homebrew | brew install juyterman1000/entroly/entroly | The command-line tool on macOS/Linux | | 🐳 Docker | docker pull ghcr.io/juyterman1000/entroly:latest | Runs in a container, nothing installed on your machine |

Prefer a package runner instead of a global install? These commands use the same published artifacts in an isolated tool cache:

# Node / WASM runtime
npx -y entroly@latest --help
pnpm dlx entroly@latest --help
bunx entroly@latest --help

# Complete Python runtime
uvx --from entroly entroly --help
pipx run --spec entroly entroly --help

The Node commands provide the local WASM CLI. The Python commands provide the complete CLI, SDK, MCP, proxy, verification, and native-engine path described above. Entroly's release workflow smoke-tests all five runners against the exact version before a release is considered complete.

Now check that it worked — free, no API key:

cd /your/repo
entroly verify-claims
entroly simulate

Both run locally. Neither one calls an AI or costs anything.

One exception to "offline": if the native engine is missing, Entroly installs it from PyPI before measuring, because without it selection cannot read your query and any savings figure would be budget arithmetic rather than a measured result. That is the only outbound call these commands make, it is a package install and nothing about your code leaves the machine, and it does not happen when the engine is already present. Set ENTROLY_NO_SELF_HEAL=1 to disable it — Entroly then reports the figure explicitly labelled as unearned.

Extras (entroly[proxy], entroly[native], entroly[full]), the standalone Rust binary, and uninstall steps: Engine & install options.

Contributing from source? Follow the reproducible development setup. Local installation and the normal test suite need no API key; .env.example documents only optional workspace, offline, provider, and proxy settings.

---

Quickstart — by how you work

Just want it working? pip install -U entroly && entroly go — that's the whole thing. It finds your editor, sets itself up, and shows you a before/after dashboard. The rest of this table is for specific setups. | Your situation | Do this | What it gets you | |---|---|---| | 🟢 "I just want it on." (pip / Python user) | pip install -U entroly && entroly go | Auto-detects your editor, wraps your agent, opens a dashboard showing tokens before and after | | "I use Node, not Python." (npm user) | npm install -g entroly && entroly init | Same engine, nothing Python required | | "I want one binary, no runtime." (Rust user) | cargo build --release --bin entroly-rs --features proxy (from entroly-core/) | A single native program with no dependencies | | "I use Claude Code / Cursor / Windsurf / VS Code." (MCP user) | entroly attach create --client claude --project . --ttl 4h --install (or entroly init for Cursor/VS Code) | Your editor gets compression, receipts, exact recovery, and evidence-backed work continuity as built-in tools — access expires on its own, and you change zero code | | "I'm building my own app in Python." (SDK user) | from entroly import compress, compress_messages, optimize | Call it straight from your code, anywhere you assemble a prompt | | "I have an API key and my own app." (proxy user) | entroly proxy → point ANTHROPIC_BASE_URL / OPENAI_BASE_URL / GOOGLE_GEMINI_BASE_URL at localhost:9377 | Every request gets optimized on the way past — no code changes on your side |

Runaway-session rescue — automatic on the proxy, callable everywhere else. When a long agent session approaches the provider's context limit, bulky tool output is compacted in flight: no manual /compact, the prompt prefix stays byte-stable so your warm provider cache survives, and every omitted span is recoverable. The proxy does it for you because it sees the outbound request. Anywhere else — pip, SDK, a provider-SDK wrapper, or an MCP host that passes its transcript — hand the conversation over and get the same policy: from entroly import rescue_session. entroly capabilities reports which protections apply to how you are running. See session rescue.

Why bother: less unnecessary context reaches the model (lower bill, less distraction for the model), nothing is silently lost (every drop is recoverable and receipted), and you can prove it — entroly verify-claims and entroly simulate show real numbers on your own repo before you connect a paid key.

from entroly import compress, compress_messages, optimize
compressed = compress(api_response, budget=2000)
messages   = compress_messages(messages, budget=30000)
context    = optimize(fragments, budget=8000, query="fix the login bug")

entroly compress response.json --out small.json
entroly recover sha256:0b957c79... --out restored.json

Full setup paths for every agent, IDE, and CI use case: Get started in depth · Command reference.

---

See it work in 30 seconds

Not mocked recordings — each video is rendered from a checked-in command that verifies its source artifact before printing a number.

Full protocols, sample sizes, and every caveat: docs/BENCHMARKS.md.

---

Benchmarks

The question that matters: if you send less, does the AI start getting things wrong? These are standard public tests, run with and without Entroly.

How to read this: Retention is how well the AI still answered — 100% means it did just as well on far less text. Token savings is how much less was sent (and therefore paid for). Measured with gpt-4o-mini; intervals are Wilson 95% CIs.

Benchmark	Baseline	With Entroly	Retention	Token savings
NeedleInAHaystack	100%	100%	100%	99.5%
LongBench (HotpotQA)	64%	66%	103%	85.3%
Berkeley Function Calling	100%	100%	100%	79.3%
SQuAD 2.0	80%	72%	90%	43.8%
GSM8K	85%	85%	100%	pass-through*
*pass-through: context already fit the budget, left unchanged. n=20–50 per row. Reproduce: python benchmarks/run_readme_benchmarks.py (needs OPENAI_API_KEY).

Being straight with you: look at the SQuAD 2.0 row — accuracy went down (80% → 72%). Compression is a trade, not magic, and it doesn't win everywhere. That's why entroly simulate exists: run it on your own project and see your own numbers before you commit to anything.

Hallucination detection (WITNESS, local, no API): 84.92% accuracy / 0.7976 AUROC on 20,000 HaluEval-QA decisions — within the reported uncertainty of gpt-4o-mini as an API judge on the same shared sample.

Frozen evidence-selection benchmark (opt-in PRISM-R research prototype, not the default compressor): a disagreement guard kept the answer-bearing passage in 298 of 300 cases while selecting an average of 1.02 of 16 passages (paired exact McNemar p=0.21875 vs. BM25 alone) — this experiment measures retrieval of the known-answer passage, not generated-answer quality. Full protocol: PRISM-R neural evidence frontier.

Recovery, latency, and head-to-head frontier results are in docs/BENCHMARKS.md with raw artifacts linked. None of these numbers are a universal or production-savings guarantee for your workload — reproduce them on your own repo with entroly simulate and entroly value.

---

Features

• Picks first, shrinks second — it works out which files actually answer your question, then compresses them.
• Gives you the original back, exactly — anything left out can be restored character-for-character and checked against a fingerprint.
• Shows its work — a receipt for every decision: what was kept, what was left out and why, and what risk remains.
• Fact-checks answers — compares what the AI said against the evidence it was given, on your machine, without paying for a second AI call.
• Doesn't wreck your caching — keeps the unchanging parts of your prompt stable so your provider's discount for repeated text still applies.
• Rescues sessions before they crash — when a conversation grows too big, it trims recoverable output instead of letting the provider reject the request mid-task.
• Can route cheap work to cheap models — optional and fail-closed when uncertain.

Runs as a CLI, Python/TypeScript SDK, MCP server, HTTP proxy, or library import. Full surface map: docs/product-surface.md. Architecture and Rust internals: docs/DETAILS.md.

---

Works with your stack

Agent / platform	Path	Status
Claude Code	Scoped MCP attachment; API-key proxy	Native
Codex CLI	Scoped MCP attachment; API-key proxy	Native
OpenClaw	Context-engine plugin + scoped MCP	Native
Cursor / Windsurf / VS Code	Automatic MCP config	Automatic
GitHub Copilot CLI	MCP (subscription) / proxy (BYOK)	Supported
Cortex Code	SDK/library boundary only	Not validated as a wrap target
Aider, OpenCode, and 30+ more	Session-scoped OpenAI-compatible proxy	One command

Status describes integration depth, not a savings guarantee — provider-observed savings require requests to actually traverse an Entroly proxy route. Entroly does not claim interception of GitHub-hosted subscription inference on Copilot's native path. Full compatibility matrix: docs/agent-compatibility.md.

Current model support

Entroly carries verified public metadata for GPT-5.6 Sol, Terra, and Luna; Gemini 3.6 Flash; and Gemini 3.5 Flash-Lite, and it can discover installed NVIDIA Nemotron 3.5 Lightning Ollama tags. Gated or private-preview announcements are not promoted into the verified matrix without a usable public model ID and limits. For example, Gemini 3.5 Flash Cyber remains outside the generally available matrix because its documented CodeMender access is restricted to selected governments and trusted partners. See Verified model support for model IDs, transport paths, limits, and availability boundaries.

Why does my AI coding agent miss files in a large codebase?

Because something decided which files it was allowed to see, and that decision is usually invisible. A codebase is larger than any context window, so a tool picks what fits — and if it assumes a smaller window than your model actually has, it drops evidence that would have fitted. The agent then says "I don't see where that is handled", and it reads like a model failure when it was a budgeting one.

Entroly makes that decision explicit: it records each model's published limits so it fills the window you are paying for, and every fragment it drops appears in a receipt with the reason. On a 1.67M-token codebase, knowing the real limit is the difference between carrying 7% and 52% of the repository as evidence in one request.

GPT-6 Astra and Muse Spark 1.3

Does Entroly support GPT-6 Astra? Yes. Entroly fills up to 869,500 tokens on GPT-6 Astra (openai/gpt-6-astra) and 865,076 on Muse Spark 1.3 (meta/muse-spark-1.3), instead of the 121,600-token default it applies to models it cannot identify. Both work through the proxy, MCP, plugin, and SDK paths with Claude Code, Codex, Cursor, and OpenAI-compatible apps — no separate configuration.

Model	Model ID	Context window	Max output	Tokens Entroly will fill
GPT-6 Astra	openai/gpt-6-astra	1,050,000	128,000	869,500
Muse Spark 1.3	meta/muse-spark-1.3	1,048,576	131,072	865,076
Muse Spark 1.3 Contributor	meta/muse-spark-1.3-contributor	1,048,576	131,072	865,076

Why this matters: when a context tool does not know a model's real limit, it assumes a small one and compresses harder than it needs to. Evidence gets dropped that would have fitted. Your agent then answers "I don't see where that is handled" — not because the model ran out of room, but because the tool guessed the room was smaller. Entroly records each model's published limits so that never happens silently, and every dropped fragment still appears in the receipt with the reason it was dropped.

What it does not do: this does not make requests cheaper — long-context requests cost what the provider charges. It removes an artificial ceiling on evidence, so hard questions can draw on more of the codebase when they need to. Entroly reserves output tokens plus an uncertainty margin, which is why the usable figure sits below the raw window.