See what a change breaks before your agent makes it.
Wingbox builds the code graph of your repository on your machine and tells an AI coding agent, in a few hundred tokens, what a change will break before it edits.
Latest release 0.2.2 · MIT license · runs on your machine
One command, one exact answer
The agent asks which files depend on the one it is about to edit. Wingbox answers from the code graph instead of reading the repository.
- What could break if I change this file?
- Which modules depend on this service, class or type?
- Does this dependency cross an architecture boundary?
- Which two or three files should I read before fixing this bug?
Your architecture, in 3D layers
The build also writes an interactive map: one HTML file that opens in a browser without a network connection. The layers view stacks API, services, domain and infrastructure; click a file and its blast radius lights up across the layers.

Measured, and checked against the code
One hundred questions drawn at random in five public repositories, an agent with and without Wingbox, every edge compared with the code. Scripts, reference lists and result files are public, and a container reproduces the run.
questions where the impact command names the complete list of dependent files
tokens an agent reads per answer, against its own search alone
complete answers from the agent with Wingbox; 48 without it
to build the graph of FastAPI, 1,227 files, from a fresh checkout
Run it on your repository
- 1
$ pipx install wingboxInstall the command. Claude Code and Codex can also load it as an agent skill: npx skills add aileron-tech/wingbox.
- 2
$ wingbox build .Build the graph. The report and the map land in wingbox-out/.
- 3
$ wingbox impact path/to/file 2Ask what a change to one file reaches within two hops.
How it works
- Local
- Everything runs on your machine: no LLM call, no embeddings, no network access to build or query the graph.
- Deterministic
- Static parsing: the same code gives the same graph, and every edge can be traced to a line of source.
- Ten languages
- Python, TypeScript, Rust, C#, Java, Go, Ruby, Rails, Free Pascal and Lazarus.
- For agents and people
- An agent skill for Claude Code and Codex, a plain command, a report and an interactive map.
Where it will not help
- Dependencies created at run time: dependency injection, reflection, generated code. The graph holds what the source states.
- Vendored and minified bundles are left out of the graph, so an import of one has no target.
- Architecture layers come from folder names; on a library with no such folders they are guesses, and the report says which.
Before you install
- My agent already has grep. Why does it need a graph?
- Text search finds lines that match a pattern; the agent then reads files to work out what depends on what. A code graph answers the structural question directly: which files depend on this one, what a change can break, which few files to read first. On 55 questions the agent with Wingbox read -35 % tokens and gave the complete list on all 55; with search alone it was complete on 48.
- Does Wingbox send my code anywhere?
- No. The graph is built and queried on your machine by deterministic static parsing: no LLM call, no embeddings, no vector database, no network access. The container image runs with the network switched off.
- How do I know the graph is right?
- Every answer can be traced to an import statement. In the benchmark the graph of seven corpora was compared with resolvers that share no code with Wingbox, and the impact command named the complete list of dependent files on 100 of 100 questions drawn at random. The scripts are public and a container reproduces the run.
- Which agents and languages does it work with?
- Claude Code, Codex and other clients that support agent skills; the command also runs on its own. Languages: Python, TypeScript and JavaScript, Rust, C#, Java, Go, Ruby and Rails, Free Pascal and Lazarus.
- Does it replace a compiler or a language server?
- No. It is an architecture and impact-analysis tool. Dependencies that are not explicit in the source, such as generated imports, runtime dependency injection or reflection, are not in the graph and have to be checked against the running application.
- How long does it take on a real repository?
- Seconds. Building the graph, the report and the map of FastAPI, 1,227 files, takes 3.2 s from a fresh checkout on a hosted runner. An impact answer comes back in about half a second.
Wingbox is the engine behind Agent Control, the fixed-price audit of agent-written code by Aileron Technologies.