91% of eventually-revoked providers detected from billing patterns alone — before CMS acted on revocation.

CMS loses an estimated $60 billion annually to improper payments across Medicare and Medicaid. Current detection is largely reactive — fraud is identified after payments are made, forcing a costly "pay-and-chase" cycle. Argus is a decision-support system that identifies anomalous provider billing patterns, surfaces evidence-backed risk cases, and provides explainable scores that human reviewers can act on proactively, in real time.

Judge access note: the live website is protected by HTTP basic auth during evaluation. If you have login issues, contact [email protected].

  19GB real CMS data          13 explainable signals           Evidence-backed cases
 (4 public datasets)    ──>  (risk + legitimacy scoring)  ──>  for human investigators
                              + ML anomaly detection            + AI-generated narratives

1. Ingest — 19GB of real, public Medicare data: 9.66M service lines across 10,282 providers from data.cms.gov. No PHI. Core scoring and validation use real public CMS data; synthetic records are only used in separate admin/demo workflows.
2. Score — Every provider-service case receives two independent scores: a risk score (how anomalous vs. peers) and a legitimacy score (how many trust indicators exist). 13 named signals, each with a threshold, weight, and data-source citation. Plus an independent Isolation Forest anomaly score with per-provider feature importance.
3. Investigate — Analysts review flagged cases with full signal breakdowns, peer comparison charts, evidence graphs, and AI-generated narratives. The system explains; the human decides.

We didn't just build a scoring system — we validated it. We took all 335 revoked providers in our dataset, removed the revocation flag, and re-scored them using only behavioral signals.

Methodology: The retrospective validation endpoint (/api/validation) removes the revoked_provider signal and re-scores providers using only behavioral signals, including peer comparisons, enrollment context, charge patterns, and concentration metrics. In the current artifact, 306 of 335 revoked providers still land in the review or high_risk bands without using the revocation label.

Source of truth: data/validation/retrospective_results.json powers the API response and the judge-facing validation story.

Try it live: argus.precise-lab.com/api/validation
The site is behind HTTP basic auth during judging. If access fails, contact [email protected].

Traditional fraud detection produces a single risk score. Argus computes two independent scores for every case. A provider with high volume (risk signal) who is enrolled, Medicare-participating, and peer-aligned on all other metrics (legitimacy signals) won't be flagged — the legitimacy score contextualizes the risk. This reduces false positives and ensures providers aren't flagged on a single anomalous metric.

The Isolation Forest anomaly model provides per-provider feature importance via leave-one-out approximation — not a global average, but which specific features drive this provider's anomaly score. Risk-increasing features shown in red, protective features in green, all computed in under 100ms.

Claims stream via Server-Sent Events, scored by the 13-signal engine in under 50 milliseconds. No batch jobs, no overnight processing — proactive detection as payments arrive.

A dedicated /api/fairness endpoint computes flagging rate disparities across geography and specialty using statistical parity difference, disparate impact ratio (EEOC four-fifths rule), and outlier detection. Configurable threshold. No demographic variables are used in scoring.

AWS Bedrock Claude powers three capabilities: text-to-SQL (analysts ask questions in plain English), risk narratives (structured signals summarized in plain language), and chat (conversational investigation). All AI output is advisory — the scoring engine is fully deterministic and AI-free.

Argus is designed as a decision-support system, not an autonomous enforcement engine.

• Human in the loop: analysts review evidence packages, take explicit case actions, and retain final decision authority.
• Explainable outputs: every case exposes the signals, thresholds, peer baselines, evidence provenance, and narrative explanation behind its score.
• Responsible ML use: the deterministic scoring engine remains primary; the Isolation Forest model is supportive and documented through a formal model card.
• Fairness monitoring: the /api/fairness workflow measures flagging disparities across state and specialty using statistical parity difference, disparate impact ratio, and outlier analysis.

Supporting docs:

• Responsible AI considerations
• Risk scoring methodology
• Isolation Forest model card
• AI and open-source disclosure

Argus is designed to deploy into a government environment with minimal rework.

Bottom line: the path from hackathon MVP to agency pilot is primarily a data connection and integration exercise, not a rebuild.

Total providers scored, risk distribution breakdown, geographic heatmap of state-level flagging patterns, and top-risk cases.

Claims stream across a US map with pulsing risk dots. Each claim scored in <50ms. Click a flagged claim to investigate.

Full signal decomposition: which signals fired, how many points each contributed, peer baseline comparisons, evidence graph, ML anomaly score with per-provider feature importance.

Submit a hypothetical claim and watch the scoring engine extract signals, compute risk + legitimacy, and generate an AI narrative — simulating what pre-payment screening would look like.

Statistical parity and disparate impact metrics across states and specialties. Outlier detection flags systemic bias.

Triaged case queue with approve/flag/deny/escalate actions, audit trail, and AI chat sidebar for natural-language data queries.

Each flagged claim has a dedicated case view with service-line details, z-score metrics, hybrid scoring context, and case-specific AI assistance.

Admin users can ingest raw CMS data, seed demo datasets for sandbox workflows, recalibrate deterministic scores, and retrain models from a tracked pipeline run.

These metrics reflect the repository state as of March 25, 2026.

Argus was built through a disciplined AI-assisted delivery process with human review, automated CI/CD, and GitOps deployment. Full process detail lives in docs/development-process.md.

• Working software first: live product, live API, judge-ready diagrams, and a rehearsed demo script all exist in the repo.
• Operational rigor: GitHub Actions runs quality, security, build, scan, release, and deploy stages; ArgoCD handles cluster sync.
• Traceable execution: daily scoreboards in docs/agile/ record progress, blockers, and decisions across the sprint.
• AI under review: AI-assisted development accelerated delivery, but final architecture, merge, and release decisions remained human-reviewed.

Full specification: Architecture (v3)

All datasets are publicly available and currently downloadable. No PHI is used.

• Problem statement

# Clone
git clone https://github.com/precisesoft/cms-fraud-detection.git
cd cms-fraud-detection

# Start all services (Postgres, Neo4j, API, Frontend)
docker compose up -d

# --- Backend ---
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
pytest --cov=src -q                    # Run backend tests
uvicorn src.api.app:create_app --factory --host 0.0.0.0 --port 8000

# --- Frontend ---
cd frontend
npm install
npm run dev                            # http://localhost:3000
npm test                               # Run frontend tests

# API docs: http://localhost:8000/docs

Demo Day: March 27, 2026 — Reston, Virginia

• Arun Sanna — Lead, AI/ML Engineering, Architecture
• Bibek Poudel — Backend, Infrastructure
• Rahul Vadera
• Reaz Rahman