lcc — Local Context Compiler

Compact coding-agent context without summarizing it away.
lcc cuts what the model does not need, keeps everything else byte for byte, and writes a receipt.

/compact vs lcc

Claude Code's /compact replaces your session with a summary written by a model. Summaries drop the exact error, path or line the agent needs two turns later. lcc does the opposite: old tool outputs leave the context but stay one recall away, and every user and assistant message is kept as it was.

Measured with lcc measure-session (1.2.0, offline, 38 ms, heuristic token count). n = 1 session of mine. Run it on yours and post the result.

In a pre-registered test on 172 real requests (evidence), an agent answering from the stashed context plus recall did as well as with the full context on file recall (+0.006, 95% CI −0.023 to +0.034) with 36.6% fewer tokens. It called recall for 90% of the questions about removed content. A /compact-style summary of the same sessions got 73% of exact values right (our reimplementation of /compact, written by Opus); full and verbatim context got 98%.

Install

pip install "local-context-compiler[tiktoken]"   # the CLI is `lcc`

Claude Code plugin (replaces the /compact summary). Function hooks are early access, so this needs Claude Code 2.1.274+ and the flag below:

export CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1
claude plugin marketplace add lucasmartins-ai/lcc
claude plugin install lcc@lcc --config provider=rules --config rulesMode=stashed

Allow mcp__plugin_lcc_lcc__recall so the agent can get removed outputs back. When a pass fails or removes too little, the plugin hands over to the built-in summary and says so in a toast. Details: Claude Code guide.

MCP (Claude Code, Cursor, Claude Desktop, any stdio client):

{"mcpServers": {"lcc": {"command": "lcc", "args": ["mcp"]}}}

Tools: compact, compact_transcript, recall, inspect, prepare, explain, intake (MCP guide).

CLI, on a session file or any document:

lcc compact ~/.claude/projects/<project>/<session>.jsonl -q "finish the parser fix" \
  --mode tool-calls --provider rules --rules-mode stashed -o compacted.json -r report.json
lcc recall <id>                                   # a removed output, hash-checked

lcc compact notes.md -q "what is wrong with the booking flow?" \
  --provider mechanical -o compacted.md -r report.json
lcc explain report.json --source notes.md         # why each block was kept or dropped

Send us your numbers

lcc measure-session ~/.claude/projects/<project>/<session>.jsonl --markdown

It runs every mode on one of your sessions, offline, and prints counts only: messages, tool calls, tokens before and after, messages kept, time. No text, path or tool output. Paste it in Discussions → Results. Every number from someone other than me makes the claims above less mine and more true.

Why lcc

• Verbatim. Kept spans are byte-identical to the source. Nothing is summarized or rewritten.
• Recoverable. stashed moves removed outputs to a local content-addressed store (~/.cache/lcc/stash); recall re-hashes on read.
• Auditable. Every pass writes a JSON report; lcc explain gives the reason for every drop.
• Local. The default judges run on your CPU in plain Python. No API key, no network.

Providers

specialist-v3 details and limits: SPECIALIST.md. Rules modes: TOOL_CALLS.md. Jev is an optional path you name explicitly (--provider jev); it sends the objective and context blocks to the TypeSafe API, and LCC_DISABLE_NETWORK=1 disables it. compact writes a relevance-compaction-1.2 report; check provider_used and degraded before trusting the output.

Benchmarks

Real sessions (held-out, INFERIDO). In plain words: when a ranker has to drop part of a session, how often does it keep what the agent actually used next? 1.0 would be always. A one-shot final test on 193 items from 36 of the maintainer's sessions that started after the training cutoff. Retention AUC over drop budgets of 0–60% of candidate tokens:

The labels are next-action evidence from one maintainer's Claude Code sessions, which favours v3's training target. The sessions are private; only aggregates are published (SPECIALIST.md).

Synthetic, reproducible (python benchmarks/run_judge_bench.py, about 20 s, no network). Nine hand-written edge cases: supersession, contradiction, config change, exception rule, pt/en mixed, prompt injection in a tool output, large git diff, old root cause, re-read.

These cases are lexically easy, so the lexical baselines do well; v3 misses the Portuguese case. Timings are from macOS arm64 under heavy machine load. Method, every arm and the limits: BENCHMARKS.md. Rules modes on real sessions: REAL_SESSION_BENCHMARKS.md.

Reduction depends on how much of a context is noise. Below a 25% gain, the report marks the pass as not worth it, and the Claude Code plugin keeps the built-in summary.

What it does not do

• It does not check that a model will answer correctly. A structural PASS is not an answer quality result.
• No RAG, embeddings or vector store.
• Protection rules and bounded restoration reduce, but do not rule out, lost evidence; see the safety model.
• specialist-v3 was trained on Claude Code transcripts. Other agents and plain documents are out of distribution; plain text uses mechanical unless a TypeSafe key is configured.

Docs

Development

Python 3.11+.

python -m pip install -e '.[dev,tiktoken]'
pytest -q && ruff check . && mypy
npm test                                   # Node API and hook tests
python benchmarks/run_judge_bench.py --check --out /tmp/judge-bench

The PyPI package named lcc is unrelated; this one is local-context-compiler. Contributing: CONTRIBUTING.md. Security: SECURITY.md. Changes: CHANGELOG.md.

License

MIT. The optional Laya integration carries Apache-2.0 attribution in NOTICE. Maintained by LookADev.