For Claude Code, Codex, Pi, Cursor and 6 more coding agents
Your coding agent reads whole files to find its way. Pixel is a local code index that hands it only the lines it needs. Same agent, same prompts, a fraction of the tokens.
brew install LivioGama/tap/pixel
Your agent reading Hugging Face's trainer.py, all 4,639 lines: 57,058 tokens. The same question through Pixel: 1,649 tokens.
You describe the task. Your agent asks Pixel on its own. It gets the 5 files that matter out of 555, and starts coding instead of searching.
YouRetry a leased push when the remote branch moved.
Agentpixel scope-task "retry a leased push when the remote branch moved"
You never type that command. pixel install teaches your agent when to run it, the same way it learns every other Pixel command.
Fast answers do not make a fast agent on their own. So we timed Claude Code on real tasks in this repository, with Pixel and against a vanilla agent with no rules or hooks.
The two losses come from three runs per cell: read them as directions, not decimals. The runs and their caveats
The tools a team weighs Pixel against, with the rows where they win kept in. GitNexus was run against Pixel on the same cases and the same machine; shunt and Jev are their own published figures, set beside ours.
A code graph for agents, served as 17 MCP tools.
| Measure | Pixel | GitNexus |
|---|---|---|
| Callers found (29 cases) | 0.86 | 0.84 |
| Median answer | 153 ms | 432 ms |
| Context on every turn | ~4,160 tok | ~19,700 tok |
| Git history, Git writes | Yes | No |
| Licence | MIT | PolyForm Noncommercial |
Where GitNexus wins: Cypher queries, taint analysis, API route maps, and callers in Ruby.
The 29 casesSpotify's plugin: large reads go to a second model.
| Measure | Pixel | shunt |
|---|---|---|
| Less read on large files | 79.7 to 97.2% measured | 82 to 94% claimed |
| Who reads the file | The index | A worker model |
| Second model on the bill | None | Yes |
| Needs | One binary | Spotify Portal with AiKA |
Where shunt wins: its worker also writes boilerplate code, which Pixel does not.
The 8 files measuredA dedicated model for coding judgement calls.
| Measure | Pixel | Jev |
|---|---|---|
| JevBench coding items | 14 of 14 with deepseek-v4.1-flash | 83.9% |
| Model | The one you choose (13 of 14 with gpt-oss) | Jev's own |
Read with care: Jev's 83.9% is its published score on 56 items; Pixel's run covers the 14 public ones, and the rest of Pixel needs no decision model.
The optional add-onWhere a specialist beats Pixel at its one job (semble on plain-English search, stacklit on a compact repository map), the numbers are on the benchmarks page too, and each comparison has a page of its own.
An agent tool stays in a team when every seat gets something from it. What Pixel gives each one, with the number behind it.
Developers
pixel install once, and the agent calls Pixel from its own shell.Lead developers
pixel impact lists a symbol's callers and callees before the change; pixel review-changes shows the diff, structured.pixel plan-rollback writes nothing until --apply.pixel install --repo adds a guard that flags untargeted reads of large files.Harness engineers
complete, capped or unresolved, and a graph answer never claims it saw every caller. The one model-backed command, the optional pixel classify, says it is not deterministic.CTOs
.pixel/. The network sees only what you run: Git remotes, the optional pixel classify and pixel web-search, and a one-time embedding model download.A closed P0/P1/P2 file list, not an agent wandering the repository.
Signatures fitted to a token budget, instead of whole-file reads.
Every caller of a symbol, listed before the agent touches it.
The hook turns rg and grep into indexed search. Same command.
Flags the likely breaking commit and the last good one. Resets nothing.
Review, then a crash-safe leased push. Never a raw --force.
One binary, one folder in your repository, no server.
.pixel/, at your repository root, holds a text index of every file Git does not ignore and a code graph of symbols, imports and calls parsed with tree-sitter, built on first use.
A local daemon keeps both open and watches the tree, so answers take milliseconds and follow your edits. No daemon? The command runs in-process.
The agent gets the symbols, signatures or lines its question needs, fitted to a token budget, with a marker saying whether the answer is complete.
A CLI plus hooks, not an MCP server. pixel install puts the protocol where each agent reads its instructions, and the agent calls Pixel from the shell it already has.
public JevBench coding items
Also 13 of 14 with gpt-oss:120b, gpt-oss:20b or deepseek-v4-flash.
Optional add-on · bring your own model
A patch billed as a "documentation cleanup" also changes a timeout: does it still need two reviewers? JevBench asks judgement calls like this one, where the obvious answer is the wrong one.
pixel classify hands such a question to the model you choose and returns one probability per answer.
Pixel works fully without it. No API key, no account. pixel classify is the only command that calls a model, and only the one you configure: OpenRouter, Ollama Cloud or a local server.
Jev's 83.9% is its own published score on 56 coding items, not re-measured here, and 14 items is a small sample. Every model, the method and its limits
Not every time. Agents are trained on grep and fall back to it. Pixel does not wait for the agent to discover a tool: pixel install puts its protocol into every session, and pixel install --repo adds a guard that flags untargeted reads of large files. The guard advises and never blocks.
With Pixel 0.5.0 it did: in each of the 11 recorded runs behind the demo, the agent called Pixel 6 to 17 times. An earlier release fared worse: given its protocol alone, the agent barely ran a Pixel command, yet still scoped tasks 29% faster, so part of the gain is the protocol's guidance itself. The runs
Grep finds the line. The cost is what comes next: the agent opens the whole file to understand the match. On Hugging Face's 4,639-line trainer.py that read costs 57,058 tokens, and Pixel's answer to the same question 1,649. pixel search-content keeps grep's regex syntax, so the agent changes nothing but the bill.
A language server resolves types, so its "who calls this" is more exact than a syntax graph's. It also needs one running server per language and answers one cursor position at a time. Pixel is one binary, covers 13 languages and your Git history, and says when an answer may be incomplete: static analysis never sees every dynamic call, and every graph answer carries that warning.
It lives inside that editor. Pixel runs from the shell, so every agent on this page gets the same index, and it stays in .pixel/ at your repository root.
Both, if you search in plain English a lot. semble puts the right file in its top 10 for 100% of 45 natural-language queries, Pixel for 69%. Pixel adds the call graph, blast radius, Git history and guarded Git writes. Together they cost about 5,100 tokens of context per turn. Where a specialist wins
Nothing you did not ask for. The index lives in .pixel/ and there is no telemetry. Pixel touches the network for four things only: the embedding model it downloads from Hugging Face on first use, the Git remote operations you run (pixel fetch, pixel push), pixel classify, which sends its question to the model you configure, and pixel web-search, which sends its query to the SearXNG endpoint you configure and nowhere else, or, without one, to DuckDuckGo and then Wikipedia. Security model
Text search covers every file Git does not ignore, up to 4 MiB. The code graph covers TypeScript, JavaScript, Rust, Go, Java, Python, C#, Ruby, PHP, C, Swift, Elixir, and Lua. The last five go through a generic extractor rather than a dedicated one.
$ brew install LivioGama/tap/pixel$ curl -fsSL https://github.com/LivioGama/pixel/releases/latest/download/install.sh | sh $ pixel install # wires Claude Code, Codex, Pi and more
$ pixel doctor . # optional: everything green?
$ pixel list-signatures path/to/a/large/file.py # first result, in your repoThe last line needs no session: under the file's outline, Pixel's report compares it with reading the whole file. On Requests' models.py: full read 10365 tok, pixel answer 641 tok (-94%).
The script works on macOS and Linux. Another agent? Plugins and rules files.
Questions, or stuck on setup? Ask in GitHub Discussions.
pixel uninstall