Terminal-first AST dependency graph and session memory engine for AI coding agents. Reduces token usage by serving focused "capsules" instead of full files, and persists session memory anchored to code symbols across sessions.

Got tired of watching people sell the same idea wrapped in marketing copy. Built this, made it free, open source it. No pitch, no waitlist, no pricing page.

• Fewer tokens, better context — Instead of dumping entire files into the context window, Scavenger serves focused capsules: signatures, docstrings, call graphs, and dependency neighborhoods — only what the agent needs.
• Cross-session memory — Annotations (facts, strategies, pitfalls) are anchored to symbols and persist across sessions. Your agent picks up where it left off. This still has a way to go, I am still testing it out.
• Simple setup — Install with a single command, run scavenger init, and you're done.
• Real dependency graph — Built with tree-sitter over 15 languages. Answers "what calls X?", "what does X call?", and "what breaks if X changes?" in milliseconds, without grep.
• Branch-aware index — Each git branch gets its own SQLite database, so context always matches your current branch.
• Federated repos (work in progress) — Query symbols from linked repositories as if they were local.

We ran an A/B comparison — same model (Claude 4.6 Opus), same 3-turn prompt sequence, same codebase (~4k lines Rust, 41 source files). One session had Scavenger enabled, one used only native tools (Grep, Read, Glob, Shell). Full methodology and turn-by-turn analysis: benchmark/report.md.

The savings are not uniform across turns — they compound:

Turn 1 invests in structural understanding via capsules (signatures, call graphs, dependency neighborhoods). By Turn 3 the agent already knows the dependency structure and needs 88% fewer file reads, 94% fewer output tokens, and finishes in 17s vs 185s.

Good fit:

• Multi-turn sessions (explore → analyze → modify → verify) — this is where the graph investment pays off
• Medium-to-large codebases where re-navigation is expensive (the bigger the project, the more tokens wasted re-reading files)
• Refactoring and impact analysis tasks — "what breaks if I change X?" is answered by the graph in milliseconds
• Repeated work across sessions — annotations persist, so the agent doesn't start from zero next time

Not worth it:

• Single-shot questions ("what does this function do?") — capsules add overhead with no payback window
• Tiny projects where the whole codebase fits in context anyway
• Write-only tasks with no exploration phase (e.g. "add this exact function to this exact file")

The break-even point in our benchmark was ~3 turns. If your session is shorter than that, you may not recoup the initial capsule investment.

Note: This is an N=1 benchmark on a single codebase. Results will vary by project size, prompt complexity, and model. We ran it to validate the approach, not to claim universal numbers. Run benchmark/benchmark.py on your own project to see your numbers.

Scavenger has two integration layers:

1. Hooks — Automatically inject capsules on file reads, trigger re-indexing on writes, and manage daemon lifecycle. This is the full experience but requires the agent to support hooks. Currently only Claude Code and Cursor have hook support.
2. MCP bridge — Exposes tools (get_capsule, read_annotations, etc.) that the agent calls explicitly. Any MCP-compatible agent can use this, but the agent won't automatically receive capsules or trigger re-indexing — it has to call the tools itself.

Agents that only support MCP (Windsurf, Continue, Amp, etc.) get the MCP bridge but not hooks. The tools work, but the experience is less seamless. If you try Scavenger with another tool, please open a discussion and let us know how it went.

Download the binary for your platform from the latest release:

# Example: Linux
curl -L https://github.com/Dalot/scavenger/releases/latest/download/scavenger-x86_64-linux.tar.gz | tar xz
sudo mv scavenger /usr/local/bin/

cargo install thescavenger

cargo install --path .

Verify:

scavenger --version

# 1. Go to your project directory
cd your-project

# 2. Initialize Scavenger (indexes files, registers hooks and MCP config)
scavenger init

That's it. scavenger init automatically:

• Indexes all source files (15 languages) and markdown docs into a per-branch SQLite graph
• Creates the Claude Code plugin at .scavenger/claude-plugin/
• Registers the MCP bridge via claude mcp add (if claude CLI is on PATH)
• Writes .mcp.json for any other MCP-compatible tool
• Writes .cursor/mcp.json and .cursor/hooks.json for Cursor
• Adds .scavenger/ to .gitignore

The daemon starts and stops automatically with each agent session — no manual management needed. You can also control it explicitly with scavenger daemon start, scavenger daemon stop, and scavenger daemon status.

After scavenger init, launch Claude Code with the plugin flag:

claude --plugin-dir .scavenger/claude-plugin/

If the claude CLI wasn't found during init, register the MCP bridge manually:

claude mcp add scavenger -- scavenger mcp-bridge

After scavenger init, reload the Cursor window so it picks up the new .cursor/mcp.json and .cursor/hooks.json files. Open the command palette (Ctrl+Shift+P / Cmd+Shift+P) and run Developer: Reload Window. You only need to do this once — after the initial reload, everything works automatically.

scavenger init writes a .mcp.json at the project root. Any tool that reads this file will discover the MCP bridge. If your tool doesn't read .mcp.json automatically, point it at scavenger mcp-bridge as the command for a stdio-based MCP server.

Hooks give agents the full Scavenger experience automatically:

• On file reads — Injects a capsule (signatures, docstrings, call graph neighborhood) so the agent sees focused context instead of raw file content.
• On file writes — Incrementally re-indexes the changed file within a debounce window.
• On session start/end — Starts and stops the daemon automatically.

Available in any MCP-connected agent as callable tools. Agents without hook support use these directly.

1. Annotations — Agent-written notes (facts, strategies, pitfalls), anchored to symbols.
2. Behavioral signals — Auto-captured metrics: which files were touched, token savings per session.
3. Version history — Annotation edits are versioned; annotations from other branches can be merged.

Create .scavenger.toml in your project root (optional — sensible defaults apply):

[capsule]
token_budget = 8000        # Max tokens per capsule (default: 8000)

[traversal]
max_hops = 3               # BFS hop limit (default: 3)
node_budget = 100          # Max nodes to traverse (default: 100)
degree_cap = 30            # Skip high-degree utility nodes (default: 30)

[docs]
patterns = ["**/*.md"]     # Markdown patterns to index
exclude = ["node_modules", "target", ".git"]

Rust, Python, TypeScript, TSX, JavaScript, JSX, Go, Java, C#, C, C++, Ruby, Bash, PHP, Swift

Note: Kotlin is not yet supported. The tree-sitter-kotlin crate requires tree-sitter <0.23, which is incompatible with our tree-sitter 0.25 dependency. Will be added when a compatible version is released.

Claude Code / Cursor / MCP tools
        ↓
Hooks (CLI) ←→ UDS Socket ←→ Daemon
                                ├── Graph (petgraph + tree-sitter)
                                ├── SQLite (per-branch index, WAL)
                                ├── Capsule Pipeline (6-stage)
                                ├── Memory (3-layer model)
                                ├── File Watcher (notify)
                                └── Federation (read-only)

Run scavenger doctor to check:

• Daemon process alive
• Socket accessible
• DB integrity
• Hook registration
• Config validity

Set NO_COLOR=1 for plain output. Use --format=json for machine-readable diagnostics.

Contributions are welcome. See CONTRIBUTING.md for development setup, coding standards, and the PR process. Check CHANGELOG.md for what has changed between releases.

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.