Don't Click This If You Trust Every Transaction You See

I built an AI agent that investigates money mules instead of just flagging them — my first international hackathon project

Kindly check and like: https://devpost.com/software/abc-kmg76h#updates

A few weeks ago I was staring at a fake transaction dataset at 1am, and something clicked that I couldn't un-see.

Most fraud looks completely normal one row at a time.

₹2,000 here. ₹8,500 there. A transfer between two accounts that could be literally anyone paying anyone for anything.

But zoom out, and sometimes those boring little transfers form a chain — Account A pays B, B splits it and pays C and D, C pays E — and suddenly you're looking at a money mule network, not a spreadsheet.

The problem is: almost every fraud tool I looked at answers one question — "is this transaction risky?" — and then just... stops. It gives you a score and walks away. No story, no reasoning, no "here's why you should care."

So for my first international hackathon, I decided to try building the thing I actually wanted to exist:

SYNAPSE — an AI agent that investigates, not just detects

The idea is simple to say and genuinely hard to build: instead of one model spitting out a risk score, build a system that behaves like a junior investigator. Give it a toolbox. Let it gather evidence from multiple angles, connect the dots, and explain itself in plain language.

Here's roughly how it works:

                    Gemini
                       │
              Investigation Agent
                       │
        ┌──────────────┼──────────────┐
        │              │              │
        ▼              ▼              ▼
   ML Risk Tool   Graph Analysis   Anomaly Analysis
        │              │              │
        └──────────────┼──────────────┘
                       ▼
                 Evidence Fusion
                       │
                       ▼
              Investigation Report

You give it a transaction dataset, and it coordinates a handful of tools:

ML risk scoring — looks at transaction velocity, frequency, counterparties, that kind of behavioral fingerprint
Graph analysis — the part I got genuinely obsessed with (more on that below)
Anomaly detection
Benford's Law — checks if the leading-digit distribution of the numbers looks statistically "natural" or not
Evidence fusion — pulls all of that into one explainable picture instead of five outputs you have to reconcile yourself

The graph is where it stopped being "just another fraud detector" for me

This was the moment the project felt real.

A spreadsheet shows you transactions. A graph shows you relationships. Once I started representing accounts as nodes and transfers as edges, the question I could ask completely changed.

Instead of "is this transaction suspicious?" I could ask "why does this one account sit at the center of so much money movement?"

        Account A
          │
       ₹50,000
          ▼
        Account B
        /       \
   ₹49,000     ₹48,000
      ▼           ▼
 Account C     Account D
      │
   ₹47,500
      ▼
 Account E

Each individual transfer here looks fine. But the shape is exactly what a mule chain looks like — money hopping through intermediaries, thinning out at each step. High fan-in, high fan-out, rapid multi-hop transfers, circular flows — that's the fingerprint I was hunting for, and no single row of a spreadsheet was ever going to show it to me.

Where Gemini actually earns its keep

I really didn't want to bolt a chatbot onto a fraud tool and call it "AI-powered" — that felt like cheating myself out of the interesting part.

So in SYNAPSE, Gemini is the orchestrator, not the whole show. It decides which tools to call, reads their structured output, connects evidence across them, and writes the final summary in language a human can actually use. The ML model, the graph engine, the stats — those produce the evidence. Gemini's job is to reason over it, not invent it.

That boundary — evidence vs. assumption — turned out to be the single hardest thing to get right in the entire build.

The stuff nobody tells you about building an "agent"

Honestly? I thought the hard part would be prompting Gemini well. It wasn't.

The hard part was everything else:

What is this agent actually allowed to do?
What happens when a tool call fails halfway through an investigation?
How do I stop it from confidently making up evidence it doesn't have?
How do I keep investigation state across multiple steps instead of starting fresh every time?
How do I make the final output something a person can trust, not just something that sounds trustworthy?

By the end I stopped thinking of it as "an LLM with tools" and started thinking of it as a junior investigator with a toolbox. It can reason all it wants — but it only ever reasons over what the toolbox actually hands it.

What's next for SYNAPSE

Right now it's Upload → Analyze → Report. Where I want to take it:

Real-time transaction monitoring instead of static datasets
Streaming financial-event analysis
Deeper temporal graph analysis (patterns over time, not just structure)
Feedback loops so investigators can correct it and it actually learns
Case management for tracking investigations, not just one-off reports

Why I'm posting this

This is my first hackathon at an international level, and honestly a huge chunk of what I learned had nothing to do with fraud detection — it was about what it even means to build an agent responsibly: giving it boundaries, making its reasoning legible, and refusing to let it bluff its way through missing evidence.

If this resonates with you — fraud/AML people, graph nerds, agent-builders, or just fellow hackathon sufferers running on no sleep — I'd genuinely love a ❤️ or a comment. And if you've built something similar or see a hole in my approach, please tell me. I'm still very much in "figure this out" mode.

SYNAPSE — connecting signals, tracing flows, uncovering risks.
ENDOFFILE

DEV Community