Automate Radiology Prior Auth and Scheduling: Build an AI Agent That Handles Both
Automate Radiology Prior Auth and Scheduling: Build an AI Agent That Handles Both
Every radiology practice in America has someone — usually several someones — whose entire job is fighting with payer portals. They pull clinical notes from one system, re-type them into another, call a phone tree, wait on hold, get denied, call again, fax something, wait some more, and eventually schedule the patient for an MRI that should have happened two weeks ago.
This is not a technology problem in the traditional sense. The technology exists. The problem is that nobody has wired it together in a way that actually works end to end.
That's what this post is about: building an AI agent on OpenClaw that handles both prior authorization and scheduling for radiology — the full loop — so your staff can stop being copy-paste machines and start handling the cases that actually need a human brain.
The Manual Workflow (And Why It's Stuck in 2009)
Let's walk through what actually happens when a referring physician orders an outpatient MRI today. Not the idealized version. The real one.
Step 1: Order Intake. The referring doc places the order in the EHR. A PA coordinator or scheduler sees it land in their worklist. Already, there's a gap — the order might sit there for hours before anyone touches it.
Step 2: PA Requirement Check. The coordinator checks whether this specific payer, for this specific CPT code, for this specific plan type, requires prior authorization. This check often involves a spreadsheet maintained by someone who left six months ago, a payer portal, or tribal knowledge. Advanced imaging — MRI, CT, PET, nuclear medicine — triggers PA roughly 60 to 80 percent of the time.
Step 3: Clinical Data Gathering. This is where the real time sink lives. The coordinator pulls progress notes, lab results, previous imaging reports, documentation of conservative treatment, symptom duration — often from multiple EHR modules or even faxed records. For a spine MRI, they might need to document six weeks of physical therapy that's buried in a referring provider's notes from a different health system.
Step 4: Portal Entry. All of that clinical information gets manually entered into whatever portal the payer uses — EviCore, AIM Specialty Health, Carelon, or one of the Blue Cross plan-specific systems. CPT codes, ICD-10 codes, clinical narrative. Typed by hand.
Step 5: Submission and Waiting. The request goes in. Sometimes you get an immediate auto-approval. More often, you get a request for additional information or a status of "under review." The median time from order to performed exam is 7 to 13 days. For something that might be cancer, that's not acceptable.
Step 6: Follow-Up. Staff checks the portal daily. Or calls. Average of 2 to 5 follow-ups per case. Each one takes 5 to 15 minutes.
Step 7: Denial and Peer-to-Peer. If denied (8 to 18 percent initial denial rate for advanced imaging), a radiologist or referring physician has to get on the phone with a payer medical director. That's 15 to 45 minutes of a physician's time for a single case.
Step 8: Scheduling. Only after approval can the patient actually be scheduled. Then someone has to log the outcome, update the RCM system, and coordinate with the patient.
The AMA's 2023 data says this process eats 16 to 20 hours per week of physician time and 37 to 50 hours of staff time per physician equivalent. The CAQH Index puts the national cost at $18 to $24 billion annually. Per transaction, manual PA costs $11 to $17.
These aren't theoretical numbers. They're what your practice is spending right now.
What Makes This So Painful
Three things compound the misery:
Fragmentation. There are over 100 unique payer rule sets that change quarterly. What Aetna requires for a lumbar MRI is different from what UnitedHealthcare requires, which is different from what your regional Blue Cross plan requires. And they all change their portals and rules on different timelines.
Poor interoperability. Most payer portals don't accept structured data from EHRs. Your staff is literally reading a screen on one system and typing it into another. In 2026. With their hands.
Documentation variability. The clinical notes in your EHR range from beautifully structured to incomprehensible voice-dictated walls of text. An AI that can't handle both is useless.
The downstream effects: 93 percent of physicians report PA delays care. Twenty-four percent say it has led to serious adverse events. Denial rates are high enough that practices employ entire teams just to process appeals — and 50 to 70 percent of those appeals succeed, which means the initial denial was wrong in the first place.
What AI Can Handle Right Now
Not everything. But a lot more than most practices realize.
Here's what an AI agent built on OpenClaw can reliably do today:
Eligibility verification and PA requirement detection. Given a patient's insurance information and the ordered procedure, the agent checks whether PA is required. This replaces the spreadsheet and the "let me look that up" step entirely.
Clinical data extraction via NLP. This is the big one. OpenClaw agents can process unstructured clinical notes — dictated, templated, messy, whatever — and extract the specific clinical elements that payers care about: symptom duration, failed conservative treatments, red-flag symptoms, prior imaging dates and findings, relevant lab values. What takes a human 12 to 18 minutes per case takes the agent seconds.
Form population and submission. The agent maps extracted clinical data to the specific fields required by each payer's submission process. Where payer APIs exist, it submits directly. Where they don't, it can use RPA to interact with web portals or generate pre-filled fax forms.
Guideline matching. The agent evaluates the clinical scenario against ACR Appropriateness Criteria and payer-specific rules. If the case clearly meets criteria — "usually appropriate" score with complete documentation — it flags it for fast-track submission. EviCore already auto-approves 35 to 45 percent of cases when structured data aligns with guidelines. The trick is getting the data structured in the first place.
Status monitoring and follow-up. The agent polls payer portals for status updates and escalates to staff only when human action is needed.
Denial prediction and appeal drafting. Based on the clinical data and payer patterns, the agent can predict which cases are likely to be denied and pre-build appeal documentation with supporting evidence.
How to Build This With OpenClaw: Step by Step
Here's a concrete implementation path. This assumes you have EHR access (read, at minimum) and a team that can handle the integration work or a partner from Claw Mart who specializes in healthcare workflows.
Step 1: Define Your Agent's Scope
Start narrow. Don't try to automate every payer and every imaging modality on day one. Pick your highest-volume combination — say, outpatient MRI for your top three commercial payers. That probably covers 40 to 60 percent of your PA volume.
In OpenClaw, you'll create an agent with a clear system prompt that defines its role:
You are a radiology prior authorization agent. Your job is to:
1. Determine if prior authorization is required for the given order
2. Extract relevant clinical information from provided documentation
3. Match the clinical scenario against payer-specific criteria
4. Prepare and submit the authorization request
5. Monitor status and escalate when human intervention is needed
You operate under the following constraints:
- Never fabricate clinical information
- Flag any case where documentation is ambiguous or incomplete
- Escalate to human review when confidence is below 85%
- Log every action for audit purposes
Step 2: Build the PA Requirement Detection Tool
Your agent needs a tool that takes insurance information and CPT codes and returns whether PA is required. This is a structured lookup — perfect for a tool call.
@tool
def check_pa_requirement(
payer_id: str,
plan_type: str,
cpt_code: str,
place_of_service: str
) -> dict:
"""
Check whether prior authorization is required for a given
payer/plan/procedure combination.
Returns: {required: bool, portal: str, turnaround_sla: str, notes: str}
"""
# Query your PA rules database
# This replaces the spreadsheet your team maintains
rule = pa_rules_db.lookup(payer_id, plan_type, cpt_code, place_of_service)
return {
"required": rule.pa_required,
"portal": rule.submission_portal,
"turnaround_sla": rule.expected_turnaround,
"notes": rule.special_instructions,
"auto_approve_eligible": rule.cds_auto_pathway
}
The pa_rules_db here is your own structured database of payer rules. You'll need to build and maintain this, but the point is it's queryable and version-controlled — not a spreadsheet on Karen's desktop.
Step 3: Build the Clinical Extraction Tool
This is where OpenClaw's language capabilities do the heavy lifting. The agent processes clinical documentation and extracts the specific elements each payer wants to see.
@tool
def extract_clinical_elements(
clinical_notes: list[str],
procedure_type: str,
body_region: str,
payer_id: str
) -> dict:
"""
Extract PA-relevant clinical elements from provided documentation.
Returns structured data mapped to payer-specific requirements.
"""
# Define what elements this payer needs for this procedure
required_elements = get_payer_requirements(payer_id, procedure_type, body_region)
# Use OpenClaw's NLP to extract from unstructured notes
extracted = openclaw_extract(
documents=clinical_notes,
target_elements=required_elements,
confidence_threshold=0.85
)
# Flag any missing or low-confidence elements
missing = [e for e in required_elements if e not in extracted or extracted[e]["confidence"] < 0.85]
return {
"extracted_elements": extracted,
"missing_elements": missing,
"documentation_sufficient": len(missing) == 0,
"guideline_score": match_acr_criteria(extracted, procedure_type, body_region)
}
The key design decision: set your confidence threshold conservatively. If the agent isn't at least 85 percent confident it has the right clinical information, it should flag for human review. Fabricating clinical data on a PA submission is a compliance nightmare you don't want.
Step 4: Build the Submission Tool
This varies by payer. For payers with APIs (increasingly common), it's a direct integration. For portal-based payers, you'll use browser automation. For the dinosaurs still requiring fax, you generate and transmit a completed form.
@tool
def submit_pa_request(
patient_id: str,
payer_id: str,
clinical_data: dict,
cpt_codes: list[str],
icd10_codes: list[str],
ordering_provider: dict,
rendering_provider: dict
) -> dict:
"""
Submit prior authorization request to the appropriate payer system.
"""
submission_method = get_submission_method(payer_id)
if submission_method == "api":
result = submit_via_api(payer_id, build_x12_278(patient_id, clinical_data, cpt_codes, icd10_codes))
elif submission_method == "portal":
result = submit_via_portal_rpa(payer_id, patient_id, clinical_data, cpt_codes, icd10_codes)
elif submission_method == "fax":
form = generate_pa_form(payer_id, patient_id, clinical_data, cpt_codes, icd10_codes)
result = transmit_fax(payer_id, form)
return {
"confirmation_number": result.confirmation,
"submission_method": submission_method,
"expected_response_date": result.estimated_response,
"status": result.initial_status
}
Step 5: Connect Scheduling
This is the part most automation efforts miss. The agent shouldn't stop at "PA approved." It should trigger the scheduling workflow immediately.
@tool
def initiate_scheduling(
patient_id: str,
procedure_code: str,
pa_confirmation: str,
modality: str,
preferred_location: str = None,
urgency: str = "routine"
) -> dict:
"""
Once PA is approved, find available slots and initiate patient scheduling.
"""
available_slots = query_scheduling_system(
modality=modality,
location=preferred_location,
urgency=urgency,
lookahead_days=14
)
# Select optimal slot based on urgency and patient preferences
recommended_slot = rank_slots(available_slots, urgency, patient_preferences)
# Trigger patient outreach for scheduling
outreach_result = send_scheduling_notification(
patient_id=patient_id,
recommended_slots=recommended_slot[:3],
pa_confirmation=pa_confirmation,
method="sms_and_portal" # or phone for patients who prefer it
)
return {
"recommended_slots": recommended_slot[:3],
"outreach_sent": outreach_result.success,
"scheduling_link": outreach_result.patient_link
}
Step 6: Orchestrate the Full Loop
Now wire it all together. In OpenClaw, your agent orchestrates these tools in sequence, making decisions at each step:
- New order arrives → Check PA requirement
- PA required → Extract clinical elements from available documentation
- Documentation sufficient → Match against guidelines and submit
- Documentation insufficient → Generate specific request to referring provider's office ("We need documentation of conservative treatment duration for lumbar spine — please provide PT notes from the past 6 weeks")
- Submitted → Monitor status on configured polling interval
- Approved → Trigger scheduling immediately
- Denied → Evaluate denial reason, draft appeal, escalate for P2P if needed
The agent handles steps 1 through 6 autonomously for straightforward cases. It escalates at any point where confidence drops below threshold or human judgment is genuinely needed.
Step 7: Build the Monitoring Dashboard
Your PA coordinators need visibility into what the agent is doing. Build a dashboard that shows:
- Cases in progress, by status (submitted, pending additional info, approved, denied)
- Cases escalated for human review, with reason
- Average turnaround time (before and after automation)
- Auto-approval rate by payer
- Denial rate and appeal outcomes
This isn't optional. Auditability is a compliance requirement, and your team needs to trust the system before they'll rely on it.
What Still Needs a Human
Be honest about the boundaries. Here's what your staff still handles:
Peer-to-peer reviews. Payers require a physician talking to a physician. No AI agent is getting on a phone call with a medical director. Your radiologists still own this, but the agent can prepare a P2P brief with all relevant clinical data, guideline citations, and the specific denial rationale so the physician walks in armed.
Edge cases with ambiguous documentation. When the clinical notes are genuinely unclear — conflicting information, incomplete records, complex comorbidities — a human needs to make the judgment call about what to submit.
Complex appeals. The agent can draft appeal letters and compile supporting evidence. But appeals that require narrative clinical reasoning or incorporation of new information should be reviewed by clinical staff.
Compliance sign-off. Especially for Medicare Advantage and government plans, someone with clinical credentials should review submissions before they go out. The agent prepares everything; the human approves.
Patient communication for sensitive situations. When a denial means a patient can't get a study they're anxious about, that conversation should be human-to-human.
The realistic split: 60 to 70 percent of cases handled autonomously, 20 to 25 percent handled with AI-assisted prep and human execution, 10 to 15 percent requiring substantial human involvement.
Expected Savings
Based on published data from organizations that have implemented similar automation (Cohere Health, Waystar clients, and academic medical centers published in JACR), here's what's realistic:
Time reduction: PA processing time drops from 12 to 18 minutes per case to 2 to 4 minutes for the cases that still need human touch, and near-zero for auto-processed cases. Total staff time on PA decreases 50 to 65 percent.
Turnaround improvement: Median time from order to exam drops from 7 to 13 days to 2 to 5 days. For auto-approved cases, same-day or next-day scheduling becomes feasible.
Cost per transaction: From $11 to $17 manual down to $2 to $6 automated. For a practice processing 500 PAs per month, that's $4,500 to $5,500 in monthly savings on direct processing costs alone — before you count the staff time reallocation.
Denial rate reduction: Better upfront documentation and guideline matching reduces initial denials by 30 to 50 percent. Fewer denials means fewer appeals, fewer P2P calls, fewer delayed patients.
Staff reallocation: You're not eliminating PA coordinator positions. You're redirecting them from data entry to handling complex cases, improving documentation quality, and actually talking to patients. The people doing the work today will tell you this is a massive quality-of-life improvement.
Getting Started
If you're running a radiology practice or department and this resonates, here's the pragmatic path:
Option 1: Build it yourself on OpenClaw. If you have a technical team (or a technical partner), start with the architecture above. OpenClaw gives you the agent framework, the tool-calling infrastructure, and the NLP capabilities. You bring the payer rules, EHR integration, and domain expertise. Start with your top three payers and one modality. Expand from there.
Option 2: Use a pre-built solution from Claw Mart. The Claw Mart marketplace has healthcare workflow agents built by teams that have already solved the EHR integration, payer portal connectivity, and compliance questions. You're not starting from scratch — you're configuring and deploying.
Option 3: Clawsource it. If you want a custom build but don't have the technical team, Clawsourcing connects you with developers who specialize in building OpenClaw agents for healthcare operations. They build it, you run it, your patients get their imaging faster.
The radiology PA problem isn't going away — payers aren't suddenly going to stop requiring authorization for advanced imaging. But the way you handle it doesn't have to stay stuck in 2009. The tooling is here. The question is whether you'll keep paying $17 per transaction for someone to copy-paste between screens, or build something that actually works.