FraudOS (AEGIS.AI) — Algorithmic Fraud Detection & XAI

Enterprise grade financial anomaly detection engine that combines optimized Isolation Forest and LSTM ensemble with Explainable AI layer to reduce false positives by 4x without sacrificing recall.

Comment

FraudOS (AEGIS.AI)

Inspiration

Financial fraud detection systems are notoriously inefficient, heavily prioritizing recall at the cost of precision. This creates a pipeline that flags transactions at a staggering 92% false-positive rate.

More importantly, these ML models often operate as complete “black boxes,” leaving investigators to manually decipher why a transaction was flagged.

We were inspired by AlgoFest’s emphasis on algorithmic excellence and real-world scalability to solve this challenge. Our goal was to build a system that not only detects fraud using highly optimized ensemble modeling, but also mathematically translates complex model outputs into human-readable intelligence.

What it does

FraudOS (AEGIS.AI) is an end-to-end algorithmic fraud detection operating system.

🔍 Optimized Ensemble Engine

Our backend continuously scores live transactions using a custom hybrid AI model:

  • Isolation Forest → detects spatial and point anomalies (unusual transaction amounts, locations, device changes, etc.)

  • LSTM (Long Short-Term Memory) → detects sequential velocity anomalies (micro-structuring patterns, rapid transfers, behavioral drift over time)

This ensemble architecture enables both high anomaly sensitivity and sequential fraud awareness.

🧠 Explainable AI (XAI) Layer

When the ensemble anomaly score crosses our configured threshold (for example, 0.80), our virtual AI investigator, Agent Rahul, uses a Large Language Model to decode the feature vectors into plain-English explanations.

Example:

CRITICAL: High-value wire transfer of $34,200 initiated from a new device in Hong Kong.

This transforms opaque ML predictions into transparent audit intelligence for human investigators.

🛡️ Regulatory Algorithmic Constraints

In financial systems, fraud thresholds cannot be changed arbitrarily.

We implemented a mathematical governance layer that programmatically blocks investigators from applying any threshold changes that would reduce the fraud recall rate below the regulatory baseline of 95%.

This ensures the system remains compliant while still allowing controlled tuning.

⚡ Asynchronous Live Injection

We built a high-performance Python worker (ai_data_agent.py) using asyncpg to continuously inject generated anomaly data into our live cloud infrastructure without exceeding database connection limits.

This creates a constantly active fraud-monitoring environment for testing and demonstration.

How we built it

⚙️ Algorithmic Backend (FastAPI)

We used Python + FastAPI to build a high-throughput asynchronous backend engine.

The ML models execute securely on this layer, isolated from the frontend architecture for improved scalability and deployment flexibility.

Core responsibilities include:

  • Fraud scoring
  • Ensemble inference
  • Threshold governance
  • Compliance logic
  • Real-time metrics generation

🗄️ Live Database Pipeline

We migrated from a local database architecture to a cloud-hosted Supabase PostgreSQL instance.

Our queries and polling pipelines were optimized to ensure the Live Activity Feed updates continuously without degrading latency or exhausting available cloud resources.

🖥️ Web OS Frontend (React + Vite)

Instead of building a traditional dashboard, we engineered a fully interactive glassmorphic Web Operating System featuring:

  • Draggable application windows
  • macOS-inspired dock system
  • Real-time activity feeds
  • Toast notifications
  • Smooth micro-interactions

This design minimizes investigator cognitive load while navigating complex fraud datasets.

Challenges we ran into

AlgoFest strongly emphasizes scalability, which became our biggest engineering challenge.

Managing asynchronous state between:

  • A continuously running Python data-injection worker
  • A cloud PostgreSQL database
  • A React frontend

required careful systems architecture.

Initially, the AI data agent opened too many simultaneous database connections, causing the Supabase instance to crash under connection limits.

We solved this by implementing:

  • Strict connection pooling using asyncpg
  • Batching within the ML scoring pipeline
  • Optimized asynchronous transaction handling

We also carefully tuned frontend polling intervals to reduce unnecessary backend load.

Accomplishments that we're proud of

🧠 Algorithmic Harmony

Successfully balancing:

  • The anomaly sensitivity of an Isolation Forest
  • The sequential behavioral awareness of an LSTM

to create a robust ensemble fraud detection architecture.

🔓 Breaking the Black Box

Demonstrating that advanced ML systems can be paired with LLM-driven explanations to produce transparent, understandable fraud audit trails.

☁️ Full-Stack Optimization

Deploying a fully live, containerized multi-node cloud architecture across:

  • Vercel
  • Render
  • Supabase

while maintaining seamless real-time UI synchronization.

What we learned

We learned that in enterprise FinTech systems, computational logic is not just about making algorithms faster.

It is equally about making algorithms:

  • Explainable
  • Governable
  • Trustworthy
  • Human-centered

One of our biggest insights was learning how to mathematically constrain an AI system to enforce business-critical compliance rules — such as our 95% recall floor lock.

What's next for FraudOS

🕸️ Graph Neural Networks (GNNs)

We plan to implement Graph Neural Networks to model relationships between bank accounts and transaction entities in order to identify coordinated fraud rings algorithmically.

⚡ Real-time WebSockets

We are transitioning from optimized REST polling to full-duplex WebSocket architecture for millisecond-latency fraud alert updates and live UI synchronization.

Tech Stack

Frontend  : React, Vite, TailwindCSS
Backend   : FastAPI, Python
Database  : Supabase PostgreSQL
AI/ML     : Isolation Forest, LSTM, scikit-learn
Cloud     : Vercel, Render
Utilities : Faker, asyncpg

Final Vision

FraudOS (AEGIS.AI) is more than a fraud dashboard.

It is an intelligent, explainable, and regulation-aware fraud investigation operating system built to bridge:

  • Advanced machine learning
  • Human investigator workflows
  • Compliance governance
  • Real-time financial intelligence

Our mission is to drastically reduce alert fatigue while making enterprise AI systems transparent, trustworthy, and operationally scalable.

Built With

Share this project:

Updates