💻 computer science

PathWISE: Multi-Agent Cancer Pathway Triaging Ontology Learning from Clinical Flowcharts

PathWISE is a multi-agent pipeline that transforms non-computable clinical cancer pathway flowcharts into validated, executable HL7 CQL libraries by combining LLM-based extraction with deterministic graph auditing and compiler verification to ensure 100% syntactic success while surfacing governance gaps without hallucination.

Original authors: Sofiat Abioye, Ufaq Khan, Shazad Ashraf, Mohammed Adil Butt, Andrew D. Beggs, Adam Byfield, Anusha Jose, William Poulett, Ben Wallace, Junaid Qadir, Muhammad Bilal

Published 2026-05-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Sofiat Abioye, Ufaq Khan, Shazad Ashraf, Mohammed Adil Butt, Andrew D. Beggs, Adam Byfield, Anusha Jose, William Poulett, Ben Wallace, Junaid Qadir, Muhammad Bilal

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a hospital's cancer care plan as a giant, colorful flowchart hanging on a wall. It has arrows, boxes, red and blue colors, and bold text. For a human doctor, this chart is a perfect map: "If the patient has symptom A (red box), go left. If they have symptom B (bold text), go right."

But for a computer, this chart is a mystery. Computers can't "see" that a red background means "urgent" or that a thick arrow means "do this next." They only read text. This creates a gap: the doctors have the map, but the computer systems that could help automate care are blind to it.

PathWISE is a new tool designed to bridge this gap. Think of it as a team of five specialized robots working together to translate that wall-chart into a language computers can actually run.

Here is how the team works, step-by-step:

1. The "Eagle-Eye" Translator (Visual Parsing)

First, a robot with "super-vision" looks at the flowchart image. It doesn't just read the words; it notices the colors, the shapes, and the direction of the arrows. It turns the messy picture into a clean, structured digital map (a graph) that a computer can understand. It knows, for example, that a red box is different from a white one, even if they say the same thing.

2. The "Traffic Controller" (Deterministic Audit)

Next, a strict, rule-following robot takes that digital map. It doesn't guess; it uses math to trace every single possible path a patient could take from start to finish. It counts the routes, checks for dead ends, and makes sure the map makes logical sense. This part is 100% deterministic, meaning it never makes mistakes or "hallucinates" new paths.

3. The "Grammar Police" (Semantic Audit)

Now, the team checks if the instructions on the map can actually be followed by a computer. Some instructions are vague, like "treat if the patient feels very sick." A computer can't measure "very." This robot flags those vague spots. It marks them as "needs human review" rather than trying to guess what the doctor meant. It separates the clear, computer-friendly rules from the fuzzy, human-judgment rules.

4. The "Code Builder" and the "Strict Inspector" (CQL Generation & Verification)

This is the most unique part of PathWISE.

The Builder: A creative robot writes the actual computer code (called CQL) based on the map.
The Strict Inspector: Instead of another robot checking the work, PathWISE uses a real, official compiler (a tool that checks code for errors) as the inspector. If the Builder makes a mistake or invents a fake medical code, the Inspector immediately says, "Error! Fix this." The Builder keeps trying until the code passes the Inspector's test. This ensures the final code is perfect, with no made-up medical terms.

5. The "Delivery Driver" (Deployment)

Finally, the verified code is packaged into a service that can plug directly into a hospital's electronic health record system. When a doctor opens a patient's file, this system pops up a card saying, "Based on the flowchart, here is the next step," or "We need a human to decide this part because the chart was vague."

What Did They Actually Do?

The researchers tested this system on five real cancer pathways used in the UK's National Health Service (NHS): for skin, lung, breast, colorectal, and upper gastrointestinal cancers.

Success Rate: The system successfully turned all five visual charts into working computer code.
Finding Flaws: It found hundreds of "governance issues" in the original charts, such as vague language or contradictions that humans might miss.
Safety: It never invented fake medical codes. If it didn't understand a term, it flagged it for a human to check, rather than guessing.
The "Hybrid" Winner: They tried different combinations of AI models. The best result came from a "Hybrid" team: one model that was great at reading the pictures (Gemini) and another that was great at writing the code (Claude).

The Bottom Line

PathWISE doesn't replace doctors. Instead, it acts as a translator that turns static, visual hospital guidelines into dynamic, working computer tools. It keeps the "guessing" part of AI strictly limited to the early drafting phase and uses hard math and official code checkers to ensure the final result is safe, accurate, and ready to help doctors make decisions.

Technical Summary: PathWISE – Multi-Agent Cancer Pathway Triaging Ontology Learning from Clinical Flowcharts

Problem Statement

Clinical pathways, which are critical for standardizing cancer triage and treatment, are predominantly disseminated as visual flowcharts. These documents encode complex decision logic through spatial topology, arrow directionality, conditional branching, color coding, and font weight. While rich in information for human interpretation, these visual artifacts are inaccessible to computational systems. Text-only Natural Language Processing (NLP) approaches fail to recover the spatial and topological semantics required for machine execution. Consequently, a persistent gap exists between expert-authored pathway knowledge and the machine-readable representations (such as HL7 Clinical Quality Language or CQL) necessary for automated, auditable Clinical Decision Support (CDS). Existing systems either lack visual ingestion capabilities or fail to produce compiler-verified, standards-compliant outputs suitable for deployment in Electronic Health Record (EHR) workflows.

Methodology: The PathWISE Pipeline

PathWISE is a five-phase pipeline designed to transform non-computable visual flowcharts into validated, executable CQL libraries deployable as FHIR CDS Hooks services. The architecture employs a hybrid approach, confining non-deterministic Large Language Model (LLM) inference to knowledge extraction and draft generation, while relying on deterministic graph mathematics and standard compilers for verification.

The pipeline operates as follows:

Visual Parsing (Vision Agent): A vision-language model processes PNG renders of pathway PDFs to extract a typed directed graph $G=(V, E)$ . Nodes are encoded with types (e.g., decision diamond, action block), normalized coordinates, visual attributes (background color, font weight), and extracted text. Edges are explicitly identified based on arrow connectors. Output is constrained by a strict Pydantic schema to ensure structural consistency.
Deterministic Graph Audit (DFS Auditor): A non-LLM, deterministic Depth-First Search (DFS) algorithm analyzes the extracted graph. It computes structural diagnostics (orphan nodes, dead-ends, cycles) and enumerates all valid patient journeys ( $P(G)$ ) as ordered node-ID sequences. This step ensures that downstream routing logic covers exactly the journeys encoded in the source diagram.
CQL Semantic Audit (CQL Audit Agent): An LLM agent evaluates each node's computability. It attempts to translate node content into CQL 1.5 expressions and assigns a label indicating validity. Nodes failing criteria (due to ambiguity, complexity, errors, or format inconsistencies) are categorized. This audit conditions subsequent generation and provides a machine-readable gap analysis for clinical governance.
CQL Generation & Verification (Generator & Compiler-as-Critic):
- Definitions: A CQL Generator agent produces FHIR R4 CQL definitions. It maps dictionary-covered concepts to exact system-code pairs, assigns sentinel identifiers for unmapped concepts (avoiding hallucination), and inserts false placeholders with governance comments for uncomputable nodes.
- Routing: A Graph Router agent constructs routing logic based on the enumerated journeys from Phase 2, using conjunctions of node definitions to form path predicates.
- Verification: A deterministic Java CQL-to-ELM compiler acts as a "critic." If the generated CQL fails compilation, the error is injected into a repair prompt for regeneration (up to three iterations). This replaces stochastic model-based critique with binary, standards-grounded verification.
CDS Hooks Deployment: The validated CQL libraries are deployed as a FastAPI service. Upon a patient-view trigger, the service evaluates the routing logic against FHIR resources, returning a structured CDS card with recommended actions, rationale, and flags for human review if uncomputable criteria are encountered.

Key Contributions

Visual-to-Execution Pipeline: PathWISE is the first system to span the full pipeline from visual clinical pathway documents to deployed, auditable CDS services, addressing the gap where visual parsing lacks clinical deployability and guideline encoding lacks FHIR compatibility.
Compiler-as-Critic Pattern: The paper introduces a design pattern where a deterministic Java compiler replaces LLM critics for verification. This ensures that hallucinated terminology codes or malformed syntax result in compile errors rather than plausible but incorrect recommendations, providing a binary pass/fail guarantee.
Multi-Agent Hybrid Architecture: The system separates knowledge extraction (LLM-based) from clinical execution (deterministic). This confines non-deterministic behavior to a reviewable authoring stage while shifting correctness checks to deterministic components.
Governance Transparency: The system explicitly surfaces "UNCOMPUTABLE" nodes and governance gaps (e.g., content ambiguity, format inconsistencies) as review items rather than attempting to force incorrect automation, preserving a human-in-the-loop audit trail.

Results

The framework was evaluated on five UK NHS cancer pathways (colorectal, lung, skin, upper GI, and breast), covering a range of structural complexities (7 to 73 nodes; 3 to 234 enumerated journeys). Three configurations were tested: Claude Only, Gemini Only, and Hybrid (Gemini for vision, Claude for CQL).

Compilation Success: PathWISE achieved 100% syntactic compilation success across all 15 generated libraries (5 pathways × 3 configurations). No library required more than two compiler-critic iterations.
Semantic Audit Performance: Pass rates for node-level computability varied by configuration. The "Claude Only" configuration achieved the highest pass rate (48.9%), while "Gemini Only" was most conservative (6.0% pass, 55 UNCOMPUTABLE nodes). The "Hybrid" configuration balanced these, achieving 37.4% pass rate.
Governance Findings: The system identified 544 structured governance findings across all configurations. "Content Ambiguity" was the dominant category (approx. 78–84% of findings), reflecting the prevalence of subjective clinical language. "Format Inconsistency" findings confirmed that visual urgency signals (e.g., red backgrounds) were successfully captured, which text-only systems miss.
Terminology Safety: The system produced zero hallucinated terminology codes for dictionary-covered concepts. Unmatched concepts were assigned sentinel identifiers for human review.
Deployment Readiness: In tests with 25 synthetic FHIR R4 patient records, the Hybrid configuration produced structurally valid CDS cards for all invocations. While 72% of records achieved fully automated routing, the remaining 28% correctly surfaced specific human-review flags for uncomputable criteria, demonstrating execution readiness without compromising safety.
Validation: Node counts agreed exactly with independent NHS England AIQCoP analysis on four of five pathways, validating the visual parsing accuracy.

Significance and Claims

The paper claims that PathWISE demonstrates a practical design pattern for high-stakes clinical workflow automation: separating model-based knowledge extraction from deterministic verification.

The authors assert that while LLMs are effective for interpreting visual structure and drafting code, they are insufficient for the final correctness checks required in regulated clinical environments. By using a deterministic compiler as a gatekeeper, PathWISE ensures that the final output is executable and standards-compliant, even if the source material contains ambiguities. The system does not claim to resolve all clinical ambiguities automatically; rather, it positions itself as a tool for auditable translation, surfacing governance gaps and uncomputable criteria for clinical review while automating the conversion of the computable portions of the pathway into interoperable decision-support logic.

The work is modest in its scope, acknowledging limitations such as the need for manual curation of terminology resources and the inability to automatically resolve ambiguous pathway criteria. It frames PathWISE as a step toward bridging the gap between visual clinical knowledge and machine-executable systems, rather than a complete replacement for human clinical judgment.