Entroly

The Context Engineering Engine for AI Coding Agents
Your AI sees 5% of your codebase. Entroly shows it everything — 78% fewer tokens.

pip install entroly  —  Works with Cursor, Claude Code, Copilot, Windsurf, OpenClaw

Install  •  Demo  •  Integrations  •  OpenClaw  •  CLI  •  Discuss

See It In Action

Run it yourself: pip install entroly && entroly demo

Open the interactive HTML demo for the full animated experience, or generate your own with python docs/generate_demo.py.

The Value

Every AI coding tool — Cursor, Copilot, Claude Code, Cody — stuffs tokens into the context window until it's full, then cuts. Your AI sees 5-10 files and the rest of your codebase is invisible.

Entroly fixes this. It compresses your entire codebase into the context window at variable resolution, removes duplicates and boilerplate, and learns which context produces better AI responses over time.

You install it once. It runs invisibly. Your AI gives better answers and you spend less on tokens.

Context Engineering, Automated

"The LLM is the CPU, the context window is RAM."

Today, every AI coding tool fills that RAM manually — you craft system prompts, configure RAG, curate docs. Entroly automates the entire process.

These layers are complementary. Doc tools give you better docs. Memory gives you persistence. RAG retrieves relevant chunks. Entroly is the optimization layer that makes sure all of it actually fits in your context window without wasting tokens.

Entroly works standalone, or on top of any doc tool, memory system, RAG pipeline, or context source.

Install

pip install entroly

That's it. One command. Works on Linux, macOS, and Windows.

Windows users: If pip is not on your PATH, use python -m pip install entroly.

Connect to your AI tool

Cursor — run entroly init in your project. It generates .cursor/mcp.json automatically.

Claude Code — run claude mcp add entroly -- entroly.

VS Code / Windsurf — run entroly init. Auto-detected.

Any other AI tool — use proxy mode:

pip install entroly[proxy]
entroly proxy --quality balanced

Then point your AI tool's API base URL to http://localhost:9377/v1. Done.

Verify it's working

entroly status     # check if the server/proxy is running
entroly demo       # see a before/after comparison of token savings on your project
entroly dashboard  # open the live metrics dashboard at localhost:9378

Install options

pip install entroly           # Core — MCP server + Python fallback engine
pip install entroly[proxy]    # Add proxy mode (transparent HTTP interception)
pip install entroly[native]   # Add native Rust engine (50-100x faster)
pip install entroly[full]     # Everything

Docker

docker pull ghcr.io/juyterman1000/entroly:latest
docker run --rm -p 9377:9377 -p 9378:9378 -v .:/workspace:ro ghcr.io/juyterman1000/entroly:latest

Multi-arch: linux/amd64 and linux/arm64 (Apple Silicon, AWS Graviton).

Or with Docker Compose: docker compose up -d

Works With Everything

OpenClaw Integration

OpenClaw users get the deepest integration. Entroly plugs in as a Context Engine that optimizes every agent type automatically:

When OpenClaw spawns multiple agents, Entroly's multi-agent budget allocator splits your token budget optimally across all of them. No agent starves. No tokens wasted.

from entroly.context_bridge import MultiAgentContext

ctx = MultiAgentContext(workspace_path="~/.openclaw/workspace")
ctx.ingest_workspace()

# Spawn subagents with automatic budget splitting
sub = ctx.spawn_subagent("main", "researcher", "find auth bugs")

# Schedule background checks
ctx.schedule_cron("email_checker", "check inbox", interval_seconds=900)

# Every agent gets optimized context automatically

How It Works

1. Ingest — Indexes your codebase, builds dependency graphs, fingerprints every fragment for instant dedup
2. Score — Ranks fragments by information density — high-value code scores high, boilerplate scores low
3. Select — Picks the mathematically optimal subset that fits your token budget, with diversity (auth + DB + API, not 3x auth files)
4. Deliver — 3 resolution levels: critical files in full, supporting files as signatures, peripheral files as one-line references
5. Learn — Tracks which context produced good AI responses, improves selection weights over time

Why Not Just RAG?

Most AI tools use embedding-based retrieval (RAG). Entroly takes a fundamentally different approach:

Platform Support

CLI Commands

Production Ready

Entroly is built for real-world reliability, not demos.

• Connection recovery — auto-reconnects dropped connections without restarting
• Large file protection — 500 KB ceiling prevents out-of-memory on giant logs or vendor files
• Binary file detection — 40+ file types (images, audio, video, archives, databases) are auto-skipped
• Crash recovery — gzipped checkpoints restore state in under 100ms
• Cross-platform file locking — safe to run multiple instances
• Schema migration — entroly migrate handles config upgrades between versions
• Fragment feedback — POST /feedback lets your AI tool rate context quality, improving future selections
• Explainable decisions — GET /explain shows exactly why each code fragment was included or excluded

Need Help?

Self-service:

entroly doctor    # runs 7 diagnostic checks automatically
entroly --help    # see all available commands

Get support:

If you run into any issue, email autobotbugfix@gmail.com with:

1. The output of entroly doctor
2. A screenshot of the error
3. Your OS (Windows/macOS/Linux) and Python version

We respond within 24 hours.

Common issues:

python3 -m venv ~/.venvs/entroly
source ~/.venvs/entroly/bin/activate
pip install entroly[full]

python -m pip install entroly

entroly proxy --port 9378

pip install entroly[native]

Part of the Ebbiforge Ecosystem

Entroly integrates with hippocampus-sharp-memory for persistent cross-session memory and Ebbiforge for TF embeddings and RL weight learning. Both are optional.

Quality Presets

Control the speed vs. quality tradeoff:

entroly proxy --quality speed       # minimal optimization, lowest latency
entroly proxy --quality fast        # light optimization
entroly proxy --quality balanced    # recommended for most projects
entroly proxy --quality quality     # deeper analysis, more context diversity
entroly proxy --quality max         # full pipeline, best results
entroly proxy --quality 0.7         # or any float from 0.0 to 1.0

Environment Variables

+-----------------------------------------------------------+
|  IDE (Cursor / Claude Code / Cline / Copilot)             |
|                                                           |
|  +---- MCP mode ----+    +---- Proxy mode ----+          |
|  | entroly MCP server|    | localhost:9377     |          |
|  | (JSON-RPC stdio)  |    | (HTTP reverse proxy)|         |
|  +--------+----------+    +--------+-----------+          |
|           |                        |                      |
|  +--------v------------------------v-----------+          |
|  |          Entroly Engine (Python)             |          |
|  |  +-------------------------------------+    |          |
|  |  |  entroly-core (Rust via PyO3)       |    |          |
|  |  |  21 modules . 380 KB . 249 tests    |    |          |
|  |  +-------------------------------------+    |          |
|  +---------------------------------------------+          |
+-----------------------------------------------------------+

License

MIT