Deterministic Analysis vs. AI Agents
CXGRD computes blast radius using dependency graph traversal — a deterministic analysis of real import, call, and reference relationships in your codebase. This page explains what that means and how it differs from AI agent-based code review tools.
The core difference
An AI agent (like an LLM-based code review tool) reads a diff and infers what might be affected, based on pattern matching over the code it's shown. Its output is a judgment — probabilistic, and it can miss relationships that aren't visible in the diff it was given, or hallucinate connections that don't exist.
CXGRD instead builds an explicit graph of your codebase's real dependencies — which files import which, which functions call which — and traces a change through that graph mechanically. A dependency edge either exists in the graph or it doesn't. There's no inference step where an edge could be missed or invented.
Why this matters in practice
| AI agent interpretation | CXGRD dependency graph | |
|---|---|---|
| Basis | Model's reading of the diff | Actual import/call relationships |
| Consistency | Can vary between runs on the same input | Same input always produces the same result |
| Failure mode | Can miss or hallucinate a relationship | Can only miss relationships the graph itself doesn't model (e.g. dynamic imports) |
| Explainability | "The model flagged this as risky" | "File X imports function Y, which changed" — a traceable path |
Where AI still adds value
CXGRD isn't anti-AI — Pro and Team tiers use an LLM (Groq) for prompt enrichment: turning a computed blast radius into a clear, readable prompt for feeding into an AI coding assistant's context window. The graph traversal that determines what is affected stays deterministic; the LLM's job is limited to explaining that result in natural language, not deciding it.
This is also where CXGRD complements tools like Cursor or Claude Code rather than competing with them: those tools govern the actions an AI agent takes while writing code. CXGRD governs the consequences of a change once it exists — checking blast radius before merge, regardless of whether the code was written by a human or an AI assistant.
Comparison to other code-review agents
Tools like Potpie use an AI agent to understand code changes and estimate blast radius from the agent's interpretation of the diff. CXGRD's blast radius comes from graph traversal over your codebase's actual structure, independent of any single model's read of a given PR. Both approaches aim at a similar problem; they differ in whether the underlying computation is a deterministic graph query or a model's inference.