Research Paper Figure
Research Paper Figure
Research Paper Figure
Research Paper Figure
Research Paper Figure
Research Paper Figure
Research Paper Figure

ClearPath: FHIR-Native Prior Authorization Readiness Agent

ClearPath is a Prompt Opinion agent workflow that converts fragmented clinical context into a clinician-review prior authorization readiness packet.

I built ClearPath for the healthcare AI “last mile”: the gap between raw AI intelligence and a safe, actionable deliverable that can actually fit into a clinician workflow.

This project was created for the Agents Assemble: The Healthcare AI Endgame Challenge, which focuses on building interoperable healthcare agents at the intersection of MCP, A2A, FHIR, and Prompt Opinion’s SHARP-style healthcare context propagation.

Inspiration

Prior authorization is one of the most frustrating administrative workflows in healthcare.

A clinician may already know why a medication is clinically reasonable, but the authorization packet still requires evidence from many places:

diagnoses
laboratory results
medication history
prior therapy failures or intolerance
clinical notes
payer criteria
contraindication documentation
safety confirmations

This is exactly the “last mile” problem Prompt Opinion describes: raw intelligence is not enough. Healthcare AI needs to produce a concrete deliverable that a clinician can review and act on.

ClearPath was inspired by that idea.

Instead of building an AI agent that simply answers questions, I built an agent that helps prepare a prior authorization readiness packet.

The goal is not to replace a clinician or make a coverage decision. The goal is to reduce administrative burden by organizing the evidence, identifying missing documentation, and generating a clinician-review packet.

What ClearPath Does

ClearPath evaluates a synthetic patient, Maria Santos, for semaglutide GLP-1 therapy.

The patient case includes:

Patient: Maria Santos, 52-year-old female
Conditions: Type 2 diabetes mellitus, obesity, hypertension
Requested therapy: Semaglutide GLP-1 therapy
Current medication: Metformin 1000 mg twice daily
Prior medication: Glipizide, discontinued due to symptomatic hypoglycemia
HbA1c: 8.7%
BMI: 34.2 kg/m²
Missing documentation: family history confirmation for medullary thyroid carcinoma or MEN2

ClearPath generates a structured prior authorization readiness packet with:

Requested therapy
Patient summary
Key evidence found
Policy criteria match table
Missing documentation
Draft prior authorization letter
Clinician review note

The final status is:

Ready for clinician review with missing documentation.

ClearPath does not:

prescribe therapy
submit prior authorization
guarantee approval
make a final coverage decision
replace clinician judgment

Why This Matters

Prior authorization is painful because it is not just a form. It is an evidence-alignment problem.

A complete prior authorization packet requires alignment among:

Patient facts
↔ Policy requirements
↔ Safety constraints

ClearPath helps close that gap.

For the demo patient, ClearPath identifies the following supporting evidence:

Type 2 diabetes diagnosis
HbA1c of 8.7%
BMI of 34.2 kg/m²
current metformin therapy
prior glipizide intolerance
documented rationale for GLP-1 therapy

It also identifies the missing safety item:

Family history of medullary thyroid carcinoma or MEN2 is missing or unknown and requires clinician confirmation.

This is the most important safety behavior in the project.

ClearPath does not hallucinate missing safety documentation. It does not treat unknown family history as approval-ready evidence.

The Core Safety Principle

The most important rule in ClearPath is:

Unknown family history ≠ no family history
Unknown family history ≠ positive family history

The correct interpretation is:

Missing documentation requiring clinician confirmation.

This matters because GLP-1 therapies such as semaglutide require careful contraindication review for personal or family history of medullary thyroid carcinoma or MEN2.

ClearPath keeps that uncertainty visible instead of hiding it.

Technical Architecture

ClearPath was built around Prompt Opinion’s interoperability model.

The workflow is:

Prompt Opinion Launchpad
→ Patient context
→ FHIR Context
→ ClearPath Prior Authorization Agent
→ GLP-1 policy criteria
→ Evidence matching
→ Clinician-review packet

The project includes:

ClearPath Prior Authorization Agent
GLP-1 Policy Criteria Agent
A2A-style agent composition
FHIR-style synthetic patient bundle
Reusable skill: extract-glp1-prior-auth-criteria
Policy-grounded prior authorization template
MCP-style technical simulation in Colab
Research figures
Readiness scoring model
GitHub repository
Static project website

Prompt Opinion Implementation

I used Prompt Opinion as the main clinical agent environment.

The live workflow runs through:

Prompt Opinion Launchpad
Patient scope
Maria Santos selected as the patient
ClearPath Prior Authorization Agent
FHIR Context visible
GLP-1 prior authorization readiness output

I also configured a separate GLP-1 Policy Criteria Agent with A2A availability to represent the policy-specialist role.

This follows the challenge theme of building interoperable healthcare agents at the intersection of:

MCP
A2A
FHIR
SHARP-style context propagation
Prompt Opinion agent composition

Agent Components

1. ClearPath Prior Authorization Agent

This is the main workflow agent.

Its role is to:

receive patient context
use GLP-1 policy criteria
identify supporting evidence
detect missing documentation
generate a clinician-review packet
avoid unsafe claims

The ClearPath agent is responsible for the final prior authorization readiness packet.

2. GLP-1 Policy Criteria Agent

This is the policy-specialist agent.

Its role is to extract GLP-1 prior authorization criteria from payer policy content.

It is designed to return:

criterion name
required evidence
whether the criterion is mandatory
missing documentation guidance
clinician-review safety note

This agent was configured with A2A availability so it can be consulted by other agents.

3. Reusable Skill

I created a reusable skill named:

extract-glp1-prior-auth-criteria

The skill is designed to extract GLP-1 prior authorization criteria from policy documents and return a structured checklist.

It focuses on:

Type 2 diabetes diagnosis
HbA1c threshold
metformin or prior therapy requirement
BMI documentation
therapy rationale
contraindication review
MTC/MEN2 family history documentation

FHIR-Style Data Model

The technical notebook models the patient using FHIR-style resources.

The synthetic FHIR bundle includes:

Patient
Condition
MedicationRequest
MedicationStatement
Observation
DocumentReference

These resources represent the evidence needed for the prior authorization packet.

Examples:

FHIR Resource	Purpose
`Patient`	Maria Santos demographics
`Condition`	Type 2 diabetes, obesity, hypertension
`MedicationRequest`	Semaglutide request and metformin therapy
`MedicationStatement`	prior glipizide intolerance
`Observation`	HbA1c, BMI, blood pressure, LDL
`DocumentReference`	clinical note and rationale

This structure shows how ClearPath can operate on realistic healthcare data patterns rather than only free-text prompts.

MCP-Style Tool Design

The Colab technical simulation models ClearPath as a sequence of MCP-style tools.

The simulated tools are:

get_patient_evidence_snapshot
extract_glp1_policy_criteria
match_patient_to_policy
generate_prior_auth_packet

Tool 1: `get_patient_evidence_snapshot`

This tool extracts patient evidence from FHIR-style resources.

It collects:

diagnoses
labs
vitals
medication history
prior therapy history
clinical note evidence
safety documentation

The evidence snapshot can be represented as:

$$ E = {D, L, M, P, R, S} $$

Where:

$D$ = diagnoses
$L$ = laboratory and vital observations
$M$ = medication history
$P$ = prior therapy history
$R$ = documented clinical rationale
$S$ = safety documentation

Tool 2: `extract_glp1_policy_criteria`

This tool converts policy text into structured criteria.

The criteria set is:

$$ C = {c_1, c_2, ..., c_n} $$

Each criterion can be represented as:

$$ c_i = (\text{name}_i, \text{required evidence}_i, \text{mandatory}_i, \text{policy note}_i) $$

For the GLP-1 use case, the criteria include:

Type 2 diabetes diagnosis
HbA1c threshold
metformin trial
BMI documentation
therapy rationale
absence of personal or family history of MTC/MEN2

Tool 3: `match_patient_to_policy`

This tool compares patient evidence against policy criteria.

Each criterion receives a status:

met
needs review
missing

The scoring model is:

$$ m_i = \begin{cases} 1, & \text{criterion is met} \ 0.5, & \text{criterion needs review} \ 0, & \text{criterion is missing} \end{cases} $$

Tool 4: `generate_prior_auth_packet`

This tool generates the final clinician-facing packet.

The packet is modeled as:

$$ P = f(E, C, M, G) $$

Where:

$E$ = patient evidence
$C$ = policy criteria
$M$ = match results
$G$ = safety guardrails

The final packet includes evidence, missing documentation, and clinician-review language.

Readiness Scoring

The technical notebook models prior authorization readiness as:

$$ R = \frac{\sum_{i=1}^{n} w_i m_i}{\sum_{i=1}^{n} w_i} $$

Where:

$R$ = readiness score
$w_i$ = criterion weight
$m_i$ = match score for criterion $i$

In this prototype, all criteria have equal weight:

$$ w_i = 1 $$

Each criterion is scored as:

met = 1.0
needs review = 0.5
missing = 0.0

For the demo patient:

$$ R = \frac{1 + 1 + 1 + 1 + 1 + 0}{6} $$

$$ R = 83.3\% $$

The missing criterion is:

Family history confirmation for medullary thyroid carcinoma or MEN2.

Therefore, the final status is:

Ready for clinician review with missing documentation.

Safety Gating Logic

ClearPath uses a specific safety gate for MTC/MEN2 documentation.

The safety gate is:

$$ g_{\text{MTC/MEN2}} = \begin{cases} 1, & \text{absence of personal and family history is explicitly documented} \ 0, & \text{family history is missing, unknown, or ambiguous} \end{cases} $$

The status rule is:

$$ \text{Status} = \begin{cases} \text{Ready for clinician review}, & R = 100\% \text{ and } g_{\text{MTC/MEN2}} = 1 \ \text{Ready for clinician review with missing documentation}, & R < 100\% \text{ or } g_{\text{MTC/MEN2}} = 0 \end{cases} $$

This prevents the system from converting missing information into a false conclusion.

Algorithm

Input:
  Patient context P
  FHIR evidence bundle F
  Policy document D
  Requested therapy T

Output:
  Prior authorization readiness packet R

1. Select patient in Prompt Opinion Launchpad.
2. Propagate patient-scoped FHIR/SHARP context.
3. Extract structured patient evidence:
      diagnoses
      observations
      medication history
      prior therapy history
      clinical notes
4. Extract GLP-1 policy criteria from the policy document.
5. For each policy criterion:
      identify required evidence
      search patient evidence
      assign status: met, missing, or needs review
6. Apply safety gates:
      do not infer absent MTC/MEN2 history from missing documentation
      do not claim approval
      do not prescribe
      do not submit authorization
7. Compute readiness score.
8. Generate clinician-review packet:
      requested therapy
      patient summary
      key evidence
      policy criteria match table
      missing documentation
      draft letter
      clinician review note
9. Return the packet inside Prompt Opinion.

Research Figures

The project includes research-style figures generated in Colab.

The most important figures are:

Figure 1: ClearPath Architecture

This figure shows the end-to-end workflow:

Prompt Opinion Launchpad
→ Patient Context
→ SHARP/FHIR Context Propagation
→ ClearPath Prior Authorization Agent
→ Policy Matching
→ Prior Authorization Readiness Packet

It also shows the GLP-1 Policy Criteria Agent and FHIR resources as supporting components.

Figure 2: FHIR Resource Composition

This figure shows the FHIR-style resources used in the technical simulation.

The resource model includes:

Observations
Conditions
MedicationRequests
Patient
MedicationStatement
DocumentReference

This supports the feasibility of using FHIR-style data as the evidence layer.

Figure 4: Evidence Completeness Matrix

This is one of the most important figures.

It shows that the system has evidence for:

Type 2 diabetes mellitus
HbA1c threshold
metformin trial
BMI documentation
GLP-1 rationale

But it does not have evidence for:

absence of MTC/MEN2 family history

That missing item is intentionally preserved as a documentation gap.

Figure 7: Agent Orchestration Trace

This figure shows the workflow sequence:

Prompt Opinion Launchpad
SHARP/FHIR Context
ClearPath Prior Authorization Agent
GLP-1 Policy Criteria Agent
MCP-style evidence snapshot
MCP-style policy matching
MCP-style packet generation
Safety layer

This demonstrates that ClearPath is designed as an interoperable workflow, not just a chatbot.

Figure 8: Hypothesized Administrative Effort Reduction

This figure compares manual workflow effort against ClearPath-assisted effort.

The estimate shows a reduction from 31 manual effort units to 10 assisted effort units.

The hypothesized reduction is:

$$ \frac{31 - 10}{31} \times 100 = 67.7\% $$

This is not a measured clinical study result. It is a hypothesis-generating estimate showing the type of administrative burden ClearPath targets.

Figure 9: Policy Readiness Scoring Model

This figure shows the 83.3% readiness score.

Five criteria are met.

One safety criterion is missing.

The missing criterion prevents the packet from being marked fully ready.

Figure 10: Research Evidence Table

This figure summarizes the full case:

Domain	Evidence	Source	Policy Relevance	Status
Diagnosis	Type 2 diabetes mellitus	Condition / clinical note	Required diagnosis	Met
Laboratory	HbA1c 8.7%	Observation	Glycemic threshold	Met
Anthropometric	BMI 34.2 kg/m²	Observation	BMI documentation	Met
Medication	Metformin 1000 mg BID	MedicationRequest	Prior/current therapy	Met
Prior Medication	Glipizide stopped due to hypoglycemia	MedicationStatement / note	Prior therapy intolerance	Met
Safety	Family history of MTC/MEN2 unknown	Clinical note	Contraindication review	Missing

This table is the clearest summary of the project’s value: ClearPath finds the evidence that exists and flags the evidence that is missing.

Results

ClearPath identified five GLP-1 prior authorization criteria as met:

Type 2 diabetes diagnosis
HbA1c threshold
Metformin trial
BMI documentation
Therapy rationale

ClearPath identified one criterion as missing:

Family history confirmation for medullary thyroid carcinoma or MEN2

The final readiness score was:

$$ 83.3\% $$

The final status was:

Ready for clinician review with missing documentation.

The final output was not:

approved
denied
submitted
prescribed

It was a clinician-review readiness packet.

Judging Criteria Alignment

AI Factor

ClearPath uses generative AI for a task that traditional rule-based software does not handle well.

A rules engine can check whether a field exists, but prior authorization often requires synthesis across:

structured FHIR-style data
unstructured clinical notes
medication history
policy criteria
missing documentation
safety constraints

ClearPath uses generative AI to assemble this context into a coherent, clinician-review packet.

The AI is not just answering a question. It is producing an actionable clinical-administrative artifact.

Potential Impact

Prior authorization is a major administrative burden.

ClearPath targets:

reduced documentation search time
fewer incomplete packets
earlier identification of missing evidence
reduced rework
safer packet preparation
clearer clinician review
more structured handoff between clinical data and administrative requirements

The technical simulation estimated a possible administrative effort reduction of:

$$ 67.7\% $$

This is a hypothesis, not a clinical outcome claim, but it clearly shows the workflow burden ClearPath is designed to reduce.

Feasibility

ClearPath is designed around real healthcare constraints.

It is feasible because:

it runs inside Prompt Opinion
it uses patient-scoped context
it models FHIR-style data
it uses A2A-style agent composition
it can be extended with MCP-style tools
it uses clinician-review language
it does not autonomously prescribe
it does not autonomously submit authorization
it does not guarantee approval
it uses synthetic data only for the demo
it explicitly flags missing documentation

The architecture respects the reality that healthcare AI should support clinicians, not bypass them.

What I Built

I built:

a Prompt Opinion prior authorization agent
a GLP-1 policy criteria agent
an A2A-enabled policy specialist workflow
a reusable skill package
a synthetic FHIR transaction bundle
a GLP-1 prior authorization policy document
a readiness packet template
a Colab technical notebook
evidence extraction logic
policy matching logic
readiness scoring logic
research visualizations
a GitHub repository
a static project website

What I Learned

I learned that healthcare AI should not be designed as one giant prompt.

It should be designed as a workflow with:

context
standards
tools
agents
safety gates
clinician review

The most important lesson was that uncertainty must be preserved.

A missing clinical fact should not be converted into a confident conclusion.

For ClearPath, the safest and most useful output is:

This packet is ready for clinician review, but family history documentation must be confirmed before submission.

Challenges

The hardest challenge was making the system both useful and safe.

Early testing showed that the model could incorrectly interpret missing MTC/MEN2 family history as a positive contraindication or as a final eligibility decision.

That failure mode was important because it showed why safety gates are necessary.

I addressed this by redesigning the workflow around:

explicit missing-documentation language
readiness scoring
clinician-review status
no approval claims
no prescribing language
no submission language
uncertainty-preserving logic

This made the final project safer and more realistic.

Why ClearPath Is Not Just a Chatbot

ClearPath is not just a chatbot because it has:

a defined clinical-administrative workflow
patient-scoped context
FHIR-style evidence representation
policy criteria matching
readiness scoring
A2A-style policy agent design
MCP-style tool simulation
safety gates
clinician-review output
reusable artifacts
research figures
deployment-ready documentation

It does not simply respond to a prompt. It converts fragmented healthcare context into a structured deliverable.

Limitations

ClearPath is a prototype.

The current demo uses synthetic patient data.

The readiness score is a technical demonstration, not a validated clinical metric.

The administrative effort reduction is a hypothesis, not a measured outcome.

The A2A policy-agent path was configured, but the stable live demo used the main ClearPath workflow because long A2A calls sometimes caused latency issues.

The FHIR integration was modeled technically in Colab and represented in Prompt Opinion with patient context and FHIR Context visible.

A production version would need:

direct FHIR querying
payer-specific policy libraries
audit logs
source-level evidence citations
clinician sign-off workflow
privacy and security review
real-world validation

Future Work

The next version of ClearPath would include a production MCP server with tools such as:

get_patient_evidence_snapshot
extract_policy_requirements
match_patient_to_policy
generate_prior_auth_packet

It would also include:

direct FHIR queries using patient context
stronger A2A orchestration
shorter policy-agent responses to reduce latency
evidence provenance for every generated claim
source references such as Observation IDs and DocumentReference IDs
support for multiple payer policies
additional prior authorization categories

Possible future use cases include:

MRI prior authorization readiness
specialist referral readiness
durable medical equipment requests
high-cost biologic therapy authorization
clinical trial pre-screening packets

Final Outcome

ClearPath demonstrates the healthcare AI endgame: converting raw intelligence into a standards-aligned, clinician-review deliverable.

It is not an autonomous decision-maker.

It is a safe administrative synthesis agent that helps clinicians prepare better prior authorization packets inside Prompt Opinion.

The final result is:

Ready for clinician review with missing documentation.

That is the core idea: useful, safe, interoperable healthcare AI that helps close the last mile without taking the clinician out of the loop.

Built With

agent-to-agent-(a2a)-workflow-design
chart.js
css
fhir-context
github
github-pages-/-netlify
google-ai-studio
google-colab
google-gemini
html
javascript
json
latex
markdown
mcp-style-tool-architecture
prompt-opinion
prompt-opinion-a2a-agents
prompt-opinion-launchpad
prompt-opinion-marketplace-studio
python
sharp-style-context-propagation
synthetic-fhir-transaction-bundle

ClearPath: FHIR-Native Prior Authorization Readiness Agent

Inspiration

What ClearPath Does

Why This Matters

The Core Safety Principle

Technical Architecture

Prompt Opinion Implementation

Agent Components

1. ClearPath Prior Authorization Agent

2. GLP-1 Policy Criteria Agent

3. Reusable Skill

FHIR-Style Data Model

MCP-Style Tool Design

Tool 1: get_patient_evidence_snapshot

Tool 2: extract_glp1_policy_criteria

Tool 3: match_patient_to_policy

Tool 4: generate_prior_auth_packet

Readiness Scoring

Safety Gating Logic

Algorithm

Research Figures

Figure 1: ClearPath Architecture

Figure 2: FHIR Resource Composition

Figure 4: Evidence Completeness Matrix

Figure 7: Agent Orchestration Trace

Figure 8: Hypothesized Administrative Effort Reduction

Figure 9: Policy Readiness Scoring Model

Figure 10: Research Evidence Table

Results

Judging Criteria Alignment

AI Factor

Potential Impact

Feasibility

What I Built

What I Learned

Challenges

Why ClearPath Is Not Just a Chatbot

Limitations

Future Work

Final Outcome

Built With

Updates

Tool 1: `get_patient_evidence_snapshot`

Tool 2: `extract_glp1_policy_criteria`

Tool 3: `match_patient_to_policy`

Tool 4: `generate_prior_auth_packet`