AWS Builder Center

Blast Radius

BlastRadius is an autonomous PR triage and codebase governance agent powered by FalkorDB for Track 01. While Vector RAG is blind to code dependencies, BlastRadius traverses 4-hop call cascades in under 1.2ms using GraphBLAS pointer chasing—425x faster than SQL CTEs. It scores PR risk, issues automated BLOCKED vs APPROVED verdicts, traces CVE breach paths via algo.SPpaths, and clones isolated test sandboxes in 8ms using native GRAPH.COPY, completely eliminating blind production merges.









Why Vector RAG Falls Short in Code Review: Building BlastRadius with FalkorDB

Every engineering team knows how quickly a seemingly harmless code change can turn into a production incident.
A developer updates a helper function in a shared authentication library. Unit tests pass locally. CI turns green. The pull request gets merged.
Twenty minutes later, PagerDuty starts firing. Payment processing is down. Inventory synchronization is failing. The public mobile API gateway is returning errors.
One small change. Three downstream services affected.
The problem isn't necessarily the code itself. It's the dependencies nobody noticed.
Modern codebases aren't collections of isolated files. They're deeply interconnected graphs of functions, modules, services, APIs, and dependencies. Yet many AI-powered coding assistants rely heavily on Vector Retrieval-Augmented Generation (RAG) to reason about codebases.
Vector search is excellent at finding semantically similar code. But similarity is not dependency, and relevance is not impact.
That's the problem we set out to solve with BlastRadius—an autonomous PR triage and codebase governance agent powered by FalkorDB, designed to trace multi-hop dependency chains and surface the potential impact of code changes in milliseconds.

The Blind Spot of Vector RAG

Vector RAG represents code as dense semantic embeddings and retrieves snippets based on similarity to a query.
Ask it to find a payment processor, and it might retrieve  payment_service.py ,  checkout_helper.py , or another function with similar terminology. For code discovery, this is useful.
But breaking-change analysis requires a fundamentally different question:
What depends on this code, and how far can the impact propagate?
A semantic search alone cannot reliably establish:
  1. Direct dependencies: Which modules or services import or call the modified symbol?
  1. Transitive dependencies: Which callers are affected across four or more dependency hops?
  1. Execution-path exposure: Can a changed function affect a publicly accessible API endpoint?
  1. Cross-service impact: Which downstream services rely on the modified behavior, even when their code contains no obvious keyword overlap?
These are structural questions, not semantic ones.
In our benchmark, Vector RAG achieved just 20% recall on the evaluated breaking-change detection task. It missed transitive cross-service callers whose relationships were not discoverable through semantic similarity alone.
The takeaway isn't that vector search is useless. It's that vector search cannot replace an explicit dependency graph when correctness depends on connectivity.

Why Not Just Use Relational SQL?

If vector search cannot reliably reconstruct dependency chains, why not store the relationships in PostgreSQL or MySQL?
You can. Relational databases support recursive Common Table Expressions (CTEs), which can traverse hierarchical and graph-like relationships. For many workloads, they are perfectly adequate.
However, deep dependency analysis can become expensive when recursive traversal repeatedly joins large relationship tables, especially as graph size, connectivity, and query complexity increase.
In our benchmark, a four-hop blast-radius query over a 95-node service topology took approximately 385.2 milliseconds using our SQL implementation.
That latency matters in a pull-request workflow. A review agent may need to evaluate dependency impact, inspect security exposure, create an isolated test environment, and return a verdict before a developer loses context or CI becomes a bottleneck.
At enterprise scale, the challenge becomes even more significant: thousands of modules, tens of thousands of symbols, and dependency chains that cross repository boundaries.
The issue isn't that SQL cannot represent graphs. It's that repeated recursive joins are not always the most efficient execution model for graph-native workloads.
We wanted a database designed around the relationships themselves.

Enter FalkorDB: Graph Traversal at Millisecond Latency

FalkorDB provides a graph-native approach to dependency analysis, allowing BlastRadius to model code relationships as nodes and edges and query them using Cypher.
Instead of treating dependencies as rows that must be repeatedly joined, BlastRadius represents the codebase as a graph:
  • Nodes: Functions, classes, modules, services, API endpoints, and third-party packages.
  • Edges: Imports, function calls, service dependencies, endpoint exposure, and other relevant relationships.
  • Properties: Ownership, repository, version, criticality, and architectural metadata.
This representation makes dependency traversal a first-class operation.
When a pull request modifies a function, BlastRadius can traverse outgoing or incoming relationships, depending on how the graph is modeled, to identify affected callers and downstream components. It can then rank the results by dependency depth, architectural importance, and exposure.
FalkorDB's graph-query architecture, built around sparse graph representations and optimized graph operations, makes it a natural fit for this kind of workload.
In our benchmark, a four-hop blast-radius query completed in as little as 0.85 milliseconds, with another measured run recorded at 1.18 milliseconds.
That's the difference between a query that can fit comfortably into an interactive review workflow and one that may introduce a noticeable delay.

Head-to-Head: Our Benchmark Results

Metric
SQL / Vector RAG
FalkorDB
Four-hop blast-radius query
385.2 ms
1.18 ms
Breaking-change recall
20% for Vector RAG
100% on the evaluated graph
Ephemeral graph copy
45 seconds for the SQL dump-and-restore workflow
8 ms using GRAPH.COPY
The SQL comparison shows a roughly 326× speedup for the 385.2 ms versus 1.18 ms measurements. Comparing 385.2 ms against the 0.85 ms best-case measurement yields approximately 453×.
The recall result deserves an important distinction: 100% recall means every expected affected node was retrieved in the evaluated test graph. It is not a guarantee of perfect results for every real-world codebase; completeness depends on the accuracy and coverage of the underlying dependency graph.
Likewise, these latency figures describe our measured workloads, not universal performance guarantees. Database configuration, graph structure, query shape, and workload size all influence results.

How BlastRadius Works

BlastRadius connects GitHub pull-request events to an autonomous analysis pipeline using webhooks and the Model Context Protocol (MCP), implemented with FastMCP.
When a pull request opens or updates, the agent performs four stages of analysis.

1. Multi-Tier Impact Analysis

BlastRadius traces affected symbols and groups the results into three impact tiers.
Tier 1 — Direct Callers
Identifies immediate callers and dependent modules within the local package or service. These are the components most likely to experience a direct behavioral change.
Tier 2 — Transitive Callers
Traverses deeper dependency chains to uncover indirect consumers across package and service boundaries. A function may have only two direct callers but still influence dozens of downstream components.
Tier 3 — Public Perimeter
Connects internal dependency paths to externally exposed API endpoints. This helps reviewers understand whether a seemingly internal change could affect customer-facing functionality.
Rather than presenting an unstructured list of affected files, BlastRadius gives reviewers a layered view of how a change can propagate through the system.

2. CVE Exposure and Exploit-Path Analysis

Dependency updates can introduce or resolve security vulnerabilities. But identifying a vulnerable package is only part of the problem.
The more important question is whether an attacker can reach the vulnerable code.
When a pull request changes a dependency associated with a known CVE, BlastRadius can use graph-path analysis to investigate whether a path exists between an externally reachable, potentially unauthenticated API endpoint and the vulnerable component.
Using FalkorDB's shortest-path capabilities, the agent can surface potentially dangerous execution paths and prioritize them for review.
For example, if a public endpoint can reach a vulnerable function through several internal services, the pull request can be flagged as a potential critical security issue.
This is reachability analysis, not proof of exploitability. Authentication checks, runtime conditions, data flow, vulnerability prerequisites, and other security controls must also be evaluated before concluding that an exploitable attack path exists.

3. Ephemeral Graph Sandboxes with  GRAPH.COPY 

Testing risky changes against production state is dangerous. Reconstructing a complete test environment for every pull request can also be expensive.
BlastRadius uses FalkorDB's native  GRAPH.COPY  command to create an isolated copy of the dependency graph for analysis and testing workflows.
In our benchmark, graph copying completed in approximately 8 milliseconds.
The agent can use this isolated graph to evaluate hypothetical dependency changes, simulate alternative relationships, and test graph-based impact scenarios without modifying the original graph.
This is particularly useful for schema migrations, architectural changes, and integration-test preparation.
One distinction matters: copying the graph isolates graph state, not the entire application environment. Database records, containers, external services, and other runtime resources must be isolated separately when tests require them.

4. Automated Verdicts and Review Assignment

Once impact analysis is complete, BlastRadius combines several signals to help determine the appropriate review path:
  • Blast radius: How many dependencies are affected, and how deep do the dependency chains extend?
  • PageRank centrality: How structurally important is the modified component within the dependency graph?
  • Architectural compliance: Does the change conflict with recorded Architecture Decision Records (ADRs) or known architectural constraints?
  • Code ownership: Which developers or teams are responsible for the affected components?
BlastRadius can then produce an  APPROVED  or  BLOCKED  recommendation, attach its findings to the pull request, and assign the relevant code owners.
For a production deployment pipeline, hard approval or blocking decisions should be governed by explicit policies, confidence thresholds, and appropriate human-review safeguards. Graph centrality or dependency depth alone should never determine whether a change is safe.
The result is a review workflow that moves beyond asking whether the code looks reasonable and starts asking whether its consequences are understood.

The Core Takeaway: The Graph Is the Architecture

There's a useful principle in software engineering: if removing a component changes nothing about the system, that component may not be doing meaningful work.
The same question applies to graph databases.
If BlastRadius can replace its graph-traversal engine without affecting dependency-analysis latency, path accuracy, or sandbox performance, then the graph layer may be unnecessary complexity.
But in our implementation, FalkorDB is central to how the system reasons about code relationships.
Without it, BlastRadius would need an alternative way to traverse multi-hop dependencies efficiently, maintain a queryable representation of architectural relationships, and reproduce graph state for isolated analysis.
The impact would extend beyond raw query latency. It would affect the responsiveness of pull-request triage, the depth of dependency analysis, and the cost of repeatedly evaluating architectural changes.
Codebases are graphs. Code changes propagate through those graphs. Code review should account for both.
BlastRadius brings dependency-aware reasoning into the pull-request lifecycle, combining graph traversal, security-path analysis, isolated graph experimentation, and automated review workflows.
Because passing tests tell us that the code works under the conditions we tested.
They don't tell us what else might break when we ship it.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article