WeMakeDevs — Graph Hacks: Context for AI AgentsTeam: CybSecNetworkProtocol

ThreatNexus

“Connecting Context. Exploring Relationships. Enabling More Coherent AI Investigations.”

ThreatNexus is a graph-based, context-aware AI investigation platform exploring how connected data, preserved context, and relationships between entities can support more coherent multi-step AI investigations.

* Live AI Agent deployed on Railway (diplomatic-integrity-production-5695.up.railway.app). Verified operational.

ThreatNexus / ContextGraph AI — Spatial Intelligence Workspace (localhost:3000)
ThreatNexus Platform Overview Dashboard showing spatial knowledge graph and multi-hop reasoning workspace
Click to inspect full high-resolution dashboard

Figure 1.0: Genuine screenshot of the deployed ThreatNexus spatial computing environment.

Section 01 // Project Background & Problem Statement

The Context Fragmentation Dilemma in AI-Assisted Security Operations

Why modern autonomous security agents frequently fail in multi-stage investigations, and how the absence of persistent graph memory compromises triage accuracy.

In modern Security Operations Centers (SOCs), autonomous AI agents are increasingly tasked with alert triage, incident response, and root-cause analysis. However, real-world cyber attacks rarely unfold as isolated, single-event occurrences. Advanced Persistent Threats (APTs) execute complex, multi-stage kill chains that span across weeks, multiple hosts, disparate credentials, and divergent telemetry streams.

The Core Premise of Context Fragmentation

When an AI agent is invoked to triage an anomalous database query on a production server, it lacks immediate memory that a perimeter jumpbox was triaged 48 hours earlier for an LSASS credential dump involving the very same service account.

Traditional Retrieval-Augmented Generation (RAG) paradigms rely heavily on vector embeddings and cosine similarity. While vector search excels at retrieving semantically similar unstructured documents, it is fundamentally ill-suited for answering structural, multi-hop questions such as:

“Did any credential extracted from Host-Finance-01 authenticate against SQL-PROD-09 within the last 72 hours across any previous investigation session?”

Without a graph representation of connected entities (nodes) and explicit relationships (edges), the agent suffers from relational blindness. It treats each incoming log record as an isolated string of text rather than a node in an evolving attack graph.

Scope Distinction: Industry Problem vs. Prototype Scope

While context fragmentation is a broad challenge across distributed autonomous AI systems, our hackathon prototype, ThreatNexus, specifically targets a focused demonstration: simulating how graph-preserved memory triples bridge an initial triage session (E-101 on Host-Finance-01) with a subsequent investigation session (E-102 on SQL-PROD-09).

Four Critical Dimensions of Failure

Fragmented Historical Context

Session Amnesia

Most contemporary AI agents process information within stateless execution windows. Once a chat or autonomous run terminates, the contextual deductions, intermediate hypotheses, and triage state are discarded. When a new alert surfaces hours or days later, the agent starts from scratch.

Disconnected Cross-Record Relationships

Relational Blindspots

Security operations produce siloed logs: Windows Event ID 4624 in Active Directory, Suricata network flow alerts, Kerberoast ticket logs, and PostgreSQL transaction logs. Traditional vector embeddings look for semantic keyword similarity rather than multi-hop structural causality.

Limited Continuity Between Sessions

Investigation Isolation

In a real-world APT intrusion, adversaries operate slowly. An initial access breach on Monday might pivot to privilege escalation on Wednesday and data exfiltration on Friday. Without persistent entity linkage, separate agent invocations fail to correlate these stages as a unified campaign.

Opaque Contextual Basis & Hallucination

Explainability Deficit

When an LLM summarizes a complex security alert, security engineers cannot immediately verify which exact log entries or entity pivots justified the agent’s conclusion. Without an inspectable graph topology, analysts struggle to distinguish verified facts from probabilistic inferences.

Section 02 // Our Technical Approach

Graph-Native Context Engineering for AI Investigations

How ThreatNexus unites knowledge graph topologies, multi-agent reasoning, and persistent memory banks to overcome the limitations of isolated vector search.

Entities as Graph Nodes

Security artifacts are mapped to typed nodes: Hosts, Database Instances, User Accounts, Executable Files, IP Addresses, and CVE Vulnerabilities. Each node maintains provenance hashes and risk posture metadata.

10 Structured Entities in Prototype

Explicit Relational Edges

Causal, operational, and network relationships are represented as directed edges: LATERAL_PIVOT, AUTHENTICATED_VIA, EXPLOITED_BY, and EXTRACTED_CREDENTIAL. Edge weights reflect confidence scores.

10 Attributed Causal Links

Cross-Session Memory Triples

Deductions from completed investigations are persisted into a structured graph memory bank. Memory triples preserve the semantic conclusion (e.g. Host-Finance-01 -> COMPROMISED_ACCOUNT -> svc_backup) for future queries.

3 Historical Investigation Sessions

Explainable Provenance Chain

Instead of opaque conversational answers, every conclusion maps to a verifiable provenance chain. Analysts inspect raw Sysmon/Zeek snippets, SHA-256 hashes, and fact classifications (Facts vs Inferences).

Multi-Hop Verification Path

End-to-End Investigation Workflow Pipeline

From raw multi-source telemetry to cross-session memory synthesis and subsequent investigation recall.

Responsive SVG / HTML Pipeline
01Raw Telemetry

Investigation Data

Ingest raw disparate security logs

02Entity Extraction

Context & Relationships

Extract entities & semantic links

03FalkorDB / Canvas

Graph Exploration

Interactive topology traversal

04E-101 Agent Triage

Agent Investigation

Autonomous multi-stage reasoning

05Memory Triples Bank

Context Preservation

Store verified memory triples

06E-102 Cross-Session Recall

Subsequent Investigation

Cross-session context recall

01
Investigation Data— Raw Telemetry
Click any step above to inspect

Sysmon event logs, Zeek network connections, perimeter auth records, and database transaction queries are normalized into structured evidence with cryptographic hashes.

Section 03 // Technical Architecture

Multi-Tier Conceptual Architecture & Integration Paths

A strictly decoupled architecture isolating client presentation from graph database queries and LLM prompt orchestration.

🌐 Feature Deep-Dive & Graph Architecture

1. Scenario Explorer & Contextual Memory

ThreatNexus doesn't just store logs; it structures them. Every multi-agent investigation session is treated as an isolated Subgraph. Instead of relying on linear vector search that loses structural relationship data, our framework maintains a stateful context. This allows AI agents to perform complex Graph Traversal across past steps, ensuring no context drift happens during deep investigations.

2. Interactive Graph Explorer

This is where FalkorDB's true speed comes to life. ThreatNexus visualizes the entire blast radius of a security incident by mapping entities as Nodes (e.g., Malicious IPs, Compromised Users, File Hashes) and their interactions as Edges (e.g., ACCESSED, DOWNLOADED, MUTATED).

  • Users can physically interact with the graph, expanding nodes to query connected threats in real-time.
  • Provides clear explainability by showing exactly why an AI agent flagged a specific correlation path.

Client Tier — Analyst BrowserActive Prototype

Responsive Single-Page Web App • WebGL Canvas • Zero Browser Secrets

View Specs →
HTTP / JSON REST API & Typed Adapter

Frontend Application Tier — Next.js 16 & React 19Standalone Demo + Live Adapter

8 Dashboard Views • Liquid Glass Design • State Context • @xyflow/react

View Specs →
NEXT_PUBLIC_API_URL: http://localhost:8000/api/v1 (Decoupled)

Backend API Layer — Python API ServiceContract Ready / In Development

FastAPI / Flask • Secure Credential Vault • Cypher Query Orchestration

View Specs →
Graph Engine — FalkorDB

Entity Nodes & Relationship Edges

Server-side Cypher Query Execution
Agent Engine — E-101 & E-102

Multi-Hop Path Traversal & Triage

Native Graph Context Reasoning

React / Next.js Frontend Layer

Production Ready Prototype
Click any layer card above to inspect specifications

Decoupled from database drivers. Uses synthetic cybersecurity datasets (E-101 to E-110) when running in standalone demo mode.

Primary Responsibilities
  • •Next.js 16 App Router & React 19 component hierarchy
  • •Stateful AppContext managing graph topology and cross-session memory
  • •Typed apiClient.ts adapter switching between Simulated Demo Mode and live API
  • •Real-time @xyflow/react node graph with custom Liquid Glass styling
Technology Stack
Next.js 16.4.1React 19TypeScriptTailwind CSS v4Lucide Icons
Decoupled API Contract

As defined in PROPOSED_BACKEND_API_CONTRACT.md, the frontend connects solely to a standard REST API adapter (/api/v1/graph, /api/v1/investigate, /api/v1/sessions). It contains zero database drivers or direct socket connections.

Zero Client Secrets

No backend credentials or server connection secrets are ever transmitted to or stored in client-side browser code. All FalkorDB connections, graph traversals, and Cypher query executions are strictly managed on the server side.

Standalone Demo Parity

When running without an active Python backend, the frontend operates seamlessly via its built-in synthetic telemetry engine (isDemoMode: true), ensuring predictable, zero-setup hackathon review.

Section 04 // Eight Dashboard Views Tour

Comprehensive Tour of the ThreatNexus Workspace

Explore each of the eight specialized views engineered into the ThreatNexus interface, featuring genuine screenshots and verified code implementations.

Spatial WorkspaceRoute: /

Overview Dashboard

The primary mission control center for the security operations analyst. It aggregates platform-wide graph metrics into 4 high-level Liquid Glass metric tiles (Graph Entities, Relationship Edges, Preserved Sessions, Critical Assets).

Key Capabilities & Workflow Mechanics

  • Holographic Graph Stage: Offers toggleable 3D Spatial and 2D Planar views of the active attack topology.
  • Real-time Telemetry Waveforms: Visualizes ingress event entropy (0.89 entropy peak) and C2 beacon cadence (45s pulse).
  • Posture & Dial Gauges: Displays tri-gauge meters for Graph Memory (94%), Threat Severity (38%), and Graph Integrity (99%).
  • Apple Liquid Glass Expanded Tiles: Clicking any metric card opens a modal presenting granular category breakdowns.
Architecture Reference:Implemented in src/app/page.tsx and src/components/spatial/SpatialWorkspace.tsx. Uses SVG orbital nodes and CSS perspective transforms for 3D depth.
Overview Dashboard & Spatial Holographic Stage
Click to enlarge screenshot

Overview Dashboard & Spatial Holographic Stage

Central telemetry showing 10 entities, 10 edges, 3 preserved sessions, 4 critical assets, ingress telemetry, autonomous traversal waveform, and interactive 2D planar / 3D spatial stage.

Section 06 // Verified Technology Stack

Built with Modern, Verified Technologies

Every library and runtime documented below was verified directly against the repository dependencies and configuration files.

Frontend Client Tier
React 19v19.3.0
Core UI Framework

Component hierarchy, concurrent rendering, and reactive context management across all 8 views.

Next.js 16v16.4.1 (Turbopack)
Application Server & Routing

App router architecture, server/client component boundaries, and fast Vercel deployment targets.

TypeScriptv5.x
Type Safety & Contracts

Strict end-to-end data schemas for graph entities, edges, investigation findings, and memory triples.

Tailwind CSS v4 & Custom CSSv4.x + Custom Tokens
Styling & Design System

Apple Liquid Glass design system, backdrop blur utilities, custom glow filters, and responsive layouts.

HTML5 & JSX/TSXModern Standard
Markup & Semantics

Accessible semantic structures, keyboard focus indicators, and screen-reader accessible elements.

@xyflow/reactv12.12.0
Interactive Graph Canvas

Interactive node-link graph visualization with custom SVG node components and bezier edge connections.

Backend & Graph Memory Tier
PythonAPI Service Layer
Backend & Orchestration

Server-side API layer proposed in PROPOSED_BACKEND_API_CONTRACT.md for Cypher queries and graph traversal orchestration.

FalkorDBGraph Memory Layer
Graph Database Engine

Low-latency Redis-based graph database executing openCypher queries for multi-hop entity relationships.

Autonomous Graph ReasoningContext Engine
Multi-Hop Investigation Engine

Deterministic multi-hop path traversal and context synthesis algorithms (Query Decomposition -> Relational Expansion -> Evidence Verification).

Development Environment & AI Agent Pair

Google Antigravity IDEAgentic Coding

AI-Assisted Development Environment

Hackathon Development Acceleration

Advanced agentic pair programming environment utilized by the CybSecNetworkProtocol team to conceptualize, scaffold, debug, and polish the ThreatNexus architecture and blog case study.

Section 07 // UI/UX Philosophy & Design System

Crafting a Spatial Cybersecurity Aesthetic

How we designed an interface that balances rich translucent glassmorphism with high visual readability and operational clarity.

Centralized Navigation

An 8-tier frosted sidebar anchors the entire experience, allowing the analyst to transition between high-level telemetry and granular subgraphs without loss of working context.

Rigorous Visual Hierarchy

Information density is managed through strategic typographic sizing, mono-font metric chips, and subdued midnight backdrops that allow critical-risk alerts to command immediate attention.

Graph-Oriented Data Presentation

Rather than burying security evidence in tables, entities and their causal pivots are presented as navigable nodes and directed edges on an interactive canvas.

Reusable UI Component Primitives

Built on modular components (GlassCard, Badge, Button, Modal, StatCard) with consistent translucent border tokens and specular top sheen highlights.

Visual InspirationApple Liquid Glass Aesthetic

Liquid Glass Expanded Modal Dialogs

To present deeper telemetry without cluttering the main overview dashboard, we created interactive expanded tiles. Clicking on stat cards smoothly expands a rich modal showcasing category breakdowns.

The styling features heavy backdrop blurs (backdrop-filter: blur(20px) saturate(180%)), translucent dark panels (rgba(8, 14, 28, 0.52)), specular top white highlights, and subtle cyan glows.

Design Attribution & Non-Endorsement Notice

The term “Apple Liquid Glass” represents a visual design inspiration drawn from contemporary frosted glass interfaces. This is an independent web implementation by Team CybSecNetworkProtocol and does not represent an official Apple implementation, technology, or endorsement.

Genuine screenshot showing the Apple Liquid Glass inspired modal dialog presenting Investigation Waveform and multi-hop reasoning chain
Inspect Liquid Glass modal

Figure 2.0: Genuine screenshot of the Apple Liquid Glass-inspired Investigation Waveform modal showing true backdrop translucency and multi-hop reasoning chain.

Section 08 // Team & Verified Hackathon Contributors

Team CybSecNetworkProtocol

Developed collaboratively for the WeMakeDevs “Graph Hacks: Context for AI Agents” hackathon.

JM

M. Jai Manikanta

Team Leader, UI/UX Designer Frontend Developer & Blog Deployer

Confirmed Responsibilities
  • •End-to-end frontend architecture in Next.js & React 19
  • •Spatial Holographic Graph UI and Apple Liquid Glass design system
  • •Interactive Graph Explorer, 8 investigation views & mock data pipeline
  • •Frontend integration, documentation & Blog Deployer
RA

Rohan Ahirwar

PPT Designer

Confirmed Responsibilities
  • •Hackathon pitch deck preparation & slide storyline
  • •Competitive research and cybersecurity case study synthesis
  • •Presentation delivery & narrative structuring for judges
Profiles:
DK

Dhruva Khare

Backend Developer, management & Deployment

Confirmed Responsibilities
  • •Python backend API layer setup and endpoint wiring
  • •FalkorDB Cypher graph database integration
  • •Graph schema design, Cypher queries & deployment coordination
Section 09 // Development Journey & Engineering Challenges

Engineering Lessons from the Hackathon Sprint

A reflective analysis of technical hurdles encountered while translating abstract graph-memory theory into a functional, tactile user experience.

Organizing Eight Interdependent Views

Challenge:

Security investigations involve high cognitive load. Splitting the workflow into 8 distinct views (Overview, Scenarios, Graph, Investigation, Sessions, Comparison, Explainability, Health) risked disjointed user navigation.

Engineering Solution:

Engineered a centralized AppContext state provider with a persistent frosted sidebar. Selecting an entity in the Graph Explorer automatically focuses that entity in the Agent Investigation view without full-page reloads.

Making Graph Relationships Intuitively Navigable

Challenge:

Dense node-link diagrams frequently degenerate into an unreadable “hairball.” Analysts struggle to differentiate between informational links and active lateral movement attacks.

Engineering Solution:

Implemented custom SVG node renderers with risk-tiered glowing halos, animated directional bezier curves for active pivots, and a slide-over EdgePanel drawer that reveals raw metadata on demand.

Balancing Glassmorphism with Text Readability

Challenge:

Excessive glassmorphism often leads to poor text contrast, visual clutter, and accessibility issues for operational monitoring.

Engineering Solution:

Restricted translucency to cards and navigation with strict background darkening (0.52 to 0.72 alpha), paired with high-contrast text tokens, specular top sheen lines, and reduced-motion media query support.

Coordinating Frontend & Backend Contracts

Challenge:

Developing the frontend concurrently while backend Cypher queries and graph schema definitions were being tuned required avoiding tight coupling.

Engineering Solution:

Authored PROPOSED_BACKEND_API_CONTRACT.md early in development. Built a standalone Simulated Demo Mode with realistic cyber telemetry, enabling complete UI validation before live backend attachment.

Modal Animations & Interaction State Polish

Challenge:

Rapid clicking between stat tiles and graph nodes caused modal state collisions and unwanted scroll jumps.

Engineering Solution:

Refined React state hooks and isolated modal dialogs with keyboard Escape listeners, focus traps, and backdrop-click dismissals.

Zero-Secret Vercel Deployment Readiness

Challenge:

Ensuring the public showcase could be safely deployed on Vercel without inadvertently leaking backend credentials or database connection strings.

Engineering Solution:

Enforced strict client/server boundaries. All generative AI keys and database connection strings remain exclusively on the Python server; client code uses only NEXT_PUBLIC configuration flags.

Key Takeaways for Context-Aware Agent Architecture

01

Context Requires Structure, Not Just Storage

Simply appending conversation logs into vector embeddings is insufficient for cyber investigations. Causality requires typed entities and directed semantic relationships (openCypher triples) that an agent can traverse multi-hop.

02

Explainability Must Be Granular

Analysts distrust monolithic AI summaries. Decomposing agent outputs into explicit epistemological categories (Facts vs Inferences vs Hypotheses) builds operational trust.

03

Design for the Standalone Reviewer

Hackathon evaluators need to experience the full interaction without installing local databases. Providing a rich simulated demo mode with clear badging ensures immediate usability.

Section 10 // Architectural Analysis: Model Portability

LLM-Agnostic Abstraction & Provider Portability

How the ThreatNexus decoupled architecture supports future model replacements through standardized API schema contracts.

A major vulnerability of early AI prototypes is hardcoding vendor-specific client libraries directly into UI components. ThreatNexus avoids this antipattern by strictly decoupling the client interface from generative model endpoints.

The Next.js frontend has zero hardcoded external AI model SDKs or API key requirements. It solely interacts with the Python REST endpoint POST /api/v1/investigate. Consequently, the underlying reasoning engine can theoretically be integrated with external LLMs or local open-source models in air-gapped SOC environments as long as the backend adapter continues to emit schema-compliant payloads.

Architectural Possibility vs. Active Implementation

Model interchangeability is an architectural capability provided by our decoupled API boundary. In the current hackathon prototype, investigations operate on native graph context memory and FalkorDB Cypher queries with zero reliance on external generative model APIs. Dynamic runtime model-switching toggles are documented as an architectural roadmap item rather than a required production dependency.

Prerequisites for Live Model Replacement

Interface Compatibility & Pydantic Schema

Any replacement model provider must output the exact JSON structure defined in PROPOSED_BACKEND_API_CONTRACT.md (including riskScore, reasoningSteps, and evidenceList with fact classifications).

Backend Prompt & Few-Shot Adaptation

Different foundation models (Claude, Llama 3, GPT-4o) exhibit varying sensitivities to system instructions and Cypher query formatting, requiring prompt tuning on the Python server.

Response Validation & Guardrail Sanitization

Switching models demands server-side JSON schema validators (e.g. Pydantic or Instructor) to prevent schema drift, malformed entity IDs, or non-deterministic field formats.

Automated Regression & Evaluation Suites

Model migrations require evaluation benchmarks to verify that cross-session recall accuracy and reasoning depth are preserved without introducing hallucinations.

Section 11 // Applications, Limitations & Future Scope

Potential Impact, Honest Constraints & Future Roadmap

A transparent assessment of practical use-cases, prototype boundaries, and future research directions for graph-based AI investigation memory.

Potential Practical Applications (Exploratory Concepts)

* Not claimed as production deployments

Security Operations Centers (SOC Tier 1 & 2)

Assisting SOC analysts by automatically clustering incoming SIEM alerts into multi-hop attack graphs and retrieving historical session memory.

Incident Response & Root-Cause Triage

Tracing breach lateral movement from initial perimeter intrusion to core infrastructure assets with verifiable provenance logs.

Cyber Threat Intelligence (CTI)

Correlating observed indicators of compromise (IoCs), adversary TTPs, and campaign infrastructure across disparate threat bulletins.

Digital Forensics & Evidence Correlation

Cataloging evidentiary artifacts with immutable SHA-256 hashes and structuring temporal event sequences for post-incident audits.

Transparent Engineering Limitations

Prototype Synthetic Data vs. Live Telemetry

The current demonstration runs on a curated synthetic dataset (10 entities, 10 edges, 9 logs). It does not ingest millions of unparsed live enterprise event streams.

Explainability ≠ Absolute Ground Truth

Displaying provenance graphs and epistemic classifications aids human verification but does not mathematically eliminate LLM reasoning error or hallucination.

Graph Topology Quality Dependency

The accuracy of multi-hop deductions is bounded by the quality and completeness of extracted relationships. Incomplete telemetry creates missing edge blindspots.

Enterprise Production Readiness

Full production deployment would require multi-tenant role-based access control (RBAC), SOC-2 compliance, data redaction, and audited latency SLAs.

Future Scope & Architectural Roadmap

Near-Term

Richer openCypher Query Generation

Empower agents with automated Cypher generation to query FalkorDB dynamically based on freeform natural language questions.

Mid-Term

Hybrid Vector-Graph Hybrid Memory

Combine semantic vector retrieval with deterministic graph traversals for richer contextual entity synthesis.

Long-Term

Live SIEM / EDR Ingestion Connectors

Develop streaming ingest pipelines connecting directly to CrowdStrike, Splunk, and Zeek network taps.

Section 12 // Project Presentation & Video Demo

ThreatNexus Live Walkthrough & Pitch Demo

Watch Team CybSecNetworkProtocol demonstrate cross-session graph memory, multi-hop reasoning, and the interactive spatial dashboard.

Configured via SITE_CONFIG.links.demoVideoYouTubeId
Watch on YouTube

Live AI Agent DeploymentRailway Online

Interact directly with the live deployed ThreatNexus AI Agent exploring graph context memory and multi-hop correlation.

Launch Live Agent
Section 13 // Technical References & Documentation

Authoritative Technical Documentation

Direct citations and documentation links for the core specifications, frameworks, and database architectures referenced throughout the project.

UI Library

React Official Documentation

Official guide, API reference, and design principles for React 19 concurrent features and hooks.

Language Specs

TypeScript Documentation

Language specification and typing guidelines for robust interfaces, generics, and compile-time validation.

Styling

Tailwind CSS Documentation

Utility-first CSS framework reference for responsive grids, backdrop filters, and design tokens.

Web Standards

MDN Web Docs

Mozilla Developer Network documentation on Web APIs, SVG graphics, WebGL canvas, and semantic HTML5.

Graph Database

FalkorDB Official Documentation

Low-latency Redis-based graph database documentation covering openCypher queries, node indexing, and memory architecture.

Graph Standards

openCypher Query Language

Standard declarative graph query language specification used by FalkorDB for relationship traversal and pattern matching.

Citation Note: These citations link directly to primary vendor specifications and API documentation. They serve as authoritative technical references for readers and evaluators, and represent standard technical documentation practices rather than duplicated project designs.