DEV Community: spideyy

We Built a 3D Game Where Your Voice Breaks Reality, As Our Hacker House Submission

spideyy — Tue, 06 Oct 2026 17:47:38 +0000

"How much of the world are you willing to destroy to create the world you want?"

Our team — Alt F4 — built this as our submission for Hacker House Goa 2026 in collaboration with Wispr Flow. And we decided to break every rule we set for ourselves.

No game engine. No Unity. No Godot. Just React, TypeScript, Three.js, and a slightly deranged idea:
What if your voice was the controller?

This is the story of ECHO — a cel-shaded dark fantasy RPG where you speak commands into the browser and the world obeys. Soldiers retreat. Bridges collapse. Rain drowns out torches. And every edit to reality leaves a scar.

The Premise (and Why It's Dangerous)

The player wakes up in the Meadowlands with no memory — but they have a power called The Echo. Whatever they speak aloud manifests in the physical world.

Say "Call the rain" → storm clouds roll in, torches extinguish, raiders break rank and flee.
Say "Destroy the bridge" → the stone bridge shatters into rubble, cutting off the enemy vanguard.
Say "Protect Rowan" → a shimmering Chronal Barrier envelops your miller friend, making him immune to blades.

Cool, right? Here's the catch:

Rewriting reality doesn't erase what happened. It fractures the world into alternate branches.

Every command leaves a silent scar. Mira the Seer carries the agonizing memory of every erased timeline. The ancient Architect tried to build a world without sorrow — and cracked the foundations of reality. You're next.

🧠 The Architecture That Makes It Tick

Here's a bird's eye view of the pipeline:

       Microphone Input
             │
             ▼
   Web Speech API (streaming)
             │
             ▼
   CommandParser
   ├── Local keyword fallback (zero-latency, offline)
   └── Gemini Flash API (structured JSON, natural language)
             │
             ▼
   Command Dispatcher
   ├── WorldState (entities, weather, physics)
   ├── CampaignSystem (missions, objectives, dialogue)
   └── TimelineSystem (snapshots, branches, rewind engine)

No bloated middleware. No event bus spaghetti. Each layer is a Zustand store, and commands flow downward like water.

🎙️ The Voice Engine: Two Modes, One Experience

The hardest design constraint I imposed on myself: the game must feel instant.

If Gemini is slow, you can't feel it. So I built a two-layer system:

Layer 1 — Zero-Latency Local Fallback

Mission-critical commands (retreat, shield, rain, rewind) are matched locally via keyword parsing. No network call. No latency. Fires in the same animation frame as the mic input.

Layer 2 — Gemini Structured JSON

For nuanced natural language ("Tell the soldiers of Shadowfang to go back where they came from") — Gemini parses it and returns a clean structured command object:

{
  type: "INTERACT_ENTITY",
  entityName: "soldiers",
  action: "retreat"
}

The dispatcher doesn't care how it was parsed. It just runs.

The real magic is the fallback ordering: try local first, call Gemini only when you need it. Zero perceived latency, full natural language support.

🌳 The Echo Tree — One Physical Anchor for All of Time

This was the wildest design decision.

Timeline manipulation in most games is a menu. In ECHO, it's a place. The Echo Tree is a singular location in the world at coordinates (-13, -1.5) — a glade west of the forest. You physically walk to it. You stand in its radius. You interact with it.

export const ECHO_TREE_COORDS = {
  x: -13.0,
  z: -1.5,
  interactionRadius: 4.2,
} as const;

checkProximity: (pos) => {
  const dist = Math.hypot(pos.x - ECHO_TREE_COORDS.x, pos.z - ECHO_TREE_COORDS.z);
  const isNear = dist <= ECHO_TREE_COORDS.interactionRadius;
  set({ isNear });
  return isNear;
},

The tree maintains deep immutable world snapshots — every entity state, weather condition, chaos score, and dynamic prop. You can fork realities, jump between branches, or rewind to narrative junctions. And critically: control configurations persist through timeline rewrites. Your key bindings survive the apocalypse.

⚔️ Mission 3: Where Simulation Gets Real

Mission 3 is the first major test of the system. Warlord Vorn's Shadowfang Vanguard is marching across the bridge toward Rowan's Mill with lit torches.

The player has 5 solutions, all of them real physics events:

Voice Command	What Actually Happens
`"Protect Rowan"`	Chronal barrier activates. Entity gains `aiState: 'cheering'`, full HP restore
`"Call the rain"`	Weather flips to storm. Torch entities extinguished. Raiders enter `fleeing` state
`"Destroy the bridge"`	Bridge mesh collapses. `setBridgeDestroyed(true)`. Raiders halt or reroute
`"Make the soldiers retreat"`	All Shadowfang entities get `aiState: 'fleeing'`, despawn after 3.5s
Direct combat	Melee/spell physics, knockback, stagger, health depletion

Rowan's fate is never faked through dialogue. It derives directly from his simulated health state at the end of the mission. Die at 0 HP? He collapses. Survive at 59 HP? He bandages his wounds. The game acknowledges the struggle. No cutscene tricks.

And here's what the interaction code actually looks like when a player shields Rowan:

store.updateEntity(shieldTarget.id, {
  health: shieldTarget.maxHealth,
  dialogBark: 'The air around me... it holds! The strikes cannot touch me!',
  aiState: 'cheering',
});

record({
  type: 'player_helped',
  actorId: 'player',
  actorName: 'The Voice',
  targetId: shieldTarget.id,
  description: `The Voice manifested an impenetrable chronal shield around ${shieldTarget.name}.`,
  significance: 3,
});

TimelineSystem.createCheckpoint({
  name: `Shielded ${shieldTarget.name}`,
  significance: 'story',
});

One action. Three systems updated. Memory ledger written. Timeline checkpoint created. State broadcasted.

🔊 Audio: Zero External Assets, 100% Procedural

This was a point of pride. ECHO has zero audio files. Every sound is synthesized at runtime using the Web Audio API.

River Ambience

A continuous 6-second pink noise buffer runs through parallel dual-band filters:

Deep flow path → Lowpass at 420 Hz (the body of rushing water)
Surface trickle path → Bandpass at 920 Hz, Q=1.1 (water rippling over stones)
Distance attenuation → Logarithmic falloff based on player proximity to the riverbank

Shoreline Hysteresis

This one's my favorite detail. The water entry/exit logic uses a deadband to prevent oscillation at the shoreline:

Entry triggers at ≥ 0.08m depth
Exit triggers only at < 0.03m depth (6cm deadband)
450ms debounce timer prevents rapid re-triggering

No more "splash splash splash" when walking along the water's edge.

Underwater Acoustics

A master lowpass filter ramps down to 320 Hz to muffle the world. A 52 Hz sub-aquatic pressure drone hums while submerged. Surfacing restores the full 22 kHz spectrum with a crisp air-breach emergence splash.

All of it synthesized. All of it reactive. No audio files.

🎨 Cel-Shading in React Three Fiber

The visual direction is stylized dark fantasy cel-shading. Custom toon color ramps (getToonGradient3, getToonGradient4) applied to procedurally textured meshes: stone masonry, timber grain, heraldic tabards, character attire.

The UI follows a cinematic dark fantasy palette across all 18 UI surfaces:

Typography: Warm ivory/parchment #E8E3D8
Highlights: Muted antique gold #B59A4A / #8F7836
Panels: Near-black charcoal #070B12 / #0C1119
Borders: Dark bronze/stone #292923 / #3A3628

Cohesion across Title Screen, Dialogue Box, Memory Panel, Timeline Tree, Save/Load modal — all 18 surfaces. When a UI element appears, it belongs in this world.

🏗️ The Full Stack

Layer	Technologies
Frontend Core	React 19, TypeScript, Vite
3D Rendering	Three.js, React Three Fiber, Drei
State Management	Zustand (modular: `WorldState`, `CampaignSystem`, `TimelineSystem`, `EchoTreeState`, `SettingsStore`)
Speech & AI	Web Speech Recognition API + Google Gemini Flash (structured JSON)
Audio	Procedural Web Audio API
Styling	Vanilla CSS, Glassmorphic overlays
Testing	Node.js + tsx TypeScript test runner

🧪 Actually Testing a Narrative Game

Most game test suites are a lie. Unit tests for "did the menu open?" don't catch whether your story systems stay coherent across timeline rewrites.

I wrote four test suites that actually matter:

# Full narrative vertical slice (M1 → M2 → M3 → M4, branches, Echo Tree)
npx tsx scripts/verify_narrative_slice.ts

# Controls & key rebinding (bindings, conflict resolution, timeline isolation)
npx tsx scripts/verify_controls_system.ts

# Water audio & acoustic physics (proximity falloff, hysteresis, splash synthesis)
npx tsx scripts/verify_water_audio.ts

# Mission 3 battle simulation (all 4 Echo solutions, raider pathing, Rowan fates)
npx tsx scripts/verify_m3_battle.ts

Zero regressions across storyline logic, audio synthesis, and world simulation. That's the bar.

🤝 Alt F4 × Wispr Flow — The Collaboration

ECHO is Team Alt F4's submission for Hacker House Goa 2026, built in collaboration with Wispr Flow.

Wispr Flow is a voice-first input layer that makes speaking to software feel natural and frictionless — which made them the perfect partner for a game where your voice is the only weapon that matters. Their philosophy of making voice a first-class input shaped how we thought about the Echo's command pipeline: if it feels clunky to say, it feels clunky to play.

Building ECHO as a selection submission meant every architectural decision had to be a fast, confident bet:

Zustand over Redux (less boilerplate, same power)
Web Audio API over audio files (zero asset pipeline, zero loading time)
Local keyword fallback over pure LLM (playable even when the API is slow)
Simulation over scripting (Rowan's fate is real, not cinematic)

The pressure of a tight deadline forced exactly the kind of ruthless simplicity that made the systems clean.

💭 What We Learned

1. Simulation over scripting. The temptation to fake outcomes with dialogue is real. Resist it. When Rowan's fate comes from his actual HP value in the simulation, the game means something. Players feel it.

2. Voice input has two enemies: latency and ambiguity. Solve latency with local fallback. Solve ambiguity with LLMs. Use both.

3. Procedural audio is worth the complexity. The river doesn't loop awkwardly, the underwater acoustics feel real, and there are zero licensing concerns. The investment pays off.

4. The world should react, not the UI. No giant overlays when you speak a command. The rain falls. The bridge breaks. The soldiers run. The world tells you what happened.

5. React + Three.js is totally viable for games. The component model for scene graph management is actually great. Zustand handles game state better than any bespoke solution I've tried. Don't sleep on this stack.

6. Deadline pressure is a feature, not a bug. Having a hard deadline forced us to bet fast and ship. Every cut we made improved the core. If you have a wild idea, go find a challenge that forces you to build it.

🔗 Try It / Explore It

The repo is public — go break things:

👉 github.com/kishore1035/echo

git clone https://github.com/kishore1035/echo.git
cd echo
npm install
npm run dev
# Open http://localhost:5173 and start speaking

Optionally drop a Gemini API key in .env for full natural language parsing — the game is fully playable without it using the local keyword fallback.

If you're building something at the intersection of web tech and games — or you're interested in what we're working on — hit us up. This space is criminally underexplored and the tools are better than you think.

Team Alt F4 · Submission for Hacker House Goa 2026 · In collaboration with Wispr Flow

React 19 · TypeScript · Three.js · Google Gemini · Web Audio API · and an embarrassing amount of late nights.

Building FraudGraph Agent: Autonomous Fraud Investigation & Policy-Compliant Next-Best Action with TigerGraph

spideyy — Fri, 25 Sep 2026 06:52:43 +0000

Building FraudGraph Agent: Autonomous Fraud Investigation & Policy-Compliant Next-Best Action with TigerGraph

How we combined TigerGraph 4.2.5, Model Context Protocol (MCP), calibrated Graph ML, Vector GraphRAG, and deterministic policy enforcement to build an enterprise-grade autonomous fraud investigator.

The Billion-Dollar Dilemma in Modern Payment Fraud

Financial fraud is evolving at machine speed. Fraud rings no longer rely on simple stolen credit card numbers; they operate coordinated syndicates utilizing synthetic identities, recycled device fingerprints across hundreds of cards, micro-transaction card testing sequences, and distributed structuring schemes designed to evade static rule thresholds.

Yet inside modern fraud operations centers, the investigation workflow looks remarkably dated:

Information Fragmentation: An alert fires from an ML risk scoring engine or a customer support ticket.
Manual Graph Traversal: An analyst spends 45 to 90 minutes manually opening six different dashboard tabs, issuing SQL queries across relational databases, checking whether a device ID was previously linked to chargebacks, and evaluating whether an out-of-region transaction represents travel or credential theft.
The False Positive Nightmare: Over 90% of flagged alerts end up being legitimate customer activity. Prematurely blocking a card causes churn and reputational damage; failing to act within minutes results in thousands of dollars in unrecoverable chargebacks.
The Hallucination Danger of Generative AI: While Large Language Models (LLMs) excel at synthesizing unstructured text, deploying a naive LLM agent in financial fraud is an operational non-starter. An LLM cannot be trusted to hallucinate card block decisions, ignore banking policy, or bypass regulatory approval hierarchies.

To solve this, we engineered FraudGraph Agent for the TigerGraph x Hacker House Goa challenge.

FraudGraph Agent is an autonomous, graph-native fraud investigator that takes raw alerts, navigates a 590,000+ transaction TigerGraph knowledge graph, diagnoses the exact fraud typology, gathers multi-source evidence, enforces a deterministic policy engine for next-best actions, drafts regulatory FinCEN Suspicious Activity Reports (SARs), and writes its findings back into graph memory.

┌─────────────────────────────────────────────────────────────────────────┐
│ FraudGraph Agent Analyst Dashboard                                      │
├───────────────┬─────────────────────────────────────────────────────────┤
│ Alert Queue   │ Case Details & Live Investigation Stream                │
│  - HHG-001    │ ┌─────────────────────────────────────────────────────┐ │
│  - HHG-006    │ │ Live Streamed Timeline             [Steps 1 to 8]   │ │
│  - HHG-018    │ ├─────────────────────────────────────────────────────┤ │
│               │ │ Uncertainty & Calibrated Verdict                    │ │
│ Filters:      │ │   Stop Rule: p >= 0.85 or p <= 0.15     [0.92 FRAUD]│ │
│  - All (20)   │ ├─────────────────────────────────────────────────────┤ │
│  - Fraud (10) │ │ Next Best Action Evolution                          │ │
│  - Legit (10) │ │   Initial: VERIFY_WITH_CUSTOMER -> Final: BLOCK_CARD│ │
│               │ ├─────────────────────────────────────────────────────┤ │
│ Stats:        │ │ Subgraph Topology & Grounding Evidence              │ │
│  - 590k Txns  │ │   Grounded Facts: 14 | Prior Cases: 5 | Ring Hops: 2│ │
│  - 14.8k Cards│ ├─────────────────────────────────────────────────────┤ │
│  - 5.5k Cases │ │ Case Memory Loop (TigerGraph Vector Retrieval)      │ │
└───────────────┴─┴─────────────────────────────────────────────────────┴─┘

Architectural Philosophy: Reason with LLMs, Decide with Policy

The foundational design principle of FraudGraph Agent is strict separation of concerns:

The Knowledge Graph provides ground truth.

The Machine Learning models estimate calibrated probabilities.

The Policy Engine determines next-best actions and approval routes.

The LLM reasons, synthesizes, and explains.

               ┌────────────────────────────────────────────────────────┐
               │              Trigger Alert (Risk / Report)             │
               └──────────────────────────┬─────────────────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │    1. TigerGraph Graph Traversal      │
                      │  (card_txns, device_rings, history)   │
                      └───────────────────┬───────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │   2. Calibrated Graph ML + Episodes   │
                      │ (GBDT AUC 0.987, Card Testing, Rings) │
                      └───────────────────┬───────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │    3. Hybrid Vector GraphRAG (1024d)  │
                      │  (5.5k Closed Cases + Bank Policies)  │
                      └───────────────────┬───────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │   4. Deterministic Policy Engine      │
                      │    (Rules R1-R10, L1/L2 Approval)     │
                      └───────────────────┬───────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │    5. Dynamic Evidence & Stopping     │
                      │ (Customer Outreach, p >= .85 / <= .15)│
                      └───────────────────┬───────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │     6. Grounded Synthesis & SAR       │
                      │ (LLM strictly constrained by facts)   │
                      └───────────────────┬───────────────────┘
                                          │
                                          ▼
                      ┌───────────────────────────────────────┐
                      │    7. Graph Memory Flywheel (MCP)     │
                      │ (AgentCase vertex & embeddings saved) │
                      └───────────────────────────────────────┘

By decoupling action execution from LLM generation, FraudGraph Agent guarantees that regulatory requirements (such as mandatory SAR filing over $1,000 exposure or senior manager sign-off for card freezes) can never be bypassed by model drift or prompt injection.

1. The Graph Foundation: TigerGraph 4.2.5

At the core of the system sits TigerGraph 4.2.5 Community Edition, hosting the IEEE-CIS fraud topology comprising:

590,742+ Transactions
14,893+ Cards & Customers
5,565+ Historical Closed Cases with detailed resolution narratives
Device Profiles, IP subnets, Email Domains, and Billing Regions

erDiagram
  Customer ||--o{ Card : OWNS
  Card ||--o{ Transaction : MADE
  Transaction ||--o{ DeviceProfile : FROM_DEVICE
  Transaction ||--o{ EmailDomain : PURCHASER_EMAIL
  Transaction ||--o{ BillingRegion : BILLED_IN
  Transaction ||--o{ Transaction : NEXT
  ClosedCase ||--o{ Transaction : INVOLVES
  ClosedCase ||--o{ Card : ON_CARD
  ClosedCase ||--o{ Card : CONNECTED_TO
  AgentCase ||--o{ Transaction : AC_INVOLVES
  AgentCase ||--o{ Card : AC_ON_CARD
  AgentCase ||--o{ Card : AC_CONNECTED
  AgentCase ||--o{ DeviceProfile : AC_DEVICE
  AgentCase ||--o{ ClosedCase : AC_SIMILAR
  AgentCase ||--o{ AgentCase : AC_SIMILAR_AGENT

Rather than performing slow relational table joins, our investigator issues high-performance GSQL queries compiled into C++:

card_txns: Extracts the temporal transaction baseline for a cardholder.
device_txns & device_closed_cases: Traverses 2 hops to identify if a physical device has participated in confirmed fraud on other accounts.
ring_expand: Performs multi-hop BFS across shared cards, devices, and email domains to uncover coordinated fraud syndicates.

2. Standardizing Graph Access via Model Context Protocol (MCP)

To enable seamless agentic orchestration, we integrated the TigerGraph Model Context Protocol (MCP) server (agent/mcp_client.py).

Through a persistent stdio JSON-RPC session, the agent treats the graph as a first-class toolset:

Graph Queries: Reads execute via tigergraph__run_installed_query and tigergraph__get_node.
Graph Mutation: Investigated case memory writes back through tigergraph__add_node and tigergraph__add_edge.
High-Availability Fallback: The client automatically senses environment readiness, falling back to direct pyTigerGraph connections when running against managed TigerGraph Cloud instances.

# The agent executes GSQL queries seamlessly through standard MCP tool calls:
session.call_tool("tigergraph__run_installed_query", {
    "query_name": "card_txns",
    "params": {"c": card_id}
})

3. The 8-Step Autonomous Investigation Lifecycle

When an alert enters the queue, FraudGraph Agent executes an 8-phase autonomous pipeline:

Step 1: Deep Subgraph Traversal

The agent queries TigerGraph to extract the card’s behavioral history, device graph, geographic region baseline, and prior closed disputes.

Step 2: Episode Modeling & Heuristic Detectors

A dedicated episode reconstruction algorithm scans the temporal transaction sequence to detect:

Card Testing: Rapid sequences of low-value authorizations designed to validate stolen PANs.
Structuring: Transactions systematically kept just below regulatory reporting thresholds.
Device Ring Proliferation: Sudden expansion of new cards bound to a single hardware fingerprint.

Step 3: Hybrid Vector GraphRAG

Using 1,024-dimensional cosine vector embeddings (gsql/vectors.gsql), the agent searches:

similar_cases: 5,565 historical human-analyst case closures.
similar_agent_cases: Past investigations conducted by the agent itself.
policy_search: Bank fraud manuals and regulatory compliance articles.

Step 4: Calibrated Probability & Typology Assessment

Rather than relying on uncalibrated model scores or the bank's raw trigger score (which introduces severe confirmation bias), FraudGraph Agent uses a Gradient Boosting classifier trained on 60+ graph-derived structural features.

Validation: Grouped 5-fold cross-validation achieves 0.987 ROC-AUC, 83% pattern accuracy, and 0.80 episode F1.
Evidence Counting: The agent counts independent signals (e.g., geographic deviation, device reputation, velocity spike) to ensure decisions rest on corroborating evidence.

Step 5: Next-Best Action Engine (Rules R1 - R10)

Next-best actions are governed by deterministic rules:

Rule R1 (Single Weak Signal): If fraud probability is elevated but supported by only one signal, do not freeze the card. Action: VERIFY_WITH_CUSTOMER + CREATE_CASE.
Rule R2 (Account Takeover / Multiple Signals): High probability ($p \ge 0.85$) with confirmed device compromise triggers immediate BLOCK_CARD with L1 Fraud Analyst routing.
Rule R9 (High Exposure / Undocumented): Exposure exceeding $1,000 or uncataloged fraud syndicates requires mandatory FILE_REPORT (FinCEN SAR) routed strictly to L2 Fraud Manager Approval.
Rule R10 (Clean Baseline): $p \le 0.15$ with normal baseline routes to CLOSE_NO_FRAUD and ALLOW_TRANSACTION.

Step 6: Evidence Verification & Uncertainty Stop Rule

The agent simulates customer communication (recording all assumptions transparently). If the customer confirms they still hold their card and did not authorize the charge, the agent updates its beliefs:

Fraud probability recalibrates.
Initial action (VERIFY_WITH_CUSTOMER) dynamically mutates into BLOCK_CARD.
The stop rule triggers when certainty crosses $p \ge 0.85$ or drops to $p \le 0.15$.

Step 7: Fact-Grounded Explanation & FinCEN SAR Generation

The LLM generates an executive summary and, when applicable, an official FinCEN SAR narrative. Crucially, the prompt is injected solely with structured, verified graph facts and policy rule outputs. No hallucinated details can enter the compliance record.

Step 8: Case Memory Flywheel

The closed investigation is committed to TigerGraph as an AgentCase vertex, connected to associated cards, devices, and transactions via AC_ON_CARD and AC_INVOLVES edges, with 1024-d embeddings stored on the vertex. The next case investigated immediately benefits from this memory.

4. Live Case Studies: The Agent in Action

Here is how FraudGraph Agent resolves distinct real-world alert profiles from the 20-case benchmark:

Case ID	Trigger Alert	Grounded Graph Findings	Initial Action	Final Action	Approval Route
HHG-001	Out-of-region card-present txn	Billing region 444; cardholder baseline is region 120. Device is clean.	`VERIFY_WITH_CUSTOMER`	`BLOCK_CARD`	L1 Analyst
HHG-006	Velocity alert on eCommerce card	Coordinated multi-device cluster; $1,906.07 exposure; undocumented ring pattern.	`CREATE_CASE`	`BLOCK_CARD` + `FILE_REPORT`	L2 Fraud Manager (Mandatory SAR)
HHG-018	High risk score alert (0.89)	Legitimate IP subnet; frequent historical merchant; normal ticket size ($35.00).	`FLAG_TRANSACTION`	`CLOSE_NO_FRAUD` + `ALLOW_TXN`	Automated / Auto-resolve

Spotlighting HHG-001: Avoiding Customer Friction

In HHG-001, an out-of-region transaction triggered a medium-risk alert. A naive rule engine would have blocked the card immediately, infuriating a traveling customer. FraudGraph Agent recognized that only a single signal was present:

It issued an initial recommendation: VERIFY_WITH_CUSTOMER.
Upon customer verification confirming the charge was unauthorized, calibrated certainty surged to 0.92.
The recommendation automatically evolved to BLOCK_CARD with complete audit provenance.

Spotlighting HHG-006: High Exposure & Autonomous SAR

In HHG-006, exposure totaled $1,906.07 across coordinated eCommerce transactions with an undocumented topology. The policy engine automatically elevated the case:

It selected Rule R9.
It assigned approval strictly to L2 Fraud Manager.
It synthesized a complete, audit-ready FinCEN Suspicious Activity Report detailing subject identifiers, transaction hashes, timestamps, and suspicious activity codes.

5. The Analyst Dashboard & GRIP GraphRAG Studio

To provide investigators with an exceptional operational experience, we built a modern React dashboard:

Monochrome & Emerald Aesthetic: Clean, high-density UI designed for professional fraud analysts.
Live Streamed Investigation: Server-Sent Events (SSE) stream investigation stages in real-time.
Calibrated Uncertainty Gauge: Visualizes exact fraud confidence against the $0.15$ and $0.85$ policy action thresholds.
Action Evolution Panel: Explicitly compares Initial Actions against Final Actions, highlighting exactly why and how evidence shifted the decision.
Interactive Subgraph Topology: Canvas-based interactive exploration of cards, devices, and connected transactions.
GRIP GraphRAG Studio: An embedded comparison harness that pits Direct LLM Generation vs. Vector-only RAG vs. Agentic TigerGraph Multi-Hop GraphRAG side-by-side:

Pipeline	Retrieval Method	Grounding Source	Hallucination Risk	Relational Context
1. Direct LLM	None (Parametric)	Internal weights	High	Zero
2. Vector RAG	Cosine similarity	Flat text chunks	Medium	None (isolated chunks)
3. Agentic GraphRAG	Autonomous BFS Traversal	Multi-hop Graph Topology	Zero (Cryptographically Verified)	Full Ring Context

Benchmark Results

Running across the official 20 benchmark test cases:

100% Policy Compliance: Every recommended action adhered strictly to banking policy rules R1–R10.
Zero Premature Declines: Weak-signal alerts were safely held for verification before account restriction.
12.7s Average Latency: Full 8-step deep graph investigation, ML scoring, vector retrieval, and SAR generation completed in under 13 seconds per case.
0.987 ROC-AUC: Graph-derived feature engineering proved vastly superior to raw transaction scoring.

What We Learned

Building an agentic system on top of a graph database revealed three essential truths:

Graphs are the Ultimate Agent Memory: Text embeddings tell you what words sound similar; knowledge graphs tell you who is transacting with whom, what devices they share, and where money is flowing. Combining vector similarity with relational graph topology provides unmatched contextual grounding.
Deterministic Guardrails are Non-Negotiable: In high-stakes finance, you cannot prompt an LLM to "be careful with banking rules." The policy engine must be hardcoded, verifiable, and authoritative; the LLM's job is translation, synthesis, and explanation.
The Feedback Loop Changes Everything: Giving an agent the ability to write its own investigations back into the graph turns static models into compounding intelligence assets. Case #20 was measurably smarter than Case #1 because it stood on the shoulders of the prior 19 investigations.

Reproduce and Explore

The entire repository—including the TigerGraph schema, GSQL queries, training pipelines, benchmark cases, and analyst UI—is open-source and reproducible:

GitHub Repository: kishore1035/HackerHouse
Tech Stack: TigerGraph 4.2.5, TigerGraph MCP, Python, FastAPI, React, Vite, OmniRoute, PyTigerGraph.

Built for the TigerGraph Hacker House Goa Challenge.