Automate Denied Claims Appeals: Build an AI Agent That Resubmits

Every healthcare billing team has the same dirty secret: a spreadsheet somewhere tracking denied claims that nobody has time to appeal. Maybe it's a shared drive folder. Maybe it's a stack of EOBs sitting on someone's desk. Either way, it represents real money — often hundreds of thousands of dollars per year — that organizations simply forfeit because the appeal process is too manual, too slow, and too painful to scale.

Here's the thing: most denied claims that get appealed actually win. The success rate on appealed claims runs 50–75% depending on payer and specialty. The problem was never that appeals don't work. The problem is that they take so damn long to prepare that most organizations only appeal 35–50% of the denials they believe are winnable.

That math should make you angry. It made us angry enough to figure out how to automate it.

This post walks through exactly how to build an AI agent on OpenClaw that handles denied claims appeals — from parsing the denial, pulling the right documentation, drafting the appeal letter, and resubmitting it with the correct attachments. We'll cover what the manual workflow looks like today, where the real pain lives, what an AI agent can realistically handle right now (no hype), and what still needs a human in the loop.

The Manual Workflow: 8 Steps, 45–180 Minutes Per Claim

Let's get specific about what actually happens when a claim gets denied. If you work in RCM, you already know this is painful. If you don't, prepare to be horrified.

Step 1: Denial Intake & Triage. Someone receives an ERA or EOB — electronic remittance advice or explanation of benefits. They need to identify the denial reason code. CO-97 (bundling). PR-204 (service not covered). Medical necessity. Missing authorization. There are hundreds of these codes, and what they actually mean in practice varies by payer.

Step 2: Root Cause Analysis. Was it a coding error on your side? Missing documentation? A clinical disagreement where the payer simply doesn't think the service was necessary? Did someone forget to get prior authorization? This step often requires pulling charts from the EHR, and it's where a lot of institutional knowledge lives — experienced billers just know that Aetna denies these codes for this reason and UHC wants this specific documentation.

Step 3: Eligibility & Timeline Check. Verify the patient still had coverage on the date of service. Check the appeal filing deadline — which ranges from 30 to 180 days depending on the payer and state. Miss the deadline and it's game over, no matter how strong your case is.

Step 4: Medical Records Retrieval. Pull clinical notes, operative reports, lab results, imaging reports, physician orders. These live in different systems — EHR, radiology information systems, PACS. In many organizations, this step alone takes 15–45 minutes because the documentation is scattered and someone has to manually compile it into a coherent package.

Step 5: Appeal Letter Preparation. Write a narrative letter — typically 2 to 10 pages — that cites specific clinical evidence, references the payer's own medical policy, cites clinical guidelines (NCCN for oncology, InterQual, Milliman criteria), and makes a clear case for why the denial should be overturned. Most organizations have templates, but every appeal requires significant customization. A good appeal letter is essentially a legal brief with clinical evidence.

Step 6: Clinical Review and Sign-Off. For medical necessity denials, a nurse or physician needs to review the appeal for clinical accuracy. This pulls clinical staff away from patient care and is one of the most resented tasks in healthcare.

Step 7: Submission. Submit via the payer's portal, fax, mail, or EDI. Yes, fax. In 2026. Many payers still require paper submissions for complex appeals, and each portal has different upload requirements, file format preferences, and attachment limits.

Step 8: Tracking and Follow-Up. Log the appeal in whatever tracking system exists (often a spreadsheet), then call the payer repeatedly to check status. Average payer response time is 37–67 days. If denied again, escalate to Level 2 appeal, independent medical review, or external review.

Average staff time per appeal: 45 to 180 minutes for standard cases. Complex, high-dollar, or peer-to-peer cases can eat 4 to 20+ hours. The cost to process a single appeal runs $75 to $350 depending on complexity.

Multiply that across hundreds or thousands of denials per month and you start to understand why organizations leave money on the table.

Why This Hurts: The Real Costs

The statistics tell the story clearly:

$262 billion in claims were initially denied in 2023 (Change Healthcare). About $105 billion was ultimately recovered on appeal — which means over $150 billion was lost.
Denial management and appeals consume 10–18% of total RCM staff time in many organizations (MGMA, HFMA surveys).
Hospitals lose an average of 3–5% of net revenue to unappealed or unsuccessfully appealed denials (HFMA 2023).
Insurers deny roughly 1 in 7 claims (AMA 2023), with denial rates hitting 25–40% in complex specialties like cardiology, oncology, and orthopedics.

Beyond the numbers, there are compounding problems that make manual appeals unsustainable:

Payer fragmentation is brutal. There are thousands of payer-specific rules, and they change constantly. What UnitedHealthcare requires for a lumbar fusion appeal is completely different from what Cigna wants. Medical policies get updated quarterly. Keeping track of all of this manually is a full-time job — often several full-time jobs.

Interoperability is still terrible. EHRs and payer systems don't communicate effectively. Pulling documentation from Epic to attach to a Cigna portal submission is still a manual, click-heavy process.

Clinical staff burnout is real. Every hour a nurse spends reviewing appeal letters is an hour not spent on patient care. Peer-to-peer calls with payer medical directors are scheduled during clinical hours and are universally despised.

The filing deadline pressure creates triage nightmares. When you have 200 denials to process and only enough staff to handle 80, you're constantly making judgment calls about which ones to pursue. Often, high-dollar but complex cases get deprioritized because they take too long, even though they'd recover the most revenue.

This is the exact kind of workflow where AI agents deliver the highest ROI: repetitive, document-heavy, rules-driven at the core but with enough variation to require intelligence rather than simple scripts.

What AI Can Actually Handle Right Now

Let's be honest about where the technology is and isn't. I'm going to break this into three categories: what you can automate today with high confidence, what you can semi-automate with human oversight, and what still needs a person.

Fully Automatable (High Confidence)

Denial reason parsing and categorization. An AI agent can read ERA/EOB data, identify denial codes, and categorize them by type (coding error, medical necessity, authorization, bundling, etc.) with near-perfect accuracy.
Triage and prioritization scoring. Using historical data on overturn rates by payer, denial code, procedure type, and dollar amount, a model can score which denials are worth appealing. Many production systems achieve 80%+ accuracy on predicting appeal outcomes.
Filing deadline tracking and alerting. Completely automatable. No reason any appeal should ever miss a deadline.
Automated documentation retrieval. An agent connected to your EHR can pull relevant clinical notes, operative reports, and lab results based on the claim's diagnosis codes, procedure codes, and date of service.
Payer policy matching. A knowledge base of payer medical policies, indexed and searchable, so the agent can identify exactly which policy applies and what criteria the payer expects to see documented.

Semi-Automatable (AI Drafts, Human Reviews)

Appeal letter generation. This is where the biggest time savings come from. An LLM-based agent can generate a 70–80% complete first draft that cites the right clinical evidence, references the correct payer policy, and structures the argument appropriately. A human reviewer then refines and approves it.
Clinical documentation summarization. The agent can extract and summarize relevant clinical findings from a patient's chart, but a clinician should verify the summary before it goes to a payer.
Resubmission with corrected information. For simple denials (wrong modifier, missing NPI, incorrect member ID), the agent can correct and resubmit autonomously. For clinical denials, it prepares the package for human review before submission.

Still Needs a Human

Final clinical judgment on gray-area medical necessity cases. AI can surface the evidence and make a recommendation, but the ultimate determination — especially for high-dollar or precedent-setting cases — needs a clinician.
Peer-to-peer calls with payer medical directors. These are physician-to-physician conversations. AI can prepare the talking points and supporting evidence, but a doctor needs to make the call.
Legal and compliance review for cases that might escalate to external review or litigation.
Rare diseases, experimental treatments, and truly novel clinical situations where there isn't sufficient historical data.

Step-by-Step: Building the Automation on OpenClaw

Here's the practical implementation. We're building an AI agent on OpenClaw that handles the appeal workflow from denial intake through resubmission. The architecture involves several connected components.

Step 1: Set Up the Denial Intake Pipeline

The agent needs to ingest denial data from your ERA/835 files or payer portal exports. On OpenClaw, you'd configure an intake node that watches for new denial records:

# denial_intake_agent.yaml
name: denial_intake
trigger:
  type: webhook
  source: ehr_era_feed
process:
  - parse_835_denial_codes
  - extract_claim_metadata:
      fields: [claim_id, patient_id, dos, cpt_codes, icd_codes, payer_id, denial_reason_code, billed_amount]
  - categorize_denial_type:
      model: denial_classifier_v2
      categories: [medical_necessity, coding_error, authorization, bundling, timely_filing, eligibility, duplicate]
  - calculate_appeal_priority:
      factors: [billed_amount, historical_overturn_rate, filing_deadline_days_remaining, denial_category]
output:
  destination: appeal_queue
  escalate_if: priority_score > 0.7

This intake agent does in seconds what manually takes 10–20 minutes per denial: it parses the code, categorizes the reason, and scores the priority.

Step 2: Build the Documentation Retrieval Agent

This agent connects to your EHR and pulls the relevant clinical documentation. The key word is relevant — you don't want to dump the entire chart. You want the specific notes, results, and reports that support the appeal.

# doc_retrieval_agent.yaml
name: clinical_doc_retriever
trigger:
  type: queue_item
  source: appeal_queue
process:
  - query_ehr_api:
      patient_id: "{{claim.patient_id}}"
      date_range: [dos_minus_30, dos_plus_7]
      doc_types: [progress_notes, operative_reports, lab_results, imaging_reports, physician_orders, prior_auth_records]
  - filter_by_relevance:
      model: clinical_relevance_scorer
      icd_codes: "{{claim.icd_codes}}"
      cpt_codes: "{{claim.cpt_codes}}"
      min_relevance_score: 0.6
  - summarize_clinical_evidence:
      model: medical_summarizer_v3
      output_format: structured_evidence_brief
  - compile_attachment_package:
      format: pdf
      include: [relevant_docs, evidence_summary]
output:
  destination: appeal_drafting_queue
  attachments: compiled_package

The relevance scorer is critical here. It filters out the noise — you don't need the patient's dental records for a cardiac catheterization appeal. The clinical summarizer then produces a structured brief that the letter-drafting agent can reference.

Step 3: Build the Appeal Letter Drafting Agent

This is where the LLM capability in OpenClaw really shines. The agent generates an appeal letter that's specific to the payer, the denial reason, and the clinical evidence:

# appeal_letter_agent.yaml
name: appeal_letter_drafter
trigger:
  type: queue_item
  source: appeal_drafting_queue
process:
  - lookup_payer_policy:
      payer_id: "{{claim.payer_id}}"
      cpt_codes: "{{claim.cpt_codes}}"
      policy_database: payer_medical_policies_kb
  - lookup_clinical_guidelines:
      icd_codes: "{{claim.icd_codes}}"
      guideline_sources: [nccn, interqual, cms_lcds, specialty_society]
  - generate_appeal_letter:
      model: openclaw_medical_appeal_llm
      inputs:
        denial_reason: "{{claim.denial_category}}"
        clinical_evidence: "{{evidence_summary}}"
        payer_policy: "{{matched_policy}}"
        clinical_guidelines: "{{matched_guidelines}}"
        claim_details: "{{claim}}"
      template: appeal_letter_v4
      tone: professional_assertive
      max_length: 2500_words
  - format_submission_package:
      include: [appeal_letter, clinical_attachments, claim_form_copy]
      payer_format: "{{payer_submission_requirements}}"
output:
  destination: human_review_queue
  flag_if: denial_category == "medical_necessity" AND billed_amount > 10000

Notice the output goes to a human_review_queue, not straight to submission. For medical necessity denials, especially high-dollar ones, you want a human — ideally a clinician — to review before it goes out. For simple coding corrections or missing information resubmissions, you can configure the agent to submit directly after a lower threshold of review.

Step 4: Configure Submission and Tracking

# submission_agent.yaml
name: appeal_submitter
trigger:
  type: approval
  source: human_review_queue
process:
  - determine_submission_method:
      payer_id: "{{claim.payer_id}}"
      methods_database: payer_submission_methods_kb
      # Returns: portal_upload, edi_837, fax, mail
  - submit_appeal:
      method: "{{submission_method}}"
      credentials: "{{payer_portal_credentials}}"
      attachments: "{{submission_package}}"
  - log_submission:
      destination: appeal_tracking_db
      fields: [claim_id, submission_date, method, confirmation_number, expected_response_date]
  - schedule_followup:
      days_after_submission: [14, 30, 45, 60]
      action: check_status_and_escalate
output:
  confirmation: appeal_tracking_dashboard

The follow-up scheduling is key. The agent automatically checks back on submitted appeals at set intervals, so nothing falls through the cracks. On each check, it can query payer portals for status updates or flag cases that need a phone call.

Step 5: Wire It All Together With a Master Orchestrator

On OpenClaw, you connect these individual agents into a pipeline with an orchestrator that handles the routing logic:

# master_orchestrator.yaml
name: denial_appeal_orchestrator
pipeline:
  - agent: denial_intake
  - agent: clinical_doc_retriever
    condition: appeal_priority_score > threshold
  - agent: appeal_letter_drafter
  - agent: human_review_router
    rules:
      - if: simple_coding_error → auto_approve_and_submit
      - if: medical_necessity AND amount < 5000 → nurse_review
      - if: medical_necessity AND amount >= 5000 → physician_review
      - if: authorization_denial → auth_team_review
  - agent: appeal_submitter
  - agent: followup_tracker
monitoring:
  dashboard: appeal_metrics
  alerts:
    - filing_deadline_approaching (< 7 days)
    - high_value_denial_unprocessed (> 48 hours)
    - appeal_success_rate_drop (< historical_baseline - 10%)

You can find pre-built agent templates for healthcare RCM workflows on Claw Mart, which gives you a starting point instead of building everything from scratch. There are denial classification models, payer policy knowledge bases, and appeal letter templates already available that you can customize for your specific payer mix and specialty.

What Still Needs a Human (Be Honest About This)

No AI agent should be making final clinical determinations on ambiguous medical necessity cases. Period. The agent is phenomenal at surfacing the right evidence, matching it to the right policy, and drafting a compelling letter. But when the question is "was this surgery truly medically necessary given this patient's specific clinical picture?" — that's a physician's call.

The same goes for peer-to-peer reviews. The agent can prepare a comprehensive briefing packet with talking points, relevant literature citations, and the payer's own policy criteria mapped against the patient's documentation. But the actual conversation with the payer's medical director needs to be a physician.

Legal escalation, compliance review, and cases involving experimental treatments or rare conditions also stay human. The ROI of AI is in handling the volume of routine appeals efficiently so your skilled staff can focus their time on these high-judgment cases.

Expected Time and Cost Savings

Based on production deployments of similar architectures (and published results from organizations using AI-driven denial management), here's what's realistic:

Time reduction per appeal:

Simple denials (coding errors, missing info): From 45–60 minutes → 5–10 minutes (mostly review and approval clicks). That's an 80–85% reduction.
Medical necessity denials (standard): From 90–180 minutes → 25–40 minutes (agent does the heavy lifting, clinician reviews). That's a 60–75% reduction.
Complex/high-dollar appeals: From 4–20 hours → 2–8 hours (agent prepares everything, human does the judgment work). That's roughly a 50% reduction.

Financial impact for a mid-size health system processing 500 denials/month:

If you're currently appealing 40% of denials and winning 55% of those, you might recover ~$110 per $1,000 in denied charges.
With AI-driven triage (appealing 75%+ of winnable denials) and better-prepared appeals (winning 65–70%), you could recover ~$195 per $1,000 in denied charges.
For an organization with $20 million in annual denials, that's roughly $1.7 million in additional recovered revenue.
Staff time savings of 35–50% on appeals work translates to either redeploying FTEs to other revenue cycle functions or handling growing denial volumes without adding headcount.

Cost to build and maintain: On OpenClaw, you're looking at the platform subscription plus the time to configure and tune your agents. Compared to building from scratch (which would require NLP engineers, healthcare data specialists, and 6–12 months of development), you're compressing implementation to weeks. The pre-built components on Claw Mart accelerate this further.

Next Steps

If you're losing revenue to unworked denials — and statistically, you almost certainly are — here's the move:

Audit your current denial volume and appeal rate. Pull 90 days of data. How many denials? How many appealed? What's the overturn rate? What's the average staff time per appeal? This gives you the baseline to measure against.
Start with one denial category. Don't try to automate everything at once. Pick your highest-volume, most formulaic denial type — usually coding errors or missing documentation. Build and validate the agent pipeline for that category first.
Browse Claw Mart for pre-built healthcare RCM agent components. There are denial classifiers, payer policy knowledge bases, and appeal letter templates that give you a 60–70% head start.
Configure your first pipeline on OpenClaw. Use the architecture above as a starting point. Connect your ERA feed, your EHR API, and your payer submission channels.
Run in shadow mode first. Have the agent generate appeal packages but route 100% to human review for the first 2–4 weeks. Compare the agent's output quality to your current manual output. Tune the prompts and policies until the quality is consistently high.
Gradually increase autonomy. As confidence builds, let simple denial types flow through with minimal human touchpoints. Keep the human review gates on medical necessity and high-dollar cases.
Clawsource it. If you'd rather not build from scratch, Claw Mart connects you with developers and pre-built agents specifically designed for healthcare revenue cycle automation. Find someone who's already solved this for your EHR and payer mix, and get to recovered revenue faster.

The money is sitting there in your denial queue. The technology to go get it exists today. The only question is how long you're willing to keep leaving it on the table.

Automate Denied Claims Appeals: Build an AI Agent That Resubmits with Correct Documentation