DEV Community: VanshDeo

Building Zyg0s: An Autonomous, Explainable Fraud Investigation Agent Powered by TigerGraph Savanna Cloud & MCP

VanshDeo — Fri, 25 Sep 2026 01:03:35 +0000

TigerGraph Agentic Fraud Investigation Hackathon (Hacker House Goa / HHGOA Track)

Author: Vansh Deo

Team Name: QueryCrew

GitHub Repository: https://github.com/VanshDeo/Zyg0s

Video Demo (3–5 min): Watch Live Walkthrough

Live Application: Launch Zyg0s Workbench

Quick Project Summary

Zyg0s is an autonomous, explainable cyber-investigation platform engineered to resolve the hardest bottleneck in modern banking: investigating complex financial crime and recommending defensible next-best actions when available signals are noisy and uncertain.

Powered by TigerGraph Savanna Cloud, Model Context Protocol (MCP), and Groq, Zyg0s fuses 7 specialized neuro-symbolic agents to traverse deep entity networks across 590,000+ IEEE-CIS transactions. It mathematically grades evidence across a 4-tier defensibility framework, quantifies epistemic uncertainty ($U$), enforces Bank Fraud Policy Rules (R1–R10) with dynamic two-stage actions, synthesizes regulator-grade FinCEN BSA/AML Suspicious Activity Reports (SARs), and updates graph-native case memory.

1. The Problem: The High-Stakes Crisis in Modern Fraud Operations

Every financial institution in the world faces an acute operational bottleneck: fraud investigation is manual, slow, and fragmented.
When an upstream machine learning model flags a suspicious credit card transaction, the money is often already in flight. Human fraud analysts are forced to swivel between five disjointed screens: looking up transaction logs, examining device fingerprints, querying customer historical baselines, checking core banking policies, and cross-referencing past fraud cases. By the time a case is manually triaged and reviewed, the fraud ring has moved on to siphon funds from dozens of other accounts.
Compounding this crisis are three structural traps:

The Unlabelled Anomaly Dilemma: In real-world payment data (such as the IEEE-CIS / Vesta financial fraud dataset), transactions do not come with neat "Is Fraud" labels at inference time. Models generate probabilistic anomaly scores where roughly 50% of alerts are false alarms.
The Destructive Action Trap: Freezing an innocent customer's card on a single weak anomaly score causes severe customer friction, churn, and regulatory scrutiny.
The Pure LLM Compliance Failure: Generic LLM agents suffer from hallucinations, drift away from strict banking authorization limits (e.g., trying to block a $5,000 account without mandatory senior manager sign-off), and cannot provide mathematically defensible audit trails required by bank compliance officers and regulators.

2. The Core Idea: What is Zyg0s?

We built Zyg0s (named after the ancient Greek zygos, the forensic scale of balance and evidence weighting).

   ┌────────────────────────────────────────────────────────┐
   │                  WHAT IS ZYG0S?                        │
   │  An Autonomous, Explainable Fraud Investigation Agent  │
   │  fusing TigerGraph Savanna Cloud, Model Context        │
   │  Protocol (MCP), and 7 Neuro-Symbolic Agents.          │
   └────────────────────────────────────────────────────────┘

Rather than treating fraud as a simple black-box binary classification problem, Zyg0s models fraud investigation as an adaptive, 8-stage evidentiary legal trial. It gathers multi-hop graph signals from TigerGraph Savanna Cloud, grades evidence across a 4-tier defensibility framework, quantifies epistemic uncertainty ($U$), recommends policy-governed two-stage actions, drafts regulatory FinCEN BSA/AML Suspicious Activity Reports (SARs), and writes closed cases back into graph memory.

3. Why TigerGraph?

Fraud is fundamentally relational—it lives in the connections between cards, devices, IP subnets, billing regions, and email domains. Relational databases choke on the recursive joins required to unmask synthetic identities and collusion rings.
TigerGraph Savanna Cloud provided the foundational backbone for Zyg0s:

Deep Multi-Hop Ego Networks: Traverses 2-hop to 4-hop neighborhoods in sub-millisecond latencies across 590,000+ transactions and 144,000+ device identity profiles.
Device Centrality & Clustering: Instantly computes degree centrality to reveal whether a device profile (e.g. Trident/7.0 | Windows 10 | IE 11.0) is isolated to one customer or acting as a shared gateway across 15+ compromised cards.
TigerGraph MCP (Model Context Protocol): We bridged TigerGraph's 65 native tools directly into our agent layer via JSON-RPC, enabling agents to dynamically inspect nodes, traverse edges, and execute graph algorithms autonomously.
Graph-Native Case Memory: Closed cases are stored as native graph vertices (ClosedCase), linked via semantic and topological edges, enabling zero-latency precedent retrieval.

4. Architecture: The Hybrid Neuro-Symbolic Division of Labor

Zyg0s resolves the AI compliance paradox by implementing a strict Neuro-Symbolic Division of Labor:

┌──────────────────────────────────────────────────────────────────────────────────┐
│                         NEURO-SYMBOLIC DIVISION OF LABOR                         │
├────────────────────────────────────────┬─────────────────────────────────────────┤
│ 🛡️ DETERMINISTIC GOVERNOR (Symbolic)   │ 🧠 LLM COGNITIVE LAYER (Neural)        │
│ "Absolute Truth, Math, & Compliance"   │ "Fluid Reasoning, Synthesis, & Copilot" │
├────────────────────────────────────────┼─────────────────────────────────────────┤
│ • GSQL multi-hop graph traversals      │ • Novel pattern discovery & naming (R9) │
│ • Entity resolution & device clusters  │ • Legal-grade FinCEN BSA/AML SAR draft  │
│ • Immutable numerical fact anchoring   │ • Natural language "What Changed" logs  │
│ • 4-Tier evidence defensibility math   │ • Interactive Investigator Copilot Q&A  │
│ • Uncertainty score formula (U = 1-C)  │ • Explaining edge cases to analysts     │
│ • Bank Fraud Policy v1.0 (R1–R10) gate │ • Zero-hallucination factual grounding  │
│ • Tiered permissions (auto, L1, L2)    │ • Graceful offline fallback             │
│ • Graph writeback to Savanna Cloud     │                                         │
└────────────────────────────────────────┴─────────────────────────────────────────┘

High-Level System Architecture

                      [ Multi-Modal Ingestion ]
          ┌───────────────────────┬───────────────────────┐
     Risk Score            Customer Report          Analyst Request
     (0.00 - 1.00)        (Disputed Amount)       (Graph Cluster Traversal)
          └───────────────────────┬───────────────────────┘
                                  │
                                  ▼
                     [ 7-Agent Pipeline Engine ]
    ┌─────────────────────────────────────────────────────────────┐
    │ 1. Alert Sentinel      ──► Ingests alert, computes Z-scores │
    │ 2. Graph Scout         ──► TigerGraph Savanna Cloud (MCP)   │
    │ 3. Evidence Assessor   ──► 4-Tier Defensibility & U index   │
    │ 4. Pattern Strategist  ──► Typology match & novel patterns  │
    │ 5. Policy Governor     ──► Bank Policy v1.0 (R1-R10) & NBA  │
    │ 6. Compliance Officer  ──► FinCEN BSA/AML SAR (5 W's)       │
    │ 7. Memory Weaver       ──► TigerGraph Graph Memory Commit   │
    └─────────────────────────────┬───────────────────────────────┘
                                  │
                                  ▼
                   [ Interactive Workbench UI ]
     Case Queue   •   Live Progression   •   Graph & SAR Workspace

5. The 8-Stage Investigation Lifecycle

Zyg0s executes an 8-stage state machine that mirrors how elite forensic investigators work:

  [1. Trigger] Ingest alert via risk score, dispute, or analyst request.
       │
  [2. Investigate] Open case, retrieve historical baselines & card history.
       │
  [3. Gather Evidence] Traverse TigerGraph 2-hop ego network & shared devices.
       │
  [4. Assess Uncertainty] Compute Epistemic Uncertainty U. If U > 0.40, stop destructive actions!
       │
  [5. Gather More Evidence] Issue non-destructive Step-Up Challenge (SMS OTP / Biometric).
       │
  [6. Take Next Actions] Evaluate Bank Policy R1-R10; evolve Stage 1 NBA into Stage 2 Final NBA.
       │
  [7. Explain Decision] Synthesize 5 W's rationale citing policy rules & evidence grades.
       │
  [8. Update Case Memory] Persist case vertex to TigerGraph Cloud via Hybrid RRF Index.

6. What an LLM Can and Cannot Do (Enforcing Strict Guardrails)

A central innovation of Zyg0s is our strict containment of Large Language Models (Groq / Qwen 2.5):

What the LLM CANNOT Do:
- ❌ Cannot calculate financial exposure or sum dollar amounts (prevents arithmetic hallucination).
- ❌ Cannot decide whether a card is blocked or cleared on its own discretion.
- ❌ Cannot authorize actions exceeding statutory or institutional approval thresholds (e.g. actions $> \$2,500$ strictly require L2 Manager approval).
- ❌ Cannot bypass evidentiary rules.
What the LLM CAN Do:
- ✅ Formulates forensic hypotheses and detects subtle novel pattern variations.
- ✅ Generates regulator-grade FinCEN SAR narratives adhering to the statutory 5 W's (Who, What, When, Where, Why).
- ✅ Synthesizes plain-English “What Changed” progression summaries for human analysts.
- ✅ Powers an interactive Investigator Copilot grounded in the TigerGraph topology.

7. How Evidence Changes the Decision (2-Stage NBA & Uncertainty Collapse)

In Zyg0s, recommendations are not static—they dynamically evolve across a Two-Stage Next-Best Action (NBA) lifecycle:
$$ \text{Confidence} = \left| \frac{\sum w_i}{\sum |w_i| + \epsilon} \right| \times \min\left(1.0, \frac{N}{N_{\text{min}}}\right) $$
$$ U = 1.0 - \text{Confidence} $$

Stage 1 (Before Verification): When an alert arrives, evidence is usually circumstantial ($U > 0.40$). Under Policy Rule R1, the agent recommends non-destructive actions: VERIFY_WITH_CUSTOMER and MONITOR_CARD.
The Step-Up Challenge: The system triggers an interactive authentication challenge (SMS OTP, biometric prompt, or cardholder inquiry).
Stage 2 (After Verification):
- If the cardholder confirms authorization $\rightarrow$ Uncertainty collapses ($U \rightarrow 0.00$), fraud risk drops to $0.05$, and the case is closed with CLOSE_NO_FRAUD (Card remains active).
- If the cardholder denies authorizing the charge $\rightarrow$ Direct evidence is established ($w = +1.0$), fraud risk rises to $0.85 - 0.99$, and the agent upgrades the action to BLOCK_ALL_CARDS, CREATE_CASE, and FILE_REPORT under L2 authorization.

8. Official HHGOA Benchmark Results (20/20 Cases Validated)

Zyg0s was rigorously evaluated against all 20 official benchmark exam cases from the final two months of the IEEE-CIS / Vesta dataset:
| Case ID | Trigger Channel | Typology Pattern | Final Verdict | Risk Score | Epistemic Uncertainty ($U$) | Final Confidence | SAR Filed? | Next Best Action | Approval Route |
| :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
| HHG-001 | Risk Score (0.61) | none | CLEARED | 5 / 100 | 0.330 | 67% | No | CLOSE_NO_FRAUD | auto |
| HHG-002 | Risk Score (0.79) | card_not_present_fraud | CLEARED | 5 / 100 | 0.000 | 100% | No | CLOSE_NO_FRAUD | auto |
| HHG-003 | Customer Dispute | none | FRAUD | 95 / 100 | 0.330 | 67% | No | BLOCK_CARD | L1 |
| HHG-004 | Customer Dispute | card_not_present_new_device | FRAUD | 99 / 100 | 0.150 | 85% | No | BLOCK_CARD | L1 |
| HHG-005 | Risk Score (0.54) | card_not_present_new_device | FRAUD | 85 / 100 | 0.150 | 85% | No | BLOCK_ALL_CARDS | L2 |
| HHG-006 | Customer Dispute | card_not_present_new_device | FRAUD | 99 / 100 | 0.150 | 85% | No | BLOCK_CARD | L1 |
| HHG-007 | Risk Score (0.87) | account_takeover | FRAUD | 85 / 100 | 0.150 | 85% | No | BLOCK_CARD | L1 |
| HHG-008 | Customer Dispute | none | CLEARED | 5 / 100 | 0.330 | 67% | No | CLOSE_NO_FRAUD | auto |
| HHG-009 | Customer Dispute | none | CLEARED | 5 / 100 | 0.330 | 67% | No | CLOSE_NO_FRAUD | auto |
| HHG-010 | Risk Score (0.90) | card_not_present_new_device | FRAUD | 85 / 100 | 0.150 | 85% | No | BLOCK_ALL_CARDS | L2 |
| HHG-011 | Customer Dispute | none | CLEARED | 5 / 100 | 0.550 | 45% | No | CLOSE_NO_FRAUD | auto |
| HHG-012 | Risk Score (0.55) | none | CLEARED | 5 / 100 | 0.330 | 67% | No | CLOSE_NO_FRAUD | auto |
| HHG-013 | Risk Score (0.76) | card_not_present_new_device | FRAUD | 92 / 100 | 0.000 | 100% | Yes | BLOCK_ALL_CARDS | L2 |
| HHG-014 | Analyst Request | card_not_present_new_device | FRAUD | 99 / 100 | 0.150 | 85% | Yes | BLOCK_ALL_CARDS | L2 |
| HHG-015 | Risk Score (0.77) | card_not_present_new_device | FRAUD | 92 / 100 | 0.000 | 100% | Yes | BLOCK_ALL_CARDS | L2 |
| HHG-016 | Customer Dispute | card_not_present_new_device | FRAUD | 99 / 100 | 0.000 | 100% | Yes | BLOCK_ALL_CARDS | L2 |
| HHG-017 | Risk Score (0.57) | card_not_present_fraud | FRAUD | 85 / 100 | 0.150 | 85% | No | BLOCK_ALL_CARDS | L2 |
| HHG-018 | Customer Dispute | none | CLEARED | 5 / 100 | 0.330 | 67% | No | CLOSE_NO_FRAUD | auto |
| HHG-019 | Risk Score (0.90) | card_not_present_new_device | FRAUD | 85 / 100 | 0.150 | 85% | Yes | BLOCK_ALL_CARDS | L2 |
| HHG-020 | Risk Score (0.52) | card_not_present_new_device | FRAUD | 85 / 100 | 0.150 | 85% | Yes | BLOCK_ALL_CARDS | L2 |

9. Engineering Challenges We Conquered

Building an autonomous agent for production fintech required overcoming several non-trivial engineering hurdles:

The Unlabelled IEEE-CIS Ground-Truth Dilemma:
- Problem: The dataset stripped binary labels to mirror real banking realities.
- Solution: We leveraged the 4-month historical database of 5,565 closed cases (closed_cases_history.csv) and built a Reciprocal Rank Fusion (RRF, $K=60$) engine to anchor case decisions in real empirical precedents.
Preventing Premature Card Freezes:
- Problem: Heuristic agents frequently over-react to single velocity spikes.
- Solution: We codified Bank Fraud Policy v1.0 (Rule R1) into code: if uncertainty $U > 0.40$ or evidence is purely correlative, the agent is strictly restricted to non-destructive actions (VERIFY_WITH_CUSTOMER).
C-Extension NumPy 2.x Incompatibilities:
- Problem: Modern Python 3.12 runtimes under NumPy 2.2 encountered binary crashes with legacy C-compiled extensions (bottleneck, numexpr).
- Solution: We implemented runtime module-level shielding (sys.modules.setdefault("bottleneck", None)) to ensure crash-proof operation across local environments and cloud deployments.
Graph Centrality at Scale:
- Problem: Querying 144,000+ device profiles for multi-account collusion can cause severe memory bloat if executed naively.
- Solution: We leveraged TigerGraph GSQL graph algorithms and MCP tools (tigergraph__get_neighbors, tigergraph__get_node) to restrict traversal expansions to relevant 2-hop neighborhoods, completing graph evaluations in under 1.5 seconds.
Dynamic Real-Time UI Synchronization:
- Problem: Ensuring the investigator dashboard updates live across 7 agent execution stages without relying on hardcoded placeholder scores.
- Solution: Built a dynamic mathematical progression telemetry pipeline connecting FastAPI backend events to a React + Vite Neo-Gothic dashboard.

10. Key Takeaways & The Future of Autonomous Fraud Ops

What We Learned

Deterministic policy rules and graph structure do not restrict AI agents—they make them usable in high-liability industries. By decoupling mathematical computation and statutory policy from fluid natural language synthesis, we achieved 100% regulatory compliance, zero arithmetic hallucinations, and defensible audit trails.

What We Would Build with More Time

Live Graph Neural Network (GNN) Embeddings: Streaming PyTorch Geometric embeddings directly updated on TigerGraph edge insertions for sub-second ring detection.
Autonomous Cross-Bank Webhook Mesh: Extending step-up auth from simulated customer messaging to live multi-institution Webhook consensus protocols.

Codebase & Benchmarks: GitHub Repository

Submission Track: TigerGraph Agentic Fraud Investigation (Hacker House Goa)

GraphRAG Benchmark Analysis

VanshDeo — Sun, 17 May 2026 19:14:48 +0000

We Built a Clinical GraphRAG Benchmark That Proves Graph Databases Aren't Just Hype

How TigerGraph-powered graph traversal beat vector search on polypharmacy reasoning — and why token efficiency tells a more interesting story than accuracy alone.

The Problem With "Just Use RAG"

Every production AI team eventually hits the same wall: your LLM hallucinates a drug interaction, misses a temporal dependency, or confidently answers a counterfactual question it has no business answering. The standard response is "add RAG." But which RAG?

Vector similarity search (Pinecone, Weaviate, etc.) is great at retrieving semantically similar chunks. It's not great at answering questions like:

"If omeprazole is stopped, which drug interaction paths resolve?"
"Which guidelines conflict on aspirin use in elderly patients?"
"Patient is taking warfarin, fluconazole, and aspirin. Trace the full interaction cascade."

These aren't similarity problems. They're graph traversal problems.

That's the thesis behind GraphRAG Inference Core V2 — a clinical benchmarking system we built to quantify exactly how much graph-structured retrieval improves over baseline approaches.

The Architecture: Three Pipelines, One Benchmark

We designed a multi-pipeline evaluation harness that runs every query through three systems simultaneously:

🔶 LLM-Only (Baseline)

Pure Gemma inference. No external context. Training-knowledge baseline. This answers: "What does the model already know?"

🔷 RAG Hybrid Core (Vector Baseline)

Gemma + Pinecone vector retrieval. Standard embedding-based context injection. This answers: "Does retrieval help, and by how much?"

🟢 GraphRAG Sentinel (Our System)

Gemma + TigerGraph V3 route-aware traversal. Queries are classified, routed to a Cypher/GSQL generator, and context is returned as compressed structured JSON.

The benchmark covers 100 clinical questions across five reasoning categories — 20 each:

Category	What It Tests
Temporal	Time-dependent drug effects, dosing windows
Contradiction	Conflicting clinical guidelines
Multi-Hop	Enzyme-mediated cascade interactions
Counterfactual	"What if X is stopped/added?" reasoning
Cross-Entity	Drug ↔ Disease ↔ Symptom ↔ Guideline reasoning

Targets: 90% LLM-Judge score, BERTScore ≥ 0.55

The Results: Token Efficiency Is the Real Story

Here's the comparative matrix from our live benchmark run on the omeprazole query:

Metric	LLM-Only	Basic RAG	GraphRAG
Total Tokens	389 ⭐	1,281	770
Latency	57,931ms	49,919ms ⭐	189,845ms
Cost	$0.000029 ⭐	$0.000090	$0.000058

At first glance this looks like GraphRAG loses on every metric. That's the wrong read.

The key insight: GraphRAG uses 770 tokens to do what Basic RAG needs 1,281 tokens for — a 39.9% token reduction while retrieving structured, graph-verified context instead of raw semantic chunks. The LLM-only baseline uses 389 tokens but provides no external grounding at all.

In production at scale, that 40% reduction compounds. 1M queries/month at $0.000058 vs $0.000090 is the difference between a sustainable product and a budget crisis.

How the Graph Query Routing Works

When a query hits the GraphRAG Sentinel pipeline, the system:

Classifies the query type (we detected GENERATE_CYPHER for the omeprazole question)
Selects a retriever — CYPHER for structural traversal, with hop-depth configured per query class
Generates and executes a TigerGraph GSQL/Cypher query against our clinical knowledge graph
Compresses the result into structured JSON context before LLM injection
Synthesizes a response through four verified stages: Entity Extraction → Community Summary Retrieval → Global Aggregation → Response Synthesis

The clinical graph schema includes: Drugs, Diseases, Symptoms, Enzymes, Adverse Events, and Clinical Guidelines — with typed edges for direct interactions, enzyme-mediated cascades, and contraindication relationships.

This is exactly the schema you need to answer "which interaction paths resolve when omeprazole stops" — not a cosine similarity index.

The Demo: "The Cascade Collapse"

Our flagship demo query traces what happens across a polypharmacy regimen when a key CYP2C19 inhibitor is removed.

The GraphRAG system correctly:

Identifies omeprazole as a CYP2C19 inhibitor (Proton Pump Inhibitor class)
Traverses the enzyme-mediated interaction graph to find CYP2C19-dependent drugs (clopidogrel, etc.)
Determines that removing the inhibition restores the metabolic pathway
Surfaces the clinical implication: clopidogrel's antiplatelet efficacy is restored, increasing bleed risk considerations

The LLM-Only response gets the answer directionally correct from training data. The Basic RAG response retrieves relevant paragraphs but can't traverse the interaction graph. Only GraphRAG surfaces the full cascade path with structural verification.

Stack

Graph DB: TigerGraph V3 (GSQL + Cypher query generation)
Vector Store: Pinecone (Basic RAG baseline)
LLM: Gemma (all three pipelines)
Frontend: Next.js dashboard with live system console
Benchmark Runtime: STITCH_OS v2.4.0
Security: AES-256-GCM channel encryption

What's Next

The benchmark harness is open. We're working toward full 100-question eval runs with automated LLM-Judge scoring and BERTScore computation across all five reasoning categories. The graph schema is extensible — drug-gene interactions, trial enrollment criteria, and payer formulary data are natural next nodes.

Try It / Contribute

The full codebase — benchmark runner, graph schema, retriever implementations, and dashboard — is open source.

GitHub: https://github.com/Sayandeep-the-coder/graphrag-benchmark

If you're building clinical AI, drug safety tooling, or just want to see a real GraphRAG vs RAG comparison with live metrics, this is the codebase to clone.

Tags: TigerGraph graphrag GraphRAGInferenceHackathon rag clinical-ai knowledge-graph polypharmacy llm-benchmarking gsql cypher drug-interactions open-source