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.

Figure 1.0: Genuine screenshot of the deployed ThreatNexus spatial computing environment.
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.
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 AmnesiaMost 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 BlindspotsSecurity 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 IsolationIn 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 DeficitWhen 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.
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.
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.
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.
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).
End-to-End Investigation Workflow Pipeline
From raw multi-source telemetry to cross-session memory synthesis and subsequent investigation recall.
Investigation Data
Ingest raw disparate security logs
Context & Relationships
Extract entities & semantic links
Graph Exploration
Interactive topology traversal
Agent Investigation
Autonomous multi-stage reasoning
Context Preservation
Store verified memory triples
Subsequent Investigation
Cross-session context recall
Investigation Data— Raw Telemetry
Sysmon event logs, Zeek network connections, perimeter auth records, and database transaction queries are normalized into structured evidence with cryptographic hashes.
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
Frontend Application Tier — Next.js 16 & React 19Standalone Demo + Live Adapter
8 Dashboard Views • Liquid Glass Design • State Context • @xyflow/react
Backend API Layer — Python API ServiceContract Ready / In Development
FastAPI / Flask • Secure Credential Vault • Cypher Query Orchestration
Graph Engine — FalkorDB
Entity Nodes & Relationship Edges
Agent Engine — E-101 & E-102
Multi-Hop Path Traversal & Triage
React / Next.js Frontend Layer
Production Ready PrototypeDecoupled 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
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.
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.
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.
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.
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.

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.
Visual Gallery & Click-to-Enlarge Lightbox
Inspect genuine project screenshots showcasing the active ThreatNexus workspace, Apple Liquid Glass-inspired modal dialogs, and underlying TypeScript components.

Full ThreatNexus Platform Workspace
Active runtime view on localhost:3000 showing 8-view navigation, real-time signal telemetry waveform, dial gauges, and the interactive spatial holographic graph stage.

Investigation Waveform — Apple Liquid Glass Modal
Pristine Apple Liquid Glass modal showing the 5-hop multi-hop reasoning chain (185.220.101.42 -> svchost_updater.dll -> Jumpbox-East-01 -> svc_backup -> SQL-PROD-09) with true backdrop blur translucency, specular highlights, and active cross-session latent linkage.

Graph Entities Liquid Glass Modal
Expanded tile presentation showing 10 entities, 4 critical risk nodes, and detailed breakdown across Hosts, Databases, Files, IP Addresses, and Accounts.

Preserved Sessions & Memory Vault
Expanded tile modal displaying historical sessions S-2026-01 (APT-41 Jumpbox), S-2026-02 (Core Ledger DB), and S-2026-03 (Perimeter Phishing) with active cross-session recall.

Spatial Workspace Source Architecture
Source code of SpatialWorkspace.tsx demonstrating integration of HolographicGraphStage, reasoning parameter sliders (Hop Depth, Confidence Threshold), and context bindings.

Modular Glass Design System Implementation
Source code of Badge.tsx showing TypeScript interface definitions, tailwind-merge integration, and curated cyan/emerald/amber/rose luminous color tokens.
Scenario Explorer Canvas
Preset cards for APT-41, Supply Chain, and Kerberoasting scenarios. Accessible in live prototype.
Agent Investigation Workbench
5-step autonomous reasoning timeline and multi-hop attack path visualization. Accessible in live prototype.
Explainability & Provenance Matrix
Epistemic classification table and raw log cryptographic evidence hashes. Accessible in live prototype.
System Health Diagnostics
Runtime connectivity status, mock vs live toggles, and backend ping test utility. Accessible in live prototype.
Built with Modern, Verified Technologies
Every library and runtime documented below was verified directly against the repository dependencies and configuration files.
Component hierarchy, concurrent rendering, and reactive context management across all 8 views.
App router architecture, server/client component boundaries, and fast Vercel deployment targets.
Strict end-to-end data schemas for graph entities, edges, investigation findings, and memory triples.
Apple Liquid Glass design system, backdrop blur utilities, custom glow filters, and responsive layouts.
Accessible semantic structures, keyboard focus indicators, and screen-reader accessible elements.
Interactive node-link graph visualization with custom SVG node components and bezier edge connections.
Server-side API layer proposed in PROPOSED_BACKEND_API_CONTRACT.md for Cypher queries and graph traversal orchestration.
Low-latency Redis-based graph database executing openCypher queries for multi-hop entity relationships.
Deterministic multi-hop path traversal and context synthesis algorithms (Query Decomposition -> Relational Expansion -> Evidence Verification).
Google Antigravity IDEAgentic Coding
AI-Assisted Development Environment
Advanced agentic pair programming environment utilized by the CybSecNetworkProtocol team to conceptualize, scaffold, debug, and polish the ThreatNexus architecture and blog case study.
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.
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.
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.

Figure 2.0: Genuine screenshot of the Apple Liquid Glass-inspired Investigation Waveform modal showing true backdrop translucency and multi-hop reasoning chain.
Team CybSecNetworkProtocol
Developed collaboratively for the WeMakeDevs “Graph Hacks: Context for AI Agents” hackathon.
M. Jai Manikanta
Team Leader, UI/UX Designer Frontend Developer & Blog Deployer
- •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
Rohan Ahirwar
PPT Designer
- •Hackathon pitch deck preparation & slide storyline
- •Competitive research and cybersecurity case study synthesis
- •Presentation delivery & narrative structuring for judges
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
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.
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
Dense node-link diagrams frequently degenerate into an unreadable “hairball.” Analysts struggle to differentiate between informational links and active lateral movement attacks.
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
Excessive glassmorphism often leads to poor text contrast, visual clutter, and accessibility issues for operational monitoring.
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
Developing the frontend concurrently while backend Cypher queries and graph schema definitions were being tuned required avoiding tight coupling.
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
Rapid clicking between stat tiles and graph nodes caused modal state collisions and unwanted scroll jumps.
Refined React state hooks and isolated modal dialogs with keyboard Escape listeners, focus traps, and backdrop-click dismissals.
Zero-Secret Vercel Deployment Readiness
Ensuring the public showcase could be safely deployed on Vercel without inadvertently leaking backend credentials or database connection strings.
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
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.
Explainability Must Be Granular
Analysts distrust monolithic AI summaries. Decomposing agent outputs into explicit epistemological categories (Facts vs Inferences vs Hypotheses) builds operational trust.
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.
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.
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.
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 deploymentsSecurity 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
Richer openCypher Query Generation
Empower agents with automated Cypher generation to query FalkorDB dynamically based on freeform natural language questions.
Hybrid Vector-Graph Hybrid Memory
Combine semantic vector retrieval with deterministic graph traversals for richer contextual entity synthesis.
Live SIEM / EDR Ingestion Connectors
Develop streaming ingest pipelines connecting directly to CrowdStrike, Splunk, and Zeek network taps.
ThreatNexus Live Walkthrough & Pitch Demo
Watch Team CybSecNetworkProtocol demonstrate cross-session graph memory, multi-hop reasoning, and the interactive spatial dashboard.
Live AI Agent DeploymentRailway Online
Interact directly with the live deployed ThreatNexus AI Agent exploring graph context memory and multi-hop correlation.
Authoritative Technical Documentation
Direct citations and documentation links for the core specifications, frameworks, and database architectures referenced throughout the project.
React Official Documentation
Official guide, API reference, and design principles for React 19 concurrent features and hooks.
TypeScript Documentation
Language specification and typing guidelines for robust interfaces, generics, and compile-time validation.
Tailwind CSS Documentation
Utility-first CSS framework reference for responsive grids, backdrop filters, and design tokens.
MDN Web Docs
Mozilla Developer Network documentation on Web APIs, SVG graphics, WebGL canvas, and semantic HTML5.
FalkorDB Official Documentation
Low-latency Redis-based graph database documentation covering openCypher queries, node indexing, and memory architecture.
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.