DEV Community

VanshDeo
VanshDeo

Posted on

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

#ai #tigergraph #agents #rag

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

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:

  1. 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.
  2. The Destructive Action Trap: Freezing an innocent customer's card on a single weak anomaly score causes severe customer friction, churn, and regulatory scrutiny.
  3. 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.          │
   └────────────────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

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     │                                         │
└────────────────────────────────────────┴─────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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:

  1. 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.
  2. 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).
  3. 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.
  4. 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.
  5. 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)

Top comments (0)