FraudOS (AEGIS.AI) — Rapid Action Fraud Agent

An autonomous financial fraud detection agent built with Gemini 3 and Google Cloud Agent Builder that not only detects anomalies but actively manages risk workflows through MongoDB's MCP server.

Comment

FraudOS (AEGIS.AI)

Inspiration

The Google Cloud Rapid Agent Hackathon challenged developers to build AI systems that do more than simply generate responses — systems that can actually take action autonomously.

When analyzing the financial services sector, we realized that most fraud detection systems today are either:

  • Reactive dashboards
  • Black-box classifiers
  • Basic chatbot assistants

Human investigators still spend nearly 92% of their time reviewing false positives, creating massive inefficiencies in fraud operations.

We were inspired to build “Agent Rahul” — a proactive, Gemini-powered AI agent capable of intercepting financial transactions, evaluating fraud risk, generating human-readable explanations, and actively updating our database through the Model Context Protocol (MCP) to manage the investigator workflow in real time.

What it does

FraudOS (AEGIS.AI) is an end-to-end AI-powered fraud detection operating system built around autonomous agent workflows.

🧠 Multi-Step Fraud Investigation

When a transaction enters the system, our Gemini 3-powered agent performs far more than a simple fraud score calculation.

The agent dynamically plans and executes a multi-step reasoning workflow:

  1. Analyze the incoming transaction
  2. Compare it against historical behavioral patterns
  3. Detect point anomalies and velocity anomalies
  4. Evaluate contextual fraud indicators
  5. Generate a complete plain-English explanation

This transforms raw anomaly detection into actionable financial intelligence.

Example Output

CRITICAL: Transaction amount exceeds normal customer behavior by 14x and originated from an unseen device in a high-risk region.

Instead of exposing investigators to abstract vectors and confidence scores, the system explains exactly why a transaction appears suspicious.

⚡ Taking Action with MCP Integration

The core innovation of FraudOS is that the AI agent does not stop at reasoning — it actively performs system operations.

Using the MongoDB MCP Server, Agent Rahul can:

  • Query historical customer profiles
  • Retrieve transaction history
  • Access contextual behavioral data
  • Write flagged fraud reports directly into MongoDB
  • Update investigator queues in real time

This removes the need for large amounts of traditional middleware and API orchestration.

The agent independently plans its actions and executes database operations through standardized MCP interactions.

👨‍💼 Human Oversight & Governance

Despite the autonomous capabilities of the agent, human investigators remain fully in control of the workflow.

Flagged transactions are routed into an investigator review queue within our React/Vite dashboard, where investigators can:

  • Review the AI reasoning
  • Approve fraud alerts
  • Clear legitimate transactions
  • Monitor system activity in real time

This creates a balanced human-in-the-loop AI governance model suitable for regulated financial systems.

How we built it

☁️ Agent Orchestration (Google Cloud + Gemini)

We used Google Cloud Agent Builder to orchestrate the behavior of our Gemini 3 agent.

The agent was configured with strict financial compliance instructions, allowing it to behave like an intelligent fraud operations analyst capable of:

  • Contextual reasoning
  • Workflow planning
  • Database interactions
  • Compliance-aware evaluations

🗄️ The Superpower — MongoDB via MCP

The biggest architectural breakthrough was integrating the MongoDB MCP Server.

This allowed Gemini to directly:

  • Read historical transaction data
  • Query customer activity
  • Write fraud evaluations back into MongoDB

without requiring extensive backend routing logic.

Instead of relying on traditional REST APIs, the agent simply determines the action it wants to perform and executes the corresponding MCP database operation.

This dramatically simplified our architecture while increasing agent autonomy.

🖥️ Frontend (React + Vite)

We built a premium Web OS-style interface using React and Vite, hosted on Vercel.

The dashboard provides investigators with:

  • Live fraud activity feeds
  • Real-time AI explanations
  • Interactive transaction queues
  • Glassmorphic desktop-inspired UI
  • Smooth animations and notifications

The frontend continuously polls MongoDB to visualize the live actions performed by Agent Rahul.

Challenges we ran into

Transitioning from a traditional REST-based architecture to an MCP-driven agent architecture introduced a major learning curve.

One of the biggest challenges was teaching the Gemini agent how to correctly structure payloads for MongoDB MCP interactions.

Because the agent was directly writing to the database, malformed payloads could potentially create inconsistent data structures.

To solve this, we implemented:

  • Strict schema validation
  • Controlled prompting strategies
  • Payload sanitization pipelines
  • MCP operation constraints

We also spent significant time refining the agent’s reasoning flow to ensure it remained deterministic and financially compliant.

Accomplishments that we're proud of

🤖 True AI Agency

We successfully moved beyond the traditional RAG chatbot model.

Agent Rahul does not merely answer questions — it:

  • Executes database writes
  • Manages investigator queues
  • Performs contextual fraud evaluations
  • Maintains workflow state autonomously

This represents a major step toward operational AI systems.

🔓 Explainable Finance

We leveraged Gemini’s advanced reasoning capabilities to convert highly technical anomaly signals into concise, understandable fraud explanations that non-technical compliance officers can interpret instantly.

This bridges the gap between machine learning systems and human trust.

What we learned

This project taught us the immense power of the Model Context Protocol (MCP).

By giving Gemini direct, standardized access to MongoDB, we eliminated the need for hundreds of lines of traditional API orchestration code.

Instead of manually building routing layers, the workflow became:

  1. Agent reasons about the task
  2. Agent selects the appropriate MCP operation
  3. Agent executes the database action directly

We also learned that autonomous AI systems in finance must prioritize:

  • Explainability
  • Governance
  • Validation
  • Human oversight

as much as raw intelligence.

What's next for FraudOS

📧 Autonomous Customer Verification

We plan to expand Agent Rahul’s toolset to include external integrations such as:

  • Gmail MCP
  • SMS verification services
  • Banking APIs

This would allow the agent to automatically contact customers when suspicious activity is detected.

🧊 Automated Account Protection

In high-confidence fraud scenarios (for example, fraud confidence > 99%), the agent could autonomously:

  • Freeze compromised accounts
  • Temporarily block transactions
  • Trigger emergency security workflows

through secure banking API integrations.

Tech Stack

Frontend   : React, Vite, TailwindCSS
AI Agent   : Gemini 3, Google Cloud Agent Builder
Database   : MongoDB Atlas
Protocol   : MongoDB MCP Server
Backend    : Python, FastAPI
Cloud      : Vercel, Google Cloud
Utilities  : async workflows, schema validation

Final Vision

FraudOS (AEGIS.AI) is not just a fraud dashboard or chatbot.

It is a proactive AI operating system designed to combine:

  • Autonomous AI agents
  • Real-time fraud detection
  • Explainable financial intelligence
  • Human governance
  • Direct database action execution

Our vision is to redefine fraud operations by transforming AI from a passive assistant into an intelligent operational teammate capable of reasoning, acting, and collaborating safely within critical financial systems.

Built With

Share this project:

Updates