Published on npm · Context packs · Optional MCP

Context packs for AI coding assistants

Give coding agents the right files before they search.

ScopeKit gives Claude, Codex, and Cursor a small task pack: files, symbols, tests, relationships, risks, and validation commands for one job.

The right files, not a graph to wander.

$ npx scopekit setup

or npm install -g scopekit && scopekit setup

View benchmarks GitHub →
~1,280× baseline-equivalent context compression Using Graphify's 71.5× full-context baseline style and ScopeKit's ~18× smaller median supplied context in our benchmark.
  • Up to 25× smaller task context
  • ~94% less supplied context
  • Lower Codex usage on every measured task
  • Equal-or-better Claude answers on every measured task
  • 0 external LLM indexing tokens

Scoped benchmark results. Context-compression comparison, not a universal end-to-end token claim.

Install and run.

Run with npx

$ npx scopekit setup

Install globally

$ npm install -g scopekit
$ scopekit setup

A task pack, not a repo dump.

Without a pack

  • Agent searches the repo
  • Reads broad files
  • Follows irrelevant paths
  • Burns context

With ScopeKit

  • Runs one pack command
  • Gets exact files and symbols
  • Sees tests and risks
  • Starts with scoped context

Index, pack, query.

Three commands cover the common loop.

$ scopekit index .
$ scopekit pack "Find auth/session logic" --profile claude
$ scopekit query "Where is auth handled?"
$ scopekit pack "Plan a safe edit" --profile ultra
default
Balanced pack.
ultra
Smallest packs for Codex-style workflows.
claude
Richer relationships and risks for Claude and Cursor.
scopekit pack "Find auth/session logic" Example
Task

Find auth/session logic

Files 
src/auth/login.ts              login entrypoint
src/auth/session.ts            session validation
src/server/auth.controller.ts  API route layer
src/ui/LoginPage.tsx           user login flow
Relationships 
controller -> session service
login page -> auth endpoint
tests -> session behavior
Risks 
session changes can break login persistence
API and UI need matching assumptions
Validate 
npm test
npm run test:auth

Illustrative pack. File names are an example, not files in every repo.

Worked examples

What the scoped benchmarks and the npm package actually showed.

Codex supplied-context suite

Five repo-understanding tasks. ScopeKit used ~94% less supplied context and lower median Codex usage on every measured task.

Claude supplied-context suite

ScopeKit's Claude profile used 79–88% less supplied context with equal-or-better answers on every measured task. Exact Claude token usage was not available from Cursor.

MCP locked-mode proofs

Scoped Codex MCP proofs showed 80.0% mean reduction on auth-discovery and 94.3% mean reduction on impact-analysis.

npm install check

Published as scopekit. Works with npm install -g scopekit and npx scopekit setup.

Benchmarked against Graphify best-effort.

Scoped to this repo, these tasks, and these clients. Artifacts and failed runs are preserved.

~94% less supplied context Codex 5-task suite, median
Every task lower median Codex usage measured supplied-context tasks
79–88% smaller Claude context equal-or-better answers
Metric Graphify best-effort / derived ScopeKit
Context size Larger query/report context ~94% smaller median context in Codex suite
Codex quality Baseline Equal-or-better on every measured task
Codex median usage Baseline Lower on every measured task
Claude quality Baseline Equal-or-better on every measured task
Claude tokens Not captured No Claude token claim
Indexing cost LLM backend for semantic extraction / clustering 0 external LLM indexing tokens

In this scoped supplied-context suite, ScopeKit produced smaller task packs, matched or improved answer quality, and lowered Codex median usage.

Scoped benchmark claims, tied to specific repos, tasks, and clients (5/5 measured tasks). Not a universal superiority claim.

Why the compression number is bigger.

Graphify reports 71.5× fewer tokens than reading a full corpus. In our benchmark, ScopeKit's supplied context was about 18× smaller than Graphify best-effort on median. Using the same full-context baseline style, that is roughly 1,280× baseline-equivalent context compression.

71.5× ~18× ~1,280×

Baseline-equivalent context compression

Context-compression comparison, not a universal end-to-end token claim.

How it works

  1. Index repo structure

    Scans files, symbols, imports, and configs locally.

  2. Read the task

    Maps the task text to relevant repo areas.

  3. Rank what matters

    Scores files, symbols, tests, and configs.

  4. Add relationships and risks

    Notes how files connect and what an edit might break.

  5. Emit a markdown pack

    Outputs a compact packet the agent can read directly.

  6. Optional MCP

    Expose the same workflow over stdio when a client wants live tools.

Context packs vs knowledge graphs.

Graph tools are useful when you want to explore. ScopeKit is for the moment an agent needs to act.

Graphify

  • Queryable knowledge graph
  • Interactive graph and report outputs
  • Useful for exploring system structure
  • Optional MCP support

ScopeKit

  • Task-specific context pack
  • Client-specific profiles
  • No external LLM indexing required
  • Useful before an agent edits, debugs, or explains code

Graphify gives the agent a graph to query. ScopeKit gives the agent the packet it needs.

Trust and scope.

Published on npm

scopekit is installable with npm and npx.

No API key required

Indexing and packing are local.

No LLM indexing bill

ScopeKit does not need an external model to build task packs.

Repo-local setup

Setup writes local instruction files; it does not install into your AI account.

Optional MCP

Use CLI packs by default; run MCP only when a client wants live tools.

Scoped claims

Benchmarks are tied to specific repos, tasks, and clients.

Set up your assistant.

These write repo-local files. For remote or cloud agents, commit them. 

$ scopekit install claude
$ scopekit install codex
$ scopekit install cursor
$ scopekit install mcp

Learn more

CLI command reference

Every setup, pack, query, install, and MCP command.

Claude and Cursor setup

Use the Claude profile for richer relationship context.

Codex setup

Use ultra packs when Codex should stay small.

Optional MCP

Run ScopeKit as a stdio MCP server.

Benchmark methodology

How supplied-context comparisons were measured.

Proofs and caveats

What is proven, what is not.

FAQ

Is ScopeKit a Graphify replacement?

No. Graphify is for exploring a knowledge graph. ScopeKit is for giving an agent the smallest useful task packet. They overlap, but the workflows are different.

Does ScopeKit require an API key?

No. Indexing and packing are local.

Does ScopeKit send code to an LLM?

No for indexing and packing. It creates context that you choose to give to your assistant.

Does setup install ScopeKit into my Claude or Codex account?

No. It writes repo-local instruction files. For remote or cloud agents, commit those files.

Can I use it without MCP?

Yes. CLI and skill mode is the default.

How do I use it with remote or cloud agents?

Run setup, commit the generated instruction files, and the remote agent can read them.

Can I still use repo-context?

Yes. repo-context and repo-context-mcp are deprecated aliases.

What claims are proven?

Scoped Codex and Claude supplied-context benchmarks, plus scoped Codex MCP proofs. See docs/benchmarks.md and docs/proofs/.

What claims are not proven?

No universal superiority claim, no Claude token savings claim, no MCP-vs-Graphify claim.