How to Automate Medication Prior Authorization with AI

Every week, somewhere in your practice, a staff member is printing a form, gathering chart notes, filling in tiny boxes, faxing it to an insurance company, and then waiting. Then calling. Then faxing again. Then calling again.

That's prior authorization. And it's eating your practice alive.

The AMA's 2023 survey puts the number at 14 hours per week per physician spent on PA. That's nearly two full working days, every week, dedicated to asking permission to do the thing you already decided was the right clinical move. Across the U.S. healthcare system, the administrative burden of prior authorization costs an estimated $90–100 billion annually. Not on the drugs themselves. On the paperwork to approve the drugs.

Here's the thing: the vast majority of that work is mechanical. It's data collection, form filling, portal navigation, status checking, and resubmission. It's work that an AI agent can do right now, today, with current technology. Not in some speculative future. Now.

This post walks through exactly how to automate medication prior authorization using an AI agent built on OpenClaw. No hand-waving. Specific steps, specific capabilities, specific limits.

The Manual Workflow: What Actually Happens Today

Let's be precise about what a PA request looks like when done by hand, because you can't automate what you don't understand:

Step 1: Trigger identification. A clinician prescribes a medication. The EHR or pharmacy benefit manager flags it as requiring prior authorization. This is usually automatic, but the flag often just means "good luck, here's more work."

Step 2: Clinical data collection. Staff pulls together patient demographics, ICD-10 diagnosis codes, medication history, documentation of previously failed therapies (step therapy requirements), relevant lab results, clinical notes, and the rationale for medical necessity. This data lives in multiple places—structured EHR fields, unstructured clinical notes, lab systems, sometimes even other providers' records.

Step 3: Form completion. Fill out the payer-specific PA form. These are typically 2–6 pages. Every payer has their own format, their own criteria, their own quirks. There is no universal form. A practice dealing with 10+ payers is managing 10+ different form templates.

Step 4: Submission. Fax it. Yes, in 2026, fax is still one of the most common submission methods. Alternatively: upload to a payer portal (each payer has their own), call it in, or use an electronic PA platform like CoverMyMeds.

Step 5: Follow-up. Check status every 1–3 business days. Respond to requests for additional information, which are extremely common. Handle the "payer ping-pong" where you're asked for information that was already in the original submission.

Step 6: Outcome management. If approved, notify the pharmacy and patient. If denied, decide whether to appeal, gather additional documentation, and potentially schedule a peer-to-peer review between the prescribing physician and a payer medical director.

Step 7: Patient communication. Tell the patient what's happening with their medication. Manage expectations. If the drug changes, restart the entire process.

Each PA takes 16–30 minutes of staff time on average. Complex cases—specialty drugs, oncology agents, biologics—can take 45+ minutes. A typical physician handles 45 PAs per week. An MGMA study pegged the cost at $40–$50 per PA in personnel time alone.

Thirty-five percent of practices have staff whose entire job is prior authorization. Their whole day. Every day.

Why This Is So Painful

The time and money numbers above are bad enough, but the downstream effects are worse:

Patient harm from delays. 94% of physicians report that PA causes care delays. The average turnaround is 2 business days, but complex cases regularly stretch to 1–2 weeks. For a patient with cancer waiting on an oncology agent, or a patient with a psychiatric condition waiting on a mood stabilizer, those delays aren't just inconvenient. They're dangerous.

Treatment abandonment. 89% of physicians say patients abandon prescribed treatment due to PA hassles. The patient just… gives up. Doesn't get the drug they need because the administrative machinery ground them down.

High denial rates. Initial denial rates run 15–30% for certain drug classes. Many of those denials are for administrative reasons—missing information, wrong form, coding errors—not clinical reasons. They're fixable, but fixing them takes another round of the same manual process.

Staff burnout. PA work is repetitive, low-autonomy, and frustrating. It's a major contributor to administrative burnout and a reason people leave healthcare jobs. When your skilled staff spends their day on hold with insurance companies, you have a retention problem.

Fragmentation. There are hundreds of payers, each with different forms, criteria, portals, and processes. No standardization. Every PA is a small research project: what does this payer require for this drug for this diagnosis?

What AI Can Handle Right Now

Not everything in PA requires a physician's brain. In fact, most of it doesn't. Here's the breakdown of what's automatable with current AI technology, and specifically what you can build with OpenClaw:

Highly Automatable (70–85% of routine PA volume)

Clinical data extraction and form population. This is the biggest time sink and the biggest win. An OpenClaw agent can process unstructured clinical notes—the messy, narrative physician documentation—and extract the specific data points a PA form requires: diagnosis codes, prior medications tried and failed, relevant lab values, dates of service, clinical rationale. Natural language processing has gotten genuinely good at this. A 2023 JAMIA study showed automated extraction hitting 87% accuracy on key clinical elements from notes—and that was with general-purpose models, not agents fine-tuned for the task.

Payer rules matching. Given a drug, a diagnosis, and a payer, determine: is PA required? What are the specific criteria? Has this patient already met them based on their chart? An OpenClaw agent can ingest payer formulary rules and clinical criteria documents, then cross-reference them against patient data in real time.

Form completion and submission. Once the data is extracted and matched against requirements, populating the actual form is mechanical. An agent can fill every field, attach supporting documentation, and submit through the appropriate channel—whether that's an ePA API, a portal, or generating a fax-ready document.

Status monitoring and follow-up. Instead of a human checking payer portals every day, an OpenClaw agent can monitor submission status, detect requests for additional information, and either respond automatically (if it's a simple data request) or alert staff immediately with the specific information needed.

Missing information detection. Before submission, the agent reviews the complete package and flags gaps. "This payer requires documentation of two failed formulary alternatives, but the chart only documents one." Catching this before submission eliminates the most common reason for administrative denials.

Approval likelihood prediction. Based on historical patterns—this drug, this diagnosis, this payer, this set of clinical criteria—the agent can estimate approval probability. If it's near-certain, fast-track it. If it's likely to be denied, flag it for a clinician to add stronger documentation before submitting.

Step-by-Step: Building a PA Automation Agent on OpenClaw

Here's the practical implementation path. This isn't theoretical—it's the workflow you'd build in the OpenClaw platform.

1. Define Your Agent's Scope

Start narrow. Pick one drug class (e.g., GLP-1 agonists for diabetes, or TNF inhibitors for rheumatoid arthritis) and one or two payers that represent your highest PA volume. You'll expand later, but launching tight lets you validate accuracy before scaling.

In OpenClaw, you'd define this as an agent with a specific task domain:

Agent: medication_pa_processor
Domain: prior_authorization
Scope: GLP-1_agonists
Payers: [UnitedHealthcare, Aetna]

2. Ingest Payer Criteria

Feed the agent the actual payer criteria documents for your target drugs. These are usually available as PDFs or web pages from the payer's provider portal. The OpenClaw agent parses these into structured decision logic.

knowledge_base:
  - source: "UHC_PA_Criteria_GLP1_2024.pdf"
    type: payer_criteria
    parser: clinical_document
  - source: "Aetna_Formulary_Criteria_GLP1.pdf"
    type: payer_criteria
    parser: clinical_document

The agent extracts the specific checklist: required diagnosis codes, step therapy requirements (which drugs must be tried first), required lab values (e.g., HbA1c thresholds), documentation requirements.

3. Connect to Clinical Data

This is where OpenClaw connects to your EHR or clinical data source. The agent needs access to patient records to extract relevant information. Depending on your EHR, this might be via FHIR API (increasingly available in Epic, Cerner, and others), HL7 feeds, or structured data exports.

data_sources:
  - type: fhir_api
    endpoint: "https://your-ehr.org/fhir/r4"
    auth: oauth2
    scopes: [patient.read, condition.read, medicationrequest.read, observation.read]
  - type: clinical_notes
    format: unstructured_text
    extraction_model: clinical_nlp_v2

The agent pulls: active diagnoses, medication history, lab results, clinical notes documenting medical necessity, and prior PA outcomes.

4. Build the Decision and Extraction Pipeline

This is the core logic. When a new PA request is triggered, the agent:

Identifies the drug, patient, and payer
Retrieves the payer's specific criteria
Extracts relevant clinical data from the patient's chart
Maps extracted data to form requirements
Identifies gaps (missing labs, undocumented step therapy)
Populates the PA form
Generates a clinical narrative for the medical necessity section

workflow:
  trigger: new_pa_request
  steps:
    - extract_patient_clinical_data
    - match_payer_criteria
    - gap_analysis
    - if gaps_found:
        - alert_staff_with_specifics
    - else:
        - populate_pa_form
        - generate_medical_necessity_narrative
        - route_for_review_or_submit

The medical necessity narrative is where the LLM capability in OpenClaw really shines. Instead of a staff member writing a paragraph about why this patient needs this drug, the agent drafts it from chart data: "Patient has type 2 diabetes mellitus (E11.65) with HbA1c of 9.2% as of [date]. Patient has previously trialed and failed metformin (initiated [date], discontinued [date] due to GI intolerance) and glipizide (initiated [date], HbA1c remained above 8.5% after 90 days). Requesting [drug] based on clinical guidelines recommending GLP-1 agonist therapy after failure of two oral agents."

That paragraph takes a human 10–15 minutes to write from chart review. The agent generates it in seconds.

5. Human Review Gate

This is critical, and I'll expand on it below—but your workflow must include a clinician review step for anything the agent flags as uncertain, complex, or high-stakes. In OpenClaw, you configure confidence thresholds:

review_policy:
  auto_submit_threshold: 0.92  # High confidence, routine case
  human_review_threshold: 0.75  # Moderate confidence, flag for review
  escalate_threshold: 0.60      # Low confidence, requires clinician input

Routine cases with clear criteria match go straight to submission. Edge cases get queued for human eyes with the agent's work already done—form filled, narrative drafted, gaps identified.

6. Post-Submission Monitoring

After submission, the agent monitors for outcomes:

monitoring:
  check_frequency: daily
  actions:
    on_approved: notify_pharmacy, notify_patient, log_outcome
    on_info_requested: extract_requested_info, draft_response, queue_for_review
    on_denied: analyze_denial_reason, draft_appeal, escalate_to_clinician

Denial management is a huge area. The agent can analyze the denial reason, cross-reference it against the submitted documentation, and draft an appeal letter with additional clinical evidence—all before a human touches it.

7. Iterate and Expand

Once your initial agent is running reliably on one drug class and two payers, expand. Add more payers, more drug classes, and refine based on outcomes data. OpenClaw tracks approval rates, processing times, and intervention rates so you can measure exactly what's improving.

What Still Needs a Human

I'm not going to pretend AI handles everything. Here's where human judgment remains essential:

Complex medical necessity decisions. When a patient has unusual comorbidities, needs off-label use, or when the clinical situation genuinely doesn't fit neatly into payer criteria, a clinician needs to make the call and articulate the reasoning. The agent can prepare the case—summarize the evidence, draft the argument—but the clinical decision is human.

Peer-to-peer reviews. When a denial triggers a phone call between your physician and a payer medical director, that's a real-time clinical conversation. No AI agent is doing that. (The agent can prepare a briefing document with all relevant clinical data and talking points.)

Appeals with nuanced argumentation. The agent can draft an appeal letter, and for straightforward denials it may be excellent. But appeals that require citing recent clinical literature, arguing against payer criteria based on individual patient circumstances, or making ethical arguments need physician involvement.

Rare diseases and edge cases. If you're treating something that shows up 1 in 100,000 times, the agent won't have enough pattern data to be reliable. Flag these for full human handling.

Final sign-off and liability. The organization and the prescribing clinician are legally responsible for what gets submitted. Always maintain a human-in-the-loop, even if that human is just reviewing and approving the agent's work product in 30 seconds instead of building it from scratch in 30 minutes.

Expected Savings

Let's be conservative and do the math:

Current cost per PA: $40–$50 in staff time
PAs per physician per week: 45
Staff time per PA: 20 minutes average

With an OpenClaw-powered agent handling 70% of routine PA volume end-to-end (with quick human review) and reducing the remaining 30% to half the manual time:

Routine PAs (70%): From 20 minutes → 2 minutes (review and approve agent's work). Savings: 18 minutes each × 31.5 PAs = 567 minutes/week saved per physician
Complex PAs (30%): From 20 minutes → 10 minutes (agent does prep, human handles judgment). Savings: 10 minutes each × 13.5 PAs = 135 minutes/week saved per physician
Total: ~700 minutes (nearly 12 hours) saved per week per physician

That's the 14 hours from the AMA survey cut down to roughly 2. Your PA staff goes from being full-time form-fillers to exception handlers—focusing their expertise where it actually matters.

In dollar terms, at $45 average cost per PA and 2,340 PAs per physician per year: you're looking at roughly $70,000–$80,000 in annual labor savings per physician in PA-related staff costs. For a 20-provider practice, that's over a million dollars a year redirected from paperwork to patient care.

The clinical impact matters too. Faster PA turnaround means fewer patients abandoning treatment. Fewer administrative denials from missing information. Higher first-pass approval rates. Cohere Health—one of the more mature clinical AI PA platforms—has reported 15–20% improvement in approval rates and turnaround times dropping from days to hours. There's no reason a purpose-built OpenClaw agent can't hit similar numbers.

Get Moving

The PA automation problem is well-defined, the technology is mature enough, and the savings are large enough that there's no reason to keep throwing human hours at it. The barrier was never the AI—it was the integration work, the payer fragmentation, and the workflow design. OpenClaw gives you the platform to handle all three.

If you want to skip the build-from-scratch phase, Claw Mart has pre-built agent templates for healthcare administrative workflows, including prior authorization. You can find PA agents that other practices have already built, tested, and refined—then customize them for your payer mix and drug formulary.

For practices that want a custom build tailored to their exact EHR setup, payer mix, and clinical specialties, Clawsourcing connects you with builders who specialize in healthcare AI agents. Post your project, describe your workflow, and get matched with someone who's already solved this problem for a practice like yours.

Start with one drug class. One payer. Prove it works. Then scale.

Your staff has better things to do than sit on hold with insurance companies. Let the agent handle the hold music.