ClaimsGuard.Ai | Devpost

Page with claim validation results

Inspiration

Our hackathon team was inspired to build ClaimsGuard.ai after noticing how medical billing inefficiencies create enormous challenges across the healthcare system. Through conversations with healthcare professionals, we discovered that coding errors and claim denials consume valuable time that could otherwise be spent on patient care. The tedious process of manually checking procedure codes, verifying modifier compatibility, and navigating complex billing requirements seemed like a perfect problem for technology to solve. We envisioned a tool that could validate claims in real-time, catching potential issues before submission and streamlining the reimbursement workflow. By creating this solution, we aimed to reduce administrative burden, accelerate payment cycles, and ultimately help healthcare providers focus more on their patients and less on paperwork.

The deeper I got into claims data, the clearer it became: the system is ripe for automation. Legacy infrastructure, manual audits, scattered rules — it was clear there had to be a better way. ClaimGuardians was born from that realization.

What it does

ClaimGuardians is an AI-powered claim denial rule engine that performs pre-submission audits using CMS and payer-specific logic. It fetches claims in FHIR format, checks them against a vectorized knowledge base of rules (like NCCI edits, global surgery periods, etc.), and uses a RAG-based LLM to provide real-time deny/accept decisions with clear explanations.

How we built it

We built a lightweight RAG pipeline using open-source components fetching claims via public APIs, vectorizing CMS and payer rules, and retrieving relevant context at query time. We then use a Groq-hosted LLM to summarize failed rule checks in natural language, allowing providers to understand and fix issues before submission.

Challenges we ran into

While building the rule engine, we encountered the sheer complexity of the rules themselves. Many CMS edits require multiple lookups, cross-referencing modifiers, diagnosis codes, service limits, and time frames. It’s not just about having the rules it’s about knowing how to interpret and apply them correctly. Capturing that logic in a scalable, RAG-compatible way pushed us to rethink our indexing and retrieval strategies.

Accomplishments that we're proud of

We’re proud that we were able to design a system that not only understands rule violations but explains them clearly. That’s rare in healthcare tech. Even more, we see an opportunity to go further: in the future, ClaimGuardians could track electronic health records via member IDs and auto-submit medical documents if a payer requests them — solving another major cause of denials.

If we can scale this to support all CMS and commercial rules, we believe ClaimGuardians could be a game-changing product in the RCM space.

What we learned

We learned that building an engine like this is not just technical it’s clinical, operational, and behavioral. We had to understand why providers code claims the way they do, how payers interpret rules, and how billing teams think about audits. We also saw firsthand the value of combining structured rule logic with natural language retrieval to explain dense compliance issues.

What's next for ClaimGuardians

Our next step is to expand our rule coverage across more payers and specialties, and start integrating EHR-level data to support real-time medical necessity validation. We want ClaimGuardians to not only detect problems, but proactively submit what's needed to prevent denials before they occur.

This is just the beginning but we believe we’re building something with massive impact.