Imagine this scenario: It’s 2:00 AM, and your SOC detects that an external contractor’s laptop was compromised. His username is Dave.

You check Dave’s permissions in AWS IAM: he only has access to a couple of staging deployment scripts. He has zero direct permissions on the production Postgres database containing 500,000 customer credit card records.

According to traditional rule engines and vector-based AI assistants, you are safe.

Except you aren't.

Three hours later, your production data is dumped on the dark web. How did an unprivileged contractor bypass your security perimeter without triggering a single alarm?

This is the exact problem we set out to solve with BreachPath, an autonomous cloud security agent built for the FalkorDB Hackathon (Track 1: Agents That Act on Connected Data).

The Blind Spot: The Multi-Hop Trap

In modern cloud environments, security breaches rarely happen in a straight line. Attackers don't break through steel doors; they crawl through the vents using transitive privilege escalation:

[Dave (Contractor)]
       │ (MEMBER_OF)
       ▼
[Contractors-Dev-Group]
       │ (CAN_ASSUME)
       ▼
[StagingDeployerRole]
       │ (ATTACHED_TO)
       ▼
[CI-Runner EC2 Instance]
       │ (HAS_ACCESS_TO)
       ▼
[CI_KMS_KEY (Env Var)]
       │ (DECRYPTS)
       ▼
[ProdAdminSecret]
       │ (GRANTS_ACCESS_TO)
       ▼
[CustomerData-Postgres-Prod] 🚨 CROWN JEWEL COMPROMISED

Why Vector RAG Completely Fails Here

Many modern AI security tools rely on Vector RAG (embeddings stored in vector databases).

If you ask a Vector RAG agent: "Can Dave reach the customer database?", the embedding of "Dave" and "Customer Database" have near-zero semantic similarity. Vector search computes vector proximity in high-dimensional space—it cannot traverse relationships, compute graph reachability, or find shortest paths.

To solve connected problems, the agent needs a graph as its context layer.

Enter BreachPath: An Agent Driven by FalkorDB

Instead of bolting a database onto the side of an LLM as a passive archive, BreachPath makes FalkorDB the active cognitive layer for the agent.

We modeled our cloud infrastructure as a dynamic graph:

• Nodes: IAM Users, Groups, Roles, EC2 Compute, KMS Keys, and S3/RDS Databases.
• Edges: Relationships like MEMBER_OF, CAN_ASSUME, ATTACHED_TO, and DECRYPTS.

1. Multi-Hop Reasoning via Cypher Queries

When an alert triggers on Dave’s account, the agent queries FalkorDB using Cypher’s shortestPath() algorithm:

MATCH p = shortestPath((u:User {name: 'dave-contractor'})-[*1..7]->(t:Storage {classification: 'CrownJewel'}))
RETURN p

In under 4 milliseconds, FalkorDB uncovers the hidden 6-hop lateral movement chain that would have taken a human security team days of manual log-digging to find.

2. Graph Algorithms as MCP Tools

We wrapped FalkorDB’s graph algorithms into Model Context Protocol (MCP) tools:

• find_attack_paths: Discovers all transitive routes to sensitive assets.
• calculate_blast_radius: Uses neighborhood degree centrality to compute a numerical risk score (0 to 100) quantifying total exposure.
• find_chokepoints: Performs cut-point analysis to identify the single relationship whose removal breaks the attack chain with minimum operational disruption.

3. Autonomous Remediation (Not Just Chat)

Judges and security teams don’t just want advice—they want closed-loop remediation.

Based on the graph topology, BreachPath identifies that severing the CAN_ASSUME relationship between Contractors-Dev-Group and StagingDeployerRole neutralizes the threat. The agent:

1. Deletes the edge directly in the live FalkorDB Cloud graph.
2. Auto-generates a least-privilege Terraform HCL policy to permanently enforce the fix in production.

What We Learned Building with FalkorDB

1. Graphs Must Shape Agent Decisions, Not Sit on the Side

Most AI agent projects fail because they use databases as dumb scratchpads. Putting FalkorDB at the center meant the graph’s topology dictated what the agent investigated next, which MCP tool it invoked, and when it was confident enough to take action.

2. Sub-Millisecond Latency is a Superpower

Because FalkorDB is built on top of Redis technologies, graph queries execute in single-digit milliseconds. When an agent is running iterative multi-hop traversals inside a tight reasoning loop, this low latency is the difference between an instantaneous real-time response and a frustrating timeout.

3. Deterministic Explainability Beats Black-Box Guesses

You can never tell a Chief Information Security Officer (CISO): "The LLM felt this account was suspicious."

With BreachPath and FalkorDB, every remediation decision is accompanied by the exact node-by-node audit trail. The agent can prove mathematically why a link was cut and show the visual before-and-after graph.

Try It Out

BreachPath is fully open-source with an interactive cyber-ops dashboard, live graph animations, and Web Audio effects:

• 📦 GitHub Repository:

  AKSA119 / breachpath

  🛡️ BreachPath — Autonomous Cloud Attack Path & Blast-Radius Remediator

  FalkorDB Hackathon Submission
  Track: Track 1: Agents That Act on Connected Data
  Theme: Multi-hop reasoning, graph algorithms as tools, tool selection through MCP, autonomous remediation, and explainable results.

  💡 The Problem

  In modern cloud architectures (AWS/GCP/K8s), security risks are rarely a single direct vulnerability. Instead, attackers use multi-hop privilege escalation: an external contractor account with minimal permissions can assume a role, connect to a CI runner, read an unencrypted KMS key, and unlock the Crown Jewel production database.

  Vector search and traditional LLMs completely fail here because:

  1. They cannot compute graph reachability or transitive permissions.
  2. They cannot run graph path algorithms (Shortest Path, Chokepoint analysis, Min-Cut).
  3. They cannot guarantee an explainable, deterministic audit trail.

  🚀 The Solution: BreachPath

  BreachPath places FalkorDB at the center of the agent's context layer:

  • Knowledge Graph: Maps Users, IAM Groups, Roles, EC2 Instances, KMS…

  View on GitHub
• 🛠️ Built With: FalkorDB Cloud, Python, Vis.js, and Model Context Protocol (MCP).

If you're building AI agents, stop asking them to guess relationships—give them a graph.