Denied claims are one of the most overlooked drivers of revenue loss in healthcare. During an on-site discovery session, Commure found that one healthcare organization lost $3.2 million annually, or 5% of its ARR, due to unpaid outstanding balances. This was simply the result of a lack of infrastructure in place to efficiently triage, correct, and resubmit denied claims.
This is a both a grim and common state of affairs for healthcare practices. A recent study of 280 hospitals across 23 states found that:
- Adjudication of claims cost hospitals over $25.7 billion in 2023, marking a 23% increase over what was reported the previous year.
- Nearly 70% of denials were ultimately overturned, but only after several costly rounds of review. This means that healthcare practices incurred roughly $18 billion in unnecessary expenses.
Clearly, the inefficiencies of current systems contribute heavily to this enormous amount of wasted time and resources.
In response to this issue, Commure built out a proprietary AI Denial Automation System that automates away over 80% of denied claim reprocessing. This system decreases labor costs on denial resubmissions, increases claim resubmission volume, and significantly improves denial re-approval rates.
Understanding Insurance Claim Denials
Here’s a quick refresher on the relevant part of the lifecycle of a claim, illustrating just how many steps are involved and, consequently, how many opportunities there are for human error and for a claim to get stuck in process.
Payers deny claims constantly for all kinds of reasons. Figure 1 depicts the general flow of the section of the claim submission process in which denials occur.
Payers then send their decisions and any payments in the form of remittances. If the claim was denied, either fully or partially, they indicate the reasons for the denial with Claim Adjustment Reason Codes (CARCs) and Remittance Advice Remark Codes (RARCs).
While there are overall trends as to which CARC/RARC combinations most commonly occur, different practices often see spikes in denials for CARCs and RARCs unique to their practice or field. This is why Commure tailors automatic denial tracking and resubmission to each practice, rather than taking a one-size-fits-all approach.
We can see this phenomenon occur in the following sample data from two sites during Q4 of 2024. Figure 2 shows that nearly half of all denials for this practice come from CARC 59, the code for apparently concurrent procedures that get billed as individual procedures.
Figure 3, on the other hand, reveals that nearly three quarters of this practice’s denials are due to CARC 104, which indicates that a provider sent inadequate or incomplete supporting documentation for the services they rendered.
The potential lost revenue exceeds $250,000 in one quarter just from that single CARC. For a practice with $6.7 million ARR, needlessly losing $1 million a year because of missing documentation is painful.
In all cases involving manual claim recon and denial resubmission, humans are both far slower and more prone to error than machines and AI proactively detecting potential errors and executing established rules and flows. The longer claims take to process, the more expensive they get for the practice.
Some of the revenue lost to unworked denials will be written off, damaging the practice’s financial health. Some will be pushed onto patients, who end up paying or going into debt over getting medical care for which they should not be held liable. When denials are accepted not worked and resubmitted, patients and practices both lose.
This is why cheap and effective automation of both the initial claim submission process and denial resubmission process is increasingly crucial for healthcare practices. This is also where Commure’s proprietary rules engines and AI solutions shine.
How Large Language Models (LLMs) Can Prevent Denials Before Submission
What are LLMs?
Large language models (LLMs) are deep learning models trained on huge amounts of text data that can then perform a variety of natural language processing (NLP) and analysis tasks, including translating, classifying, and generating text. Due to the sheer breadth of their knowledge base, they can provide reasonably accurate answers to queries, even in the absence of specifically labeled examples.
Data Ingestion & Analysis
At Commure, we train our LLMs on a massive corpus of historical claims, payer denial responses, and policy documents. Our AI agent can fetch EOBs, work denials, and complete other repetitive tasks. They automatically leverage the resources of supporting LLMs and engines. For example, we utilize an LLM that tests data we extract from EHRs, and another that empowers human staff with precise recommendations for coding denials and rejections (Figure 4). The agents parse through payer documents and surface these coding recommendations with a 95% QA pass rate.
We use these agents to ingest encounter-level data from EHRs, remittances, and insurance responses to build a knowledge graph that can:
- Surface payer-specific denial patterns.
- Run deep research across structured and unstructured payer documents to extract specific policy nuances.
- Recommend compliant CPT, ICD, and modifier codes based on past success rates.
Pre-submission Validation
Commure’s LLMs validate claims in real-time by identifying missing fields, incorrect codes, and misaligned documentation. Submissions are automatically reviewed against payer-specific rules and historical data, with our AI agent, Scout, flagging errors and proposing corrections before submission.
In one workflow, for example, Scout automates submission integrity QA by validating claim formatting and billing rules—tripling QA coverage and significantly improving first-pass acceptance rates.
Integration with Existing Systems
Commure embeds LLM-based validation directly within systems like our database, Normandy, and external EHRs such as Athena and AMD. These tools automatically pull and reconcile patient, payer, and encounter data, ensuring seamless pre-submission verification.
Automating Denial Management and Resubmission
Automated Denials Explanation Analysis
Commure’s LLMs extract denial reasons from insurer responses, mapping them to specific errors in the original claims. In order to stay a step ahead, we also scrape payer policies and preemptively create rules in the rule engine to prevent denials based on recent payer policy changes.
In real-world deployments, Scout uses standardized templates to generate concise denial notes (Figure 5) that are automatically added to claims—automating 40% of related tasks with over 2,000 AI-generated notes weekly.
Intelligent Claim Modification
Scout and Denial Copilot suggest fixes based on prior approvals of CARCs/RARCs and payer policy interpretation. Whether it’s a missing authorization or a modifier mismatch, AI tools generate corrected claims and route them for immediate resubmission.
The authorization debugging workflow, for example, identifies prior auth numbers within EHRs and auto-resubmits if found. In cases where prior auth cannot be found, it can initiate AI calls to validate whether prior auth is required for the billed procedures, if the payer has it on file, and then reprocess the claim if applicable. LLMs will also summarize the key points of the phone call.
Figure 6, below, shows daily automatic claim modifications and resubmissions for a particular practice over a one-month period.
Autonomous Resubmission Process
Commure integrates with clearinghouses and portals via APIs and robotic workflows. For Medicare appeals, Scout extracts medical records, generates the appeal package, and submits it via portals like Novitas—achieving $127K in billed charge automation with zero human error.
AI Agents: Automated Calls for EOB Procurement
When an ERA is not received within the predefined SLA, our AI agents initiate automated outbound calls to payers to retrieve the ERA and extract any associated denial codes. This integration minimizes manual intervention in the A/R follow-up process. As of this writing, the system executes approximately 1,500 calls daily—automating 80% of related workflows and delivering annualized savings of $195,000, with continued efficiency gains expected.
Deep Dive Into Automated Denial Management
Let’s take a closer look at Commure’s process for rules establishment and management automation for the tens of thousands of denials that pour in every day.
As mentioned above, LLMs can customize our engines to evaluate, categorize, and resolve claim denials through rule-based logic and insurance detection mechanisms. We do this for each of our partner practices. This section breaks down how denials are classified and how we use structured batch submissions, enriched patient data, and external eligibility checks to drive intelligent claim resubmissions.
Denial Categorization by RARC/CARC/Payer
Every claim that enters our resubmission pipeline is first evaluated to determine the type of denial it encountered and track which payers consistently send which kinds of denials:
- Coverage-related denials (identified by specific CARC and RARC codes) are prioritized for automated eligibility verification.
- For example, (CARC) CO 22 indicates denial due to care that may be covered by another payer per coordination of benefits. All CO 22 denials will therefore enter this category and corresponding workflow.
- Other denial types may be resolved through standard workflows without invoking insurance detection.
- Diagnosis and modifier code denials are good examples here.
- Note that once eligibility and coverage are established, all other possible reasons for denial are analyzed and remedied at once. The claim is then sent through our engine again in a dry run prior to resubmission.
For coverage denials, our engine checks for updated patient insurance information (PII) and validates it with real-time eligibility checks. If active coverage is confirmed, a new claim submission is created. If not, the system prepares to engage insurance detection.
Change in Submission Payloads
When a denial progresses to resubmission—especially one influenced by insurance detection—the claim payload must adapt dynamically. Key components updated in the payload include:
- Insurance company ID (determined via match against historical claims or clearinghouse results)
- Subscriber/dependent information (pulled from eligibility response or existing PII)
- Coverage priority (inferred based on denial type, existing insurance, and returned coverage)
We leverage an [upsert_verify_and_submit_claim_correction] endpoint, passing a [fields_to_update_dict] to make direct, surgical updates to claims without requiring custom rules engine invocations. This approach mirrors how manual claims are currently corrected.
Listening for and Acting on Denial Batches
Our system processes denied claims in batches of 500, drawn via [_get_denied_claims_to_analyze]. These are inserted into a tracking table [resubmission_batches], where each claim is marked with [has_run_completed = False]. Claims are processed individually, and this flag is updated accordingly.
Once all claims in a batch are marked complete, we check—under DB-level locking—that no [has_run_completed = False] entries remain. Only then do we trigger insurance detection for that batch, ensuring batch integrity and avoiding duplicate processing.
Insurance Detection Flow
For claims reaching the insurance detection stage, the following workflow is used:
- Tracking:
- Unique patient/DOS combinations are logged in [
insurance_detection_resubmission_tracking], preventing duplicate inquiries within a defined time frame. - If a matching entry exists but lacks a usable result, the system skips resubmission and awaits response.
- Unique patient/DOS combinations are logged in [
- Submission:
- Claims eligible for detection (new or failed past attempts) are batched into a [
.COV]file and sent to our clearinghouse via SFTP. - Each request is logged in [
insurance_detection_batches], and individual inquiries are stored in [insurance_detection_checks], linked by [batch_id].
- Claims eligible for detection (new or failed past attempts) are batched into a [
- Ingestion and Matching:
- Periodic jobs parse clearinghouse response files into [
insurance_detection_check_details], using file name correlation for mapping. - These results determine next steps for each claim.
- Periodic jobs parse clearinghouse response files into [
Automated Resubmission Logic
When eligibility results are returned, we assess whether a claim can be auto-resubmitted:
- Active coverage with a match score of [
STRONG], [PROBABLE], or [PROBABLE_NO_ADDRESS]is required. - We map clearinghouse payer data to our internal insurance company records, using:
- Historical claims at the site
- Encounter billing type (PROFESSIONAL, INSTITUTIONAL, WC)
- Payer name and clearinghouse payer ID
- Priority logic distinguishes between primary and secondary claims based on denial reasons and available coverage.
If subscriber or dependent information is missing, fallback strategies pull PII from our database, provided the relationship is verifiable. If any required fields are missing and cannot be inferred confidently, we escalate the claim to manual review.
This streamlined, rule-driven approach allows our LLMs to intelligently manage denials, adapt submissions, and reduce manual overhead, while maintaining strong safeguards around data accuracy and claim validity.
Overcoming Implementation Challenges
Commure ensures full compliance with HIPAA, GDPR, and payer-specific mandates by implementing:
- End-to-end encryption
- Role-based access control
- Detailed audit logs
Data Security and Privacy Risks
All patient data processed by Scout is encrypted in transit and at rest. The system’s architecture follows zero-trust principles and ensures minimal human access to PHI.
Model Accuracy and Explainability
LLM-driven decisions are made transparent via audit trails, human-readable recommendation logs, and QA pipelines that validate every automated task. Denial Copilot and EOB Copilot include explainable AI features, with manual override options.
Adoption by Healthcare Providers and Insurers
To build trust, Commure delivers measured rollouts and demonstrates measurable cost savings—e.g., $100K+/year from eligibility detection automation alone
The Future of AI in Insurance Claims Processing
As models improve, we anticipate:
- Real-time adjudication: AI-powered negotiation and approvals during patient encounters.
- Proactive coverage detection: Automated and highly accurate eligibility checks before services are rendered.
- Expansion beyond claims: Fraud detection, personalized billing plans, and real-time patient financial education.
The trajectory is clear: AI will soon be a copilot across all of RCM—not just denials.
Commure is reshaping medical claims processing with scalable, accurate, and autonomous AI agents. By preventing denials before submission, streamlining rework, and integrating deeply with existing systems, Commure reduces costs, enhances accuracy, and improves outcomes for providers and patients alike.
With 80% of RCM already automated and a roadmap to reach 95%, Commure invites industry stakeholders to explore what AI-driven claims processing can unlock for the future of healthcare.
Many thanks to all the engineers who lent their expertise for this blog post: Rithesh Shetty, Jasu Mandakh, Yash Wani, Jasdeep Grover, Jordan Chow, and Thuy Ngo. You all do incredible work.
Share this story
.png)
.jpg)
.jpg)
