Receipt-backed selection records: what was kept, what was omitted, and the handle that recovers the exact original bytes.
Compression you can undo, on your own repository, in one command — without replacing your model or agent architecture.
pip install -U entroly · entroly verify-claims · entroly simulate
Entroly is an open-source, local-first AI token-efficiency and Context Assurance layer: budgeted evidence selection, recoverable context compression, content-addressed evidence recovery, and auditable receipts. Works through VS Code, Claude Code, Cursor, Codex, OpenClaw, GitHub Copilot, Aider, and OpenAI/Anthropic-compatible apps.
English · 简体中文 · 繁體中文 · 日本語 · 한국어 · Español · हिन्दी · Français · Deutsch · Português · Italiano · Türkçe · Tiếng Việt · Bahasa Indonesia · Polski · Nederlands · ไทย · Svenska · Čeština · Tagalog · Română
What is it? · Install · Quickstart · Benchmarks · Questions · Contribute
--- ## What is Entroly? (in plain English) Entroly is a local-first context control plane for AI coding tools. It selects evidence within a token budget, preserves recoverable omissions, and records selection decisions in receipts. Three properties to evaluate on your task: | | | |---|---| | 💰 **Avoidable input cost** | Smaller requests can reduce input cost when they reach a provider through an Entroly-controlled route. The result depends on the workload and provider cache — see the [real numbers](#benchmarks) below. | | 🔍 **Recoverable originals** | Receipt-backed recovery retains source material locally. Exact recovery requires the referenced store and source bytes to remain available; it does not guarantee answer quality. | | 🧾 **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. On hosts with a verified prompt hook, Entroly runs before the model plans. MCP-only integrations remain callable tools that an agent may skip; API traffic is intercepted only when it is routed through the Entroly proxy. Check `entroly activation status --json` instead of assuming an installed integration is active. **Do I need to pay for anything to try it?** No. The two commands in the [Install](#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. (Missing native-engine support is reported without downloading packages — see the note under [Install](#install).) **Switching coding agents mid-task?** `entroly-work resume` reconstructs unfinished work from durable repository evidence, even if the previous agent left no handoff. The receiving agent must review the inferred state and acknowledge it before claiming work through Entroly. Start with [`entroly-work --project . --json resume --to-agent codex`](docs/agent-continuity.md); the [agent continuity guide](docs/agent-continuity.md) shows the complete flow and how to measure whether it actually saves rediscovery work on your tasks. --- ## Contributing Start with [development setup and repository layout](CONTRIBUTING.md), then follow the [architecture](docs/architecture.md), [style guide](docs/STYLE_GUIDE.md), and [test instructions](CONTRIBUTING.md#run-the-relevant-checks) for the surface being changed. Source, delivery adapters, and benchmark evidence have different review requirements; the contributor guide explains their boundaries. ## Install > **Not sure which one?** Pick **Python**. It's the complete version and what > most people use. The other packages expose different runtime surfaces. | 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` | Local Node/WASM CLI; the Python package has a broader CLI, SDK, and proxy surface | | 🦀 **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: ```bash # Node or Bun / WASM runtime npx -y entroly@latest --help pnpm dlx entroly@latest --help bunx --bun 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:** ```bash cd /your/repo entroly verify-claims entroly simulate ``` Both run locally. Neither calls an AI or proves answer quality, activation, or a lower provider bill. Use a task-specific `--query` with `simulate`; if it reports **Relevance ranking is OFF**, run `entroly doctor` before evaluating the selection. Runtime package repair is **off by default**. If the native engine is missing, query-conditioned selection is unavailable and reduction figures are labelled unearned. Install it explicitly with `python -m pip install -U entroly-core`, call `entroly.repair()` from Python, or set `ENTROLY_ENABLE_SELF_HEAL=1` to permit startup repair. This downloads through the configured package index (normally PyPI). `ENTROLY_NO_SELF_HEAL=1` and `ENTROLY_AIR_GAP=1` override repair consent. See [Privacy](PRIVACY.md) and [recovery-data security](docs/recovery-data-security.md). Extras (`entroly[proxy]`, `entroly[native]`, `entroly[full]`), the standalone Rust binary, and uninstall steps: [Engine & install options](docs/DETAILS.md#engine--install-options). Contributing from source? Follow the reproducible [development setup](CONTRIBUTING.md#development-setup). Local installation and the normal test suite need no API key; [`.env.example`](.env.example) documents only optional workspace, offline, provider, and proxy settings. --- ## Quickstart — by how you work > **Start with the [local check](#install).** `entroly go` registers an MCP > server for a detected editor and starts a proxy and dashboard. Route API > traffic through that proxy or use a supported host hook, then verify that > the integration actually ran. The table below shows the available paths. | Your situation | Do this | What it gets you | |---|---|---| | 🟢 **"I control my app's API base URL."** *(pip / Python user)* | `pip install -U entroly && entroly go` | Starts the local proxy and dashboard; point your app at the displayed URL and check observed requests with `entroly value --json` | | **"I use Node, not Python."** *(npm user)* | `npm install -g entroly && entroly init` | Node/WASM CLI and local MCP path; use Python for the full proxy and SDK path | | **"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, Codex, Gemini CLI, or VS Code agent plugins."** *(plugin user)* | Install the Entroly plugin/extension for that host, submit one prompt, then run `entroly activation status --json` | A trusted prompt hook performs bounded local selection before planning; a receipt proves the hook ran | | **"I use Cursor with third-party configs enabled."** | `entroly activation install --host cursor --project .` | Merges a reversible Claude-compatible prompt hook; native Cursor MCP remains advisory | | **"I use Kiro IDE 1.x or CLI 3.x."** | `entroly activation install --host kiro --project .` | Installs a reversible project `PromptSubmit` hook whose stdout is added to agent context | | **"I use another MCP host."** | `entroly attach create --client claude --project . --ttl 4h --install` or the client-specific command in the compatibility matrix | Scoped Entroly tools and receipts; the model can still skip MCP unless the host has a verified lifecycle hook | | **"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` | Requests sent through the proxy are eligible for optimization; inspect receipts and provider-observed usage after a real request | Cursor MCP users can also use this one-click install link (no marketplace account required): [Add Entroly to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=entroly&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImVudHJvbHktbWNwQDEuMC44NCIsInNlcnZlIl0sImVudiI6eyJFTlRST0xZX05PX0RPQ0tFUiI6IjEiLCJFTlRST0xZX01DUF9QQVNTSVZFIjoiMSIsIkVOVFJPTFlfTUNQX1BST0ZJTEUiOiJwdWJsaWMiLCJFTlRST0xZX01BWF9GSUxFUyI6IjIwMCJ9fQ). **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](docs/session-rescue.md). **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. ```python 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") ``` ```bash 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](docs/first-run-trust.md) · [Command reference](docs/DETAILS.md#command-reference). --- ## 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](docs/integration-hub.md#vercel-ai-sdk) · [OpenAI SDK](docs/integration-hub.md#openai-sdk) · [Anthropic SDK](docs/integration-hub.md#anthropic-sdk) | [Agno](docs/integration-hub.md#agno) · [Strands Agents](docs/integration-hub.md#strands-agents) · [CrewAI](docs/integration-hub.md#crewai) · [AutoGen](docs/integration-hub.md#autogen) | | [LangChain](docs/integration-hub.md#langchain) · [LiteLLM](docs/integration-hub.md#litellm) · [MCP](docs/integration-hub.md#mcp) | [Claude Code on Vertex AI](docs/integration-hub.md#claude-code-on-vertex-ai) · [Claude Code on Azure AI Foundry](docs/integration-hub.md#claude-code-on-azure-ai-foundry) | | [OpenClaw](docs/integration-hub.md#openclaw) · [OpenCode](docs/integration-hub.md#opencode) | [Claude Code in VS Code](docs/integration-hub.md#claude-code-in-vs-code) · [VS Code Copilot](docs/integration-hub.md#vs-code-copilot) · [Grok](docs/integration-hub.md#grok) | **[Open the complete verified integration and operations hub →](docs/integration-hub.md)** --- ## 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.
entroly verify-claims — import, compression, receipts, WITNESS checks, recovery, proxy routing, replay. No API key.
On a frozen 24-case holdout, Entroly answered 24/24; a published baseline answered 18/24 at roughly 1.5x the effective context. python scripts/readme_proof.py model-recovery
Omitted evidence recovered byte-exact after a process restart, 66/66 payloads. python scripts/readme_proof.py restart-recovery
gpt-4o-mini · Budget: 50K tokens · Wilson 95% CI · Reproduce: python -m bench.accuracy --benchmark all
| Benchmark | n | Baseline (95% CI) | Entroly (95% CI) | Retention | Benchmark Delta |
|---|---|---|---|---|---|
| **NeedleInAHaystack** | 20 | 100.0% [83.9–100%] | 100.0% [83.9–100%] | **100.0%** | Baseline |
| **GSM8K** | 100 | 85.0% [76.7–90.7%] | 86.0% [77.9–91.5%] | **101.2%** | +1.0% |
| **SQuAD 2.0** | 100 | 84.0% [75.6–89.9%] | 83.0% [74.5–89.1%] | **98.8%** | -1.0% |
| **MMLU** (4-way MCQ) | 100 | 82.0% [73.3–88.3%] | 85.0% [76.7–90.7%] | **103.7%** | +3.0% |
| **TruthfulQA** (MC1) | 100 | 72.0% [62.5–79.9%] | 73.0% [63.6–80.7%] | **101.4%** | +1.0% |
| **LongBench** (HotpotQA) | 100 | 57.0% [47.2–66.3%] | 59.8% [49.8–69.0%] | **104.9%** | +2.8% |
The reported SQuAD score fell from 84% to 83%. Retention ratios above 100%
can reflect sampling or model variability. The displayed intervals are historical
reported values, not a validated paired comparison; Wilson intervals require
binary outcomes and do not justify uncertainty for averaged partial-credit scores.
Establishing non-inferiority needs a predefined tolerance, paired per-task outcomes,
appropriate uncertainty estimates, and adequate sample size. These results cannot
be extrapolated to more aggressive compression or other models.
### Context Selection Quality
19-fragment synthetic corpus · 300-token budget · 3 fixture queries · Reproduce: entroly benchmark
| Metric | RAW (Naive FIFO) | TOP-K (local baseline) | **ENTROLY (Knapsack)** |
|---|---|---|---|
| Avg fragments selected | 6.0 | 6.0 | **8.7** |
| Avg module coverage | 3.0 | 3.7 | **8.7** |
| Total SAST catches | 0 | 0 | **3** |
Entroly sees 8.7 modules where TOP-K sees 3.7 — it includes auth, payments, AND rate limiting. TOP-K misses the rate limiter. Full methodology, CIs, and reproduce commands →
---
## Research
Entroly includes the following research-oriented implementations. A module's
presence does not establish production reliability, mathematical novelty, or
independent validation; consult its implementation and evaluation limitations.
| Algorithm | What it does | Implementation |
|---|---|---|
| **BIPT** | Byte-level hallucination detection via Kolmogorov-inspired provenance tracing | [`provenance_tracer.py`](entroly/verifiers/provenance_tracer.py) |
| **NKBE** | Nash-KKT multi-agent token budget equilibrium | [`nkbe.rs`](entroly-engine/src/nkbe.rs) |
| **Causal Context Graph** | Intervention-aware fragment feedback learning | [`causal.rs`](entroly-engine/src/causal.rs) |
| **Cognitive Bus** | ISA event routing with KL-divergence priority | [`cognitive_bus.rs`](entroly-engine/src/cognitive_bus.rs) |
| **Resonance Matrix** | Supermodular pairwise fragment value learning | [`resonance.rs`](entroly-engine/src/resonance.rs) |
| **System 1 <> 2** | Dual-process verified-belief bridge (proxy <> vault) | [`coupling.py`](entroly/coupling.py) |
> [Read the full research documentation](docs/RESEARCH.md) · [Cite Entroly](CITATION.cff)
---
## 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.
- **Cross-agent shared memory** — Claude, Codex, Cursor, and Gemini can read and write the same compressed context store with automatic SimHash deduplication and agent provenance tracking.
- **Output token reduction** — effort-based routing classifies query complexity and steers model verbosity, reducing output tokens alongside input tokens.
- **Shell hook compression** — transparent CLI output compression for git, npm, cargo, docker, pytest, kubectl, and terraform. Preserves errors and warnings, strips progress bars and boilerplate.
- **Image compression** — 40-90% reduction on screenshots and diagrams for vision API calls, with optional OCR text extraction.
- **Failure mining** — `entroly learn --deep` mines session data for recurring failure patterns and writes corrections to CLAUDE.md, .cursorrules, and other agent configs.
Runs as a **CLI**, **Python/TypeScript SDK**, **MCP server**, **HTTP proxy**, or **library import**. Full surface map: **[docs/product-surface.md](docs/product-surface.md)**. Architecture and Rust internals: **[docs/DETAILS.md](docs/DETAILS.md)**.
---
## How Entroly compares
Entroly combines budgeted selection, source-span receipts, and optional
verification. These are distinct guarantees: a receipt records retained and
omitted material; recovery checks source integrity; WITNESS/EICV checks can still
produce false positives or false negatives. Solver objectives approximate useful
context and do not prove that the chosen context is sufficient for a task.
Compare tools on the same task set, version, model, token budget, and quality
criterion. The local TOP-K fixture does not measure any commercial product. We
do not provide an independently reproduced cross-product comparison here.
---
## Works with your stack
Install the public Codex plugin from the Entroly repository:
```console
codex plugin marketplace add juyterman1000/entroly --ref main
codex plugin add entroly@entroly-public
```
Restart Codex, review and trust the hook, then run `entroly activation status
--json` after a task. The marketplace installs the local Node/WASM runtime with
the plugin; the model does not have to remember to call an MCP tool before
Entroly runs. A receipt proves that the hook executed and selected local
context or made an explicit no-match decision. It does not prove token or cost
savings without a matched provider-bound baseline.
Install the same public repository as a Gemini CLI extension:
```console
gemini extensions install https://github.com/juyterman1000/entroly --ref main --consent
```
Restart Gemini CLI after installation. The repository root contains
`gemini-extension.json` and `GEMINI.md`, so the command works without navigating
into an integration subdirectory.
For VS Code or Kiro, download the `entroly-vscode-*.vsix` asset from the latest
[GitHub release](https://github.com/juyterman1000/entroly/releases/latest), then
install it with **Extensions: Install from VSIX** or `code --install-extension`.
The extension is self-contained and does not require an API key.
JetBrains AI Assistant users can add the same server globally at **Settings →
Tools → AI Assistant → Model Context Protocol (MCP)**:
```json
{
"mcpServers": {
"entroly": {
"command": "npx",
"args": ["-y", "entroly-mcp@1.0.86", "serve"],
"env": {
"ENTROLY_NO_DOCKER": "1",
"ENTROLY_MCP_PASSIVE": "1",
"ENTROLY_MCP_PROFILE": "public",
"ENTROLY_MAX_FILES": "200"
}
}
}
}
```
The repository also ships a free, open-source JetBrains plugin that guides this
setup from **Tools → Configure Entroly for AI Assistant**, checks the local
runtime on request, and keeps the evidence boundary visible. See
[`extensions/jetbrains`](extensions/jetbrains/README.md).
MCP marketplace and plugin manifests select the compact `public` profile so
agents see the core context, receipt, continuity, recovery, and verification
tools first. A direct `entroly serve` invocation remains backwards compatible
and exposes the full tool surface. You can choose either behavior explicitly
with `ENTROLY_MCP_PROFILE=public` or `ENTROLY_MCP_PROFILE=full`.
### Cross-agent review from a source checkout
The bundled `entroly-agent-review` skill guides a local Claude-to-Codex (or
other agent) code review. With both agents pointed at the same repository and
local Entroly state, ask the writer to claim the task, use `work_state` to get
its `workstream_id`, and call `work_handoff` for the reviewer. The reviewer uses
`work_pending_handoffs`, `work_resume`, and `work_acknowledge_recovery` before
claiming further work, then independently inspects the diff and calls
`work_record_review`. `work_reviews` reports whether the reviewed source is
still current. Start with `work_capabilities` in each host to check the actual
repository root; MCP registration by itself does not establish that the right
checkout is selected.
If the writer's model budget ends before it calls `work_handoff`, the reviewer
can call `work_resume(to_agent=...)` to obtain a reconstructed no-handoff proof
and current changed-file evidence. It must treat previous-agent intent as
unknown, acknowledge the recovered state, and review the source independently.
It cannot create or record a Claude-authored handoff after Claude is gone.
The handoff and review are local Work Graph records. They bind a reviewer
statement to observed Git state and file digests; they do not attest the
reviewer's model identity or prove the verdict correct. This flow currently
requires shared local state. A customer-hosted multi-machine service, identity
policy, and audit administration are separate enterprise work.
The MCP path is provider-neutral: the host can use OpenAI, Anthropic, Google,
Mistral, DeepSeek, Kimi, GLM, or a local model. There is no separate plugin
marketplace for each model provider; the host's MCP or extension contract is
the integration boundary.
| Agent / platform | Path | Status |
|---|---|---|
| Claude Code | Bundled `UserPromptSubmit` hook + scoped MCP | Deterministic after plugin enablement |
| Codex CLI / app | Bundled `UserPromptSubmit` hook + scoped MCP | Deterministic after hook trust |
| Gemini CLI | Bundled `BeforeAgent` hook + scoped MCP | Deterministic after extension enablement |
| OpenClaw | Context-engine plugin + scoped MCP | Native |
| Cursor | Claude-compatible project hook; MCP or proxy fallback | Deterministic only when third-party configs are enabled |
| Kiro IDE 1.x / CLI 3.x | Project `PromptSubmit` hook | Deterministic after project install |
| VS Code / Copilot agent mode | Agent-plugin hook where supported; MCP fallback | Host-version dependent |
| IntelliJ / JetBrains AI | MCP or supported custom endpoint | Advisory until a lifecycle hook is verified |
| 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 |
Hook enforcement belongs to the host, so it is independent of whether that
host runs an OpenAI, Anthropic, Gemini, Kimi, DeepSeek, Mistral, or GLM model.
Status describes integration depth, not a savings guarantee. Provider-observed
savings require requests to 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](docs/agent-compatibility.md)**.
Entroly carries verified metadata for current models from OpenAI, Anthropic, Google, Meta, and others. It auto-discovers local Ollama models. Model-specific details: **[docs/DETAILS.md](docs/DETAILS.md)**.
---
## When to use it · when to skip it
**Great fit:** large repos where the agent only sees a few files at a time · chatty multi-turn agents · anywhere you want answers checked against evidence · cutting a real, growing AI bill.
**Skip it:** tiny repos or short prompts that already fit the budget · judgment-heavy tasks where you always want the full flagship model.
---
## More commands
For evidence-led optimization rather than a synthetic savings estimate:
```bash
entroly learn --history --json
entroly shrink -- pytest -q
entroly trial --experiment checkout-fix --arm baseline -- codex exec "fix the checkout test"
entroly trial --experiment checkout-fix --arm optimized -- codex exec "fix the checkout test"
entroly trial --report checkout-fix
entroly browser https://example.com --query "billing settings"
entroly find docs/product-surface.md --query "exact source evidence" --json
entroly response set evidence --scope project
```
Trials run one explicitly selected arm at a time so a stateful or paid agent task is never repeated implicitly. Response contracts shape agent instructions; they do not truncate responses or count as measured savings. Browser and command reductions keep exact local recovery handles and pass through when their safety gates cannot be met.
For teams that need to say who an agent is and what it was allowed to do:
```bash
entroly govern status # identity, policies, audit chain
entroly govern policy check write --risk high # evaluate one authorization
entroly govern audit verify # exit non-zero on a broken chain
```
Authorization is deny-by-default and every denial names the policy and the reason it gave. `audit verify` checks that recorded entries were not altered after the fact — it does not prove every action was recorded, and `govern status` reports the state of the local control plane only, not an attestation that each agent action passed through it. Identity tokens are unsigned unless `ENTROLY_IDENTITY_KEY` is set, and the credential is never printed.
Also available: `entroly wrap`, `entroly unwrap`, `entroly serve`, `entroly daemon`, `entroly dashboard`, `entroly demo`, `entroly capabilities`, `entroly ingest`, `entroly select`, `entroly receipt`, `entroly explain`, `entroly context-commit`, `entroly proof`, `entroly benchmark`, `entroly cache`, `entroly ravs`, `entroly perf`, `entroly batch`, `entroly usage`. Full description: [command reference](docs/DETAILS.md#command-reference).
---
## Common questions
Apache-2.0 · local-first · no outbound analytics by default
pip install entroly && entroly go