Why We Replaced 2,000 Security Alerts with an Autonomous Graph Agent (Powered by FalkorDB & Gemini)

🚨 The 2:00 AM PagerDuty Nightmare

It is 2:00 AM on a Saturday. Your phone shrieks with a PagerDuty high-severity alert.

Your container scanner (Trivy, Snyk, or Prisma) has discovered a CVSS 9.8 Critical Remote Code Execution vulnerability. Your heartbeat spikes, you stumble out of bed, open your laptop, and start hunting through terminal logs and Kubernetes manifests.

After 45 minutes of frantic investigation, you realize the vulnerable package is sitting in an internal, air-gapped analytics batch worker with zero incoming network connections. It can’t receive traffic from the internet. It has zero access to customer credentials. An attacker couldn't reach it if they tried.

Meanwhile, three rows down in your backlog sits a seemingly lower-priority CVSS 7.5 vulnerability. Unbeknownst to anyone, this one is running directly on your public-facing authentication gateway, which possesses read-write access to your PostgreSQL database storing 4.2 million unencrypted customer records.

This is the fundamental crisis of modern cybersecurity: we are drowning in alerts but starving for context.

🧩 The Core Problem: Flat Data vs. Connected Reality

Traditional security tooling evaluates software vulnerabilities in isolation:

Real Risk ≠ CVSS Base Score

A CVSS score measures theoretical severity in a vacuum. It knows nothing about:

Network Topology: Is this container reachable from 0.0.0.0/0 via an ingress gateway?
Access Privileges: Does this service have credentials to query Crown Jewel datastores (PII, PCI-DSS vaults)?
Runtime Call Graphs: Does the application even invoke the vulnerable method at runtime?
Ownership: Who is the on-call engineer responsible for patching it?

Attempting to answer these multi-hop questions using relational SQL databases requires nightmare recursive JOIN statements that buckle under scale.

To solve this, we built Blast Radius for the FalkorDB Graph Hackathon 2026 (Track: Agents That Act on Connected Data).

💡 The Solution: Blast Radius

Blast Radius is an autonomous cybersecurity triage agent that projects cloud infrastructure into a real-time FalkorDB Knowledge Graph and deploys an autonomous Google Gemini 3.8 Flash agent to trace, reason over, and remediate attack paths.

text
┌────────────────────────┐
│ Public Internet │
└───────────┬────────────┘
│
▼
┌────────────────────────┐
│ Public API Gateway │
└───────────┬────────────┘
│
▼
┌────────────────────────┐
│ Auth Service │ ──[DEPENDS_ON]──► log4j-core 2.14.1
└───────────┬────────────┘ (CVE-2021-44228)
│
▼
┌────────────────────────┐
│ Customer DB (PII) │ ◄── [Crown Jewel Exposed!]
└────────────────────────┘

Instead of asking security engineers to manually cross-reference network diagrams with CVE feeds, Blast Radius lets the agent query FalkorDB directly:

"Can an untrusted actor on the public internet traverse our service call graph to exploit this package, and what sensitive databases can they touch if they do?"

⚡ Why FalkorDB? (The Power of GraphBLAS)

When designing an autonomous AI agent that makes real-time decisions, tool latency is everything. If your agent has to wait 3 seconds for a graph traversal query to return, multi-step chain-of-thought loops grind to a halt.

We chose FalkorDB because of its underlying foundation: GraphBLAS.

FalkorDB represents graph traversals as sparse matrix multiplications using linear algebra. Instead of pointer-chasing through deep adjacency lists, FalkorDB executes graph pattern matching through highly optimized, cache-friendly matrix operations.

The Results in Production:
Multi-hop ingress path traversal (3–5 hops): Executed in 0.38 milliseconds.
Negative pattern existence check (air-gap proof): Executed in 0.29 milliseconds.
Memory footprint: < 45 MB in Docker, booting in milliseconds with Redis protocol compatibility.
🔍 The openCypher Magic Behind the Agent

Here is a look at the exact openCypher queries our Gemini agent executes on FalkorDB:

1. Ingress Attack Path Reachability cypher MATCH (inet:Internet)-[e1:CALLS*1..3]->(svc:Service)-[e2:DEPENDS_ON]->(pkg:Package {cveId: $cveId}) OPTIONAL MATCH (svc)-[e3:READS]->(ds:DataStore {isCrownJewel: true}) RETURN inet.name AS ingress, svc.name AS affectedService, pkg.name AS package, pkg.version AS version, ds.name AS crownJewelTarget, ds.classification AS dataClassification, length(e1) + 1 AS hopsCount;

Outcome: In less than 1ms, FalkorDB returns whether an external attacker has a navigable path from the public perimeter to the vulnerable library.

1. Auto-Suppressing 94% of Alert Noise

If a CVE cannot be reached from the public boundary, the agent mathematically verifies its air-gapped isolation:

cypher
MATCH (pkg:Package {cveId: $cveId})<-[:DEPENDS_ON]-(svc:Service)
WHERE NOT EXISTS {
MATCH (:Internet)-[:CALLS*1..5]->(svc)
}
RETURN svc.name AS isolatedService, pkg.name AS package, "SUPPRESSED_AIR_GAPPED" AS verdict;

Outcome: The alert is autonomously suppressed and archived with mathematical proof. The on-call engineer is never woken up.

1. Measuring Crown Jewel Blast Radius

If an exploit path exists, the agent inspects all outbound data access edges:

cypher
MATCH path = (svc:Service {id: $serviceId})-[:READS|CALLS*1..2]->(ds:DataStore {isCrownJewel: true})
RETURN ds.name AS targetStore,
ds.classification AS complianceTag,
ds.recordsCount AS recordsAtRisk,
nodes(path) AS blastPath;

Outcome: The agent determines that the service can reach Customer DB (PII), containing 4,200,000 customer records, triggering immediate regulatory escalation under GDPR and PCI-DSS Tier 1 protocols.

🤖 An Agent That Doesn't Just Alert—It Acts

Most security dashboards show you a problem and leave you to fix it. Blast Radius follows through with autonomous remediation:

Creates GitHub Pull Requests: Automatically inspects the dependency manifest (pom.xml / package.json), generates the version bump diff (e.g., bumping log4j-core from 2.14.1 to 2.17.1), and opens a PR with SLSA Level 3 provenance.
Generates Zero-Trust Kubernetes Policies: Constructs a live Calico/Cilium NetworkPolicy to immediately isolate the compromised pod while the patch deploys.
Escalates to the Real Service Owner: Queries: Team-[:OWNS]->:Service in FalkorDB to find @alex.chen and opens a pre-populated Jira ticket, while broadcasting an incident briefing directly into #sec-incidents on Slack.
🧠 Key Learnings from the Hackathon

Building Blast Radius taught our team three invaluable lessons about graph databases and AI agents:

Knowledge Graphs Are the Ultimate Guardrail for LLMs:
LLMs are prone to hallucinations when given unstructured walls of logs. When grounded in a FalkorDB property graph, the agent receives strict, deterministic relational facts (hops, protocols, ports, classifications). Its reasoning becomes reproducible and auditable.

GraphBLAS Redefines What's Feasible in Real Time:
Sub-millisecond graph query times allow agents to explore candidate hypotheses iteratively (branching paths, checking ownership, evaluating downstream consumers) without perceptible lag.

Context is the Cure for Alert Fatigue:
By treating security as a connected graph problem rather than a tabular list problem, we eliminated 94% of noise while accelerating triage for critical threats from hours to seconds.
🚀 Try It Out
GitHub Repository: https://github.com/srujan1-creator/blast-radius
Built for: FalkorDB Graph Hackathon 2026 — Track: Agents That Act on Connected Data
Tech Stack: FalkorDB (GraphBLAS), Google Gemini 3.8 Flash, React 19, Tailwind CSS v4, D3.js, Web Audio SOC API.

Special thanks to the FalkorDB team for building an exceptionally fast, developer-friendly graph database.