VIGIL

The Problem

Insurance billing fraud is hard to catch because claim documents are messy, unstructured images and PDFs, and existing tools either hand the consequential fraud decision to an LLM (opaque, undefendable) or require manual auditor review of every claim (slow, expensive). The system needed to be both accurate and legally defensible in a regulated environment.

My Role

Full-stack and AI engineer, #1 GitHub contributor on a team of 4 at GenAI Genesis 2026 (1,000+ participants).

The Approach

• Built a five-layer LangGraph pipeline (Perception, Reasoning, Planning, Action, Reflection) with 14 specialized agents, each with typed input/output contracts, so every stage is independently testable and auditable.
• Implemented the fraud scoring engine as pure deterministic Python (fee deviation, procedure-code risk, provider history), driven by a YAML policy file, so no LLM ever owns the consequential 0-100 fraud score, the model only handles messy OCR extraction and plain-language summarization.
• Added a compliance and bias gate (with optional IBM watsonx.ai validation), an immutable audit log, and a mandatory human approval step before any high-risk action is taken, mirroring financial-services governance patterns.
• Validated the full user-facing flow with a 26-test Playwright E2E suite and stored state in Supabase PostgreSQL behind a FastAPI backend with JWT auth and a structured-logging metrics endpoint.

Key Decisions

• Chose a multi-agent graph over a single large prompt specifically because fraud detection requires transparency: each agent has a bounded responsibility, the fraud path, benefits path, compliance path, and audit path are decoupled, and the graph is easier to explain to a regulator than an opaque chain-of-thought answer.
• Kept the consequential scoring deterministic and outside the LLM, the LLM extracts and summarizes, but weighted Python components produce the score. This means the system can always produce a human-readable breakdown of why a claim was flagged, which is non-negotiable in a regulated or legal context.
• Migrated from Snowflake to Supabase PostgreSQL mid-hackathon by isolating storage behind an abstraction layer, which let us rewire the persistence implementation without touching the agent pipeline, proving the value of interface-driven design under pressure.

Impact & Results

• Received a GKE Turns 10 Honourable Mention at GenAI Genesis 2026, competing against 1,000+ participants.
• Shipped 21,000+ lines of code and a 26-test Playwright E2E suite covering the full receipt-to-fraud-decision flow within the hackathon window.
• Demonstrated that a governance-first, human-in-the-loop architecture (deterministic scoring, immutable audit log, compliance gate, mandatory human approval) is achievable at hackathon speed and directly transferable to regulated financial-services AI.

The Stack

What I Learned

• Building VIGIL convinced me that the right boundary for LLMs in high-stakes systems is language-heavy perception and explanation, not consequential decisions, the moment a fraud score came out of a prompt, it became unauditable, and that tradeoff was not worth the simplicity gain.
• The mid-hackathon Snowflake-to-Supabase migration taught me that isolation matters more than you think: because we had abstracted the storage layer early, the rewrite was a contained two-hour task rather than a pipeline-wide refactor under deadline pressure.
• Orchestration complexity is the real cost of multi-agent design, not LLM latency, coordinating 14 agents with typed contracts and parallel execution paths required careful graph design and explicit error boundaries, which is the engineering discipline I would carry into any production agentic system.