swe-pruner — Summary

One-line: Neural context pruner that removes irrelevant code tokens before they reach the LLM, cutting 23–54% of tokens on SWE-Bench Verified with a 0.6B fine-tuned model.

Identity

What It Does

swe-pruner serves a FastAPI endpoint (port 8000) that accepts a context payload and returns a pruned version, stripping code chunks the model predicts are irrelevant to the query. The pruner model (code-pruner, 0.6B parameters) is fine-tuned and hosted on HuggingFace (ayanami-kitasan/code-pruner). Agents call the /prune endpoint directly; there is no MCP server, no Claude hook, and no vault.

Claimed Results

• "Make Claude Tokens 40% Saving!" (badge, verbatim)
• "23–54% token reduction on SWE-Bench Verified"
• "up to 14.84x compression on LongCodeQA"
• Paper: arXiv:2601.16746 (ByteDance Seed)

Archetype

Research paper implementation — FastAPI inference server, not a Claude plugin or MCP server. Closest to a preprocessing layer that any agent framework can call via HTTP.

swe-pruner — Overview

Problem Statement

LLM-based coding agents (Claude, OpenHands, SWE-agent) retrieve large repository contexts before issuing a fix. Most of this context is irrelevant to the specific issue. swe-pruner addresses this by interposing a neural pruning step: a small 0.6B model judges each code chunk's relevance and discards those below threshold before the context ever reaches the frontier model.

Positioning

• Research artifact: Accompanying implementation for arXiv:2601.16746 (ByteDance Seed team)
• Not a SaaS or plugin: No hosted API, no MCP server, no Claude Code plugin
• Universal preprocessor: Works with any agent that can call an HTTP endpoint (Claude Agent SDK demo, OpenHands demo, direct HTTP)
• Complementary to retrieval: Sits after BM25/vector retrieval and before the LLM call; pruner trims what retrieval keeps

Key Claims (verbatim from README)

"Make Claude Tokens 40% Saving!"

"23-54% token reduction on SWE-Bench Verified"

"up to 14.84x compression on LongCodeQA"

Target Users

• Researchers running SWE-Bench evaluations who need reproducibility
• Agent framework developers wanting to add a pruning preprocessing step
• Cost-sensitive production users willing to run a local 0.6B GPU inference server

Prerequisites

• Python >= 3.12
• CUDA GPU (flash-attn requires CUDA; CPU fallback not documented)
• HuggingFace model download (~1.2GB): ayanami-kitasan/code-pruner
• pip install swe-pruner (installs swe-pruner CLI entry point)

swe-pruner — Architecture

Deployment Model

Agent (Claude / OpenHands / any HTTP client)
       │
       ▼  POST /prune  (JSON: query + context chunks)
┌─────────────────────────────────────────────┐
│  swe-pruner FastAPI server  (port 8000)      │
│                                              │
│  online_serving.py  ←  pyproject entry point │
│  ┌─────────────────────────────────────────┐ │
│  │  code-pruner model (0.6B, HuggingFace)  │ │
│  │  ayanami-kitasan/code-pruner             │ │
│  │  flash-attn inference (CUDA)            │ │
│  └─────────────────────────────────────────┘ │
│  Returns: pruned context chunks              │
└─────────────────────────────────────────────┘
       │
       ▼  Pruned context passed to frontier LLM
  (Claude / GPT-4 / etc.)

Components

Model

• Name: code-pruner
• HuggingFace: ayanami-kitasan/code-pruner
• Parameters: ~0.6B
• Fine-tuned for: Code chunk relevance classification
• Inference: flash-attn (requires CUDA)
• Download: git lfs pull or huggingface-cli download

Required Dependencies

python >= 3.12
flash-attn        # CUDA-only
transformers
fastapi
uvicorn

No Persistent State

swe-pruner is stateless: no vault, no SQLite, no session memory. Each /prune call is independent.

swe-pruner — Components

CLI Entry Point

swe-pruner --model-path ./model --port 8000

FastAPI Endpoints

Integration Examples

Claude Hooks

None. swe-pruner has no .claude/settings.json, no MCP server, no plugin manifest.

MCP Tools

None. swe-pruner is not an MCP server.

Skills

None.

HuggingFace Model

• Repo: ayanami-kitasan/code-pruner
• Used via transformers AutoModel/AutoTokenizer
• Not bundled; must be downloaded separately

Paper

arXiv:2601.16746 — "SWE-Pruner: Pruning Irrelevant Context for SWE Agents" (ByteDance Seed)

swe-pruner — Uniqueness

Differentiator

swe-pruner is the only framework in the batch that uses a fine-tuned neural model for context pruning. Every other framework uses heuristic methods (BM25, entropy scoring, SimHash, knapsack DP, or graph traversal). swe-pruner trains a dedicated 0.6B model to learn relevance from SWE-Bench data, then runs inference on each candidate chunk.

vs. ccmemory (Seed)

vs. Batch Peers

• entroly: Both claim 40-70%+ token reduction. entroly uses knapsack DP + BM25 + entropy (heuristic, no model download). swe-pruner uses a 0.6B model (requires CUDA, ~1GB download, GPU inference latency). entroly adds PRISM RL, WITNESS, proxy mode; swe-pruner adds nothing beyond pruning.
• lean-ctx: Both claim aggressive compression. lean-ctx uses BM25+vector hybrid at MCP layer. swe-pruner uses neural scoring at HTTP preprocessing layer. lean-ctx has no model download requirement.
• symdex: symdex retrieves code by structure (imports, AST); swe-pruner filters retrieved code by relevance. Complementary: symdex could feed swe-pruner.
• claude-self-reflect: CSR improves response quality over time via RL; swe-pruner reduces input size with a fixed model. CSR is session-aware; swe-pruner is stateless.

Unique Capabilities Not Found in Seeds or Batch Peers

1. Neural relevance scoring: Fine-tuned 0.6B model trained on SWE-Bench data — the only learned (not heuristic) pruner in the batch.
2. SWE-Bench reproducibility: Published paper (arXiv:2601.16746) with reproducible benchmark numbers; most other frameworks have no formal evaluation.
3. 14.84x compression on LongCodeQA: Highest single-benchmark compression ratio claim in the batch (lean-ctx claims 99.6% on one test, but different task type).
4. Universal HTTP interface: Agents call /prune via HTTP — no SDK lock-in, no Claude-specific hooks, works with any agent runtime.

Caveats

• Requires CUDA GPU: unusable on CPU-only machines without modification
• No active maintenance signal: no version tags, no license file, repo on public branch
• Model must be downloaded separately (~1GB); not bundled
• Research prototype: not production-hardened (no auth, no rate limiting, no error recovery)