Entroly — Summary

Entroly is a Python + Rust context compression engine that operates as an HTTP reverse proxy in front of LLM APIs (Anthropic, OpenAI, Gemini) and as an MCP server. It intercepts API calls, applies context selection (knapsack 0/1 DP, BM25, Shannon entropy, SimHash dedup) to reduce input tokens, and optionally runs WITNESS — a $0/2ms hallucination detection system that scored AUROC 0.80 on HaluEval-QA, statistically tying GPT-4o-mini. Token savings: README claims "70-95% tested on large-repo release checks"; self-test on the Entroly codebase measures 87% average savings (96.7% at 32K budget, 99.1% at 8K budget).

The architecture has two layers: Python orchestration (MCP protocol, HTTP proxy, CLI, flow) and Rust computation (entroly-core, bound via PyO3/maturin: knapsack, entropy, BM25, SimHash, dependency graph, PRISM RL loop, static security scan). PRISM is a reinforcement loop that learns fragment→outcome mappings, shifting compression weights over sessions. A single PostToolUse Claude Code hook (ravs capture) feeds every tool outcome into the RAVS event log for Bayesian routing.

Compared to seeds: Entroly operates at the LLM API proxy level (intercepts HTTP calls before they reach Anthropic/OpenAI), unlike lean-ctx (wraps tool invocations), CogniLayer (compresses subagent context via MCP), or CSR (captures past conversation history). The WITNESS hallucination detection capability is unique in this batch. Entroly also ships a web dashboard (entroly dashboard), a --kiro integration folder, and 37+ wrap targets across CLI tools.

Entroly — Overview

Origin

juyterman1000. Apache-2.0 license. Python + Rust (PyO3/maturin). Version 1.0.6. Available on PyPI, npm (WASM), Homebrew. Active (last commit 2026-05-26). 1 contributor.

Philosophy

From README:

"Entroly compresses AI context, detects hallucinations, and saves up to 80% on OpenAI, Anthropic, and Gemini API bills. Works locally with Cursor, Claude Code, Codex, GPT & custom providers."

"Audit AI answers against supplied evidence. Cut large-repo context 70-95% in release checks when retrieval has room to work."

Core differentiators:

1. API proxy level — not a tool wrapper; intercepts the HTTP stream before the LLM sees it
2. WITNESS — hallucinaton detection at $0/2ms (deterministic PAV, no LLM call)
3. PRISM RL loop — learns which fragments worked well and adjusts compression weights
4. Reproducible benchmarks — JSON result files committed to repo, reproducible via one command

Key Token Savings Claims (verbatim from README)

• "Token Savings: tested 70-95% on large-repo release checks" (badge)
• "Save 80% on API bills" (headline)
• Self-test on Entroly codebase (entroly verify-claims):
  • 96.7% savings at 32K budget
  • 99.1% savings at 8K budget
  • 87.0% average savings

WITNESS Hallucination Detection

Measured under HaluEval-QA standard protocol (20K decisions):

• AUROC: 0.80
• Accuracy: 84.9% ± 0.6%
• Cost: $0, ~2ms/decision
• Statistically ties GPT-4o-mini (86.3% on same sample)

Entroly — Architecture

Distribution

• PyPI: pip install entroly
• npm: npm i -g entroly-wasm (WASM version)
• Homebrew: brew tap juyterman1000/entroly && brew install entroly
• Docker: docker-compose.yml

Two-Layer Architecture

Python (entroly/)
├── server.py        # MCP server (thin Rust wrapper)
├── proxy.py         # HTTP reverse proxy (port 9377)
├── cli.py           # 40+ CLI commands
├── sdk.py           # compress() / compress_messages()
├── epistemic_router.py  # 5 flow selector
├── flow_orchestrator.py # Pipeline execution
└── vault.py         # Persistent learning store

Rust (entroly-core/src/)
├── knapsack.rs      # 0/1 DP token budget solver
├── entropy.rs       # Shannon entropy scoring
├── semantic_dedup.rs # SimHash O(1) dedup
├── bm25.rs          # TF-IDF + BM25
├── depgraph.rs      # Import/dependency resolution
├── prism.rs         # RL loop (fragment→outcome)
├── cogops.rs        # Unified engine
├── sast.rs          # Static security (55 rules)
└── archetype.rs     # Role-based context presets

State Files

• vault/beliefs/ — durable code-entity understanding
• vault/verification/ — challenge tracking
• vault/actions/ — task outputs, PR briefs
• vault/evolution/skills/ — skill specs with fitness metrics
• .entroly_verification.json — verify-claims output
• .claude/settings.json — PostToolUse RAVS hook

Required Runtime

• Python 3.10+
• Rust (for dev; pre-built via PyPI)
• Optional: OPENAI_API_KEY for NLI verification in WITNESS

Target AI Tools

Claude, Cursor, Codex, Aider, Copilot, Gemini, Qwen, OpenCode; any proxy-aware HTTP client.

Entroly — Components

MCP Tools (12, from server.py)

remember_fragment, optimize_context, recall_relevant, record_outcome, record_test_result, record_command_exit, record_ci_result, explain_context, checkpoint_state, resume_state, prefetch_related, get_stats

CLI Commands (40+, from cli.py)

init, serve, dashboard, health, autotune, proxy, daemon, benchmark, status, config, telemetry, clean, export, import, drift, profile, batch, wrap, learn, go, demo, share, doctor, digest, migrate, role, completions, optimize, feedback, compile, verify-code, verify, verify-claims, sync, search, docs, finetune, witness, ravs

Hook (1 in .claude/settings.json)

Plugin

.claude-plugin/manifest.json v1.0.6 — Claude Code plugin with MCP server (entroly serve)

Kiro Integration

.kiro/steering/ — Kiro IDE steering files (exact content not retrieved; shows multi-IDE support)

WITNESS

CLI: entroly witness --context-file evidence.txt --output-file answer.txt --mode strict Proxy mode: entroly proxy --witness audit / --witness strict

Profiles: rag, qa, benchmark_qa, code, summary, chat, dialogue

PRISM RL Loop

Tracks fragment→outcome mappings across sessions:

• record_outcome MCP tool — record success/failure
• record_test_result / record_command_exit / record_ci_result — automatic outcome signals
• PRISM shifts compression weights based on accumulated feedback

Epistemic Router (5 Flows)

1. Fast Answer — fresh beliefs, act immediately
2. Verify Before Answer — stale beliefs, recompile + verify
3. Compile On Demand — no beliefs, index + extract + verify
4. Change-Driven — PR/commit trigger, blast radius analysis
5. Self-Improvement — repeated failures → skill synthesis

Entroly — Uniqueness

Differentiator

Entroly operates at the HTTP proxy layer, intercepting actual Anthropic/OpenAI API calls before they reach the model. This is architecturally distinct from every other framework in the memory/context batch, which operate at the tool, hook, or MCP level and only see what the agent explicitly passes them.

The proxy intercepts are invisible to the agent: context is compressed, WITNESS certificates are attached to responses, and RAVS telemetry is captured without the agent issuing any special calls.

vs. ccmemory (Seed)

vs. Batch Peers

• lean-ctx: Both do aggressive compression. lean-ctx uses CCP cross-session carry; entroly uses PRISM RL to learn which fragments matter. lean-ctx is MCP-only; entroly adds HTTP proxy interception.
• claude-self-reflect (CSR): Both use PostToolUse hooks + SQLite. CSR focuses on reflection/quality (9.3x quality claim); entroly focuses on compression economics (70-95% savings). CSR has no proxy mode.
• basic-memory: Both are multi-IDE. basic-memory is a knowledge graph (entities/relations); entroly is a compression engine with no graph model.
• cognilayer: Both have CLI + MCP + hooks. CogniLayer targets multi-agent orchestration (21 orchestration tools); entroly targets token cost reduction.
• iwe: Both are Rust-based. iwe is a note graph IDE extension with no agent hooks; entroly is an agent middleware with no document editing model.

Unique Capabilities Not Found in Seeds or Batch Peers

1. Proxy-level interception: Only framework that works by routing HTTP calls through a sidecar, making it the only one that can compress context from any AI tool, not just Claude Code.
2. WITNESS hallucination certificates: Attaches verifiable NLI evidence certificates to every proxied response, creating an audit trail at $0/2ms.
3. PRISM RL loop: Reinforcement learning on fragment→outcome mappings across sessions; weights shift based on test pass/fail, command exit codes, and CI results.
4. Knapsack DP token budget solver: Hard token budget constraint solved via 0/1 dynamic programming in Rust, not heuristic truncation.
5. Dual runtime (Python+Rust via PyO3): Hot paths (entropy, BM25, SimHash, dedup) compiled to native Rust; Python manages orchestration and MCP protocol.