System for explainable automated pre-approval decisions in a digital pharmacy service platform owned by a payer

Abstract

A computerized system (100) for explainable automated pre-approval decisions within a digital pharmacy performance management platform owned by a payer, wherein the system comprises: a) a policy and evidence capture level (110) configured to normalize payer benefit artifacts into typed and versioned policy objects; b) a constrained decision diagram (CDG) compiler (120) configured to compile the policy objects into a finite acyclic decision diagram with deterministic semantics; c) a real-time context orchestrator (130) configured to assemble member-specific context data using low-copy schema-versioned adapters; d) a hybrid decision engine (140) configured to deterministically traverse the CDG and invoke conditionally protected micromodels; e) a counterfactual explanation generator (150) configured to provide justifications based on

Description

AREA OF INVENTION

[0001] The present invention relates generally to health information systems and digital platforms for managing pharmacy services. In particular, the invention relates to a computer-based system and method for automated pre-authorization (PA) decisions within a digital pharmacy service platform owned by a payer, wherein the decision results are deterministic, explainable by design, and verifiable with regulatory repeatability. BACKGROUND OF THE INVENTION

[0002] Pre-authorization processes in pharmacy services management are traditionally manual, fragmented, and time-consuming. Applications for reimbursement approval often require human review across multiple unconnected systems, including entitlement databases, drug directories, usage management modules, and clinical review tools. This fragmentation leads to delays, inconsistent decisions, limited transparency, and an increased administrative burden for physicians, pharmacies, and members.

[0003] Conventional rule-based engines are limited in their flexibility and struggle to combine approval criteria, stepwise therapy rules, historical performance data, and evolving clinical guidelines under strict real-time constraints. Conversely, purely machine learning-based systems lack deterministic explainability and often fail to meet regulatory requirements for traceable, reproducible decisions.

[0004] There is a need for a deterministic, version-controlled architecture capable of compiling payer guidelines into an explainable execution plan, integrating protected machine learning results in a controlled manner, generating justifications for physicians and members, and obtaining immutable, repeatable evidence with limited latency that is suitable for point-of-care decision-making. SUMMARY OF THE INVENTION

[0005] The present invention provides a computer-based system for explainable automated pre-approval decisions within a digital pharmacy service platform owned by a payer.The system comprises a policy and data collection layer configured to normalize payer artifacts into typed, versioned policy objects; a compiler configured to generate a constrained decision graph (CDG) with deterministic semantics; a real-time context orchestrator configured to assemble contextual data for members using schema-versioned, low-copy adapters; a hybrid decision engine configured to traverse the CDG and invoke conditionally protected micromodels; a counterfactual explanation generator that creates explanations for physicians and members; and an immutable audit and replay store that stores policy versions, inputs, graph traversal paths, timings, and decisions as content-addressed artifacts.The technical effects achieved include deterministic traversal of a finite, acyclic execution plan, explainability through construction using edge-bound model calls, bit-perfect repetition of decisions tied to policy versions, limited latency suitable for point-of-care workflows, and regulatory auditability supported by governance metrics. Brief description of the attached drawings Fig. Figure 1 illustrates the overall architecture of the system. Fig. Figure 2 illustrates the workflow for creating policy versions and compiling CDG-IR. Fig. Figure 3 illustrates the end-to-end process of pre-approval. Fig. Figure 4 illustrates the pipeline for creating statements. Fig. Figure 5 illustrates the performance optimization and latency control architecture. Detailed description of the invention

[0006] System 100 comprises a payer-owned digital pharmacy benefit management (PBM) platform hosting an ingestion layer (110), a constrained decision graph (CDG) compiler (120), a real-time context orchestrator (130), a hybrid decision engine (140), a counterfactual statement generator (150), an immutable audit and replay store (160), and an appeal module (170), all coordinated via an internal bus (180) configured to manage events and timestamps. The Policy and Evidence Ingestion Layer (110) normalizes benefit artifacts, form rules, step therapy ladders, and clinical criteria into typed and versioned policy objects with integrity checks, enabling controlled rollouts and differentiated comparisons between versions.The CDG compiler (120) compiles the policy objects into a finite, acyclic graph that includes type-safe nodes and explicit predicates, rejecting cycles, undefined symbols, and non-deterministic constructs to produce an intermediate representation optimized for deterministic and fast traversal. The real-time context orchestrator (130) assembles membership data, claims data, and clinical information into a structured context vector using schema-versioned adapters, with zero-copy transfers and cache-coherent prefetch mechanisms reducing data movement and execution jitter. The hybrid decision engine (140) traverses the CDG deterministically, invoking conditionally protected micromodels. The outputs of these models are bound to predefined graph edges and are only deactivated when explicitly declared in conjunction with an explanation template.The counterfactual explanation generator (150) uses enabled edge predicates and allowed feature assignments to populate policy-linked templates that generate clinician-worthy justifications and member summaries, while simultaneously calculating minimal counterfactual changes capable of altering the decision outcome to guide resubmissions. The immutable audit and replay memory (160) persistently records policy version identifiers, input digests, traversal paths, decision outcomes, explanations, and timing metrics as content-addressed artifacts, enabling bit-for-bit replay of decisions for appeals and regulatory audits.The Appeals and Overrides module (170) allows new evidence to be fed in and reruns the decision under the exact historical policy version, reporting any differences in the outcome or reasoning along with updated explanations and related time references.

[0007] Fig. Figure 2 illustrates the workflow for versioning policies and transforming versioned policy artifacts into a compiled Constrained Decision Graph Intermediate Representation (CDG-IR). At the top of the diagram, Block 200 (Policy v1), Block 202 (Policy v2), and Block 204 (Policy v3) represent sequentially versioned policy objects, each identified by a unique content hash (h1, h2, h3). The parent links explicitly maintain the lineage between successive versions to enable deterministic reconstruction, controlled rollback, and diff-based comparison of policy evolution.The versioned policy objects are made available to Block 206 (Schema Registry), which performs rigorous schema validation, type checking, and structural integrity verification to ensure that only syntactically and semantically valid artifacts are processed further. The validated artifacts then proceed to Block 208 (Signature Verification), where cryptographic signatures are authenticated to confirm source authenticity and detect tampering, thereby supporting regulatory governance and audit requirements.After successful verification, the validated and provenance-linked policy content is processed in Block 210 (CDG-IR Compiled), where a compiler performs static analysis, resolves symbol references, enforces an acyclic graph structure, and rejects undefined or non-deterministic constructs. This generates a Constrained Decision Graph Intermediate Representation, which serves as a deterministic execution plan for automated pre-approval decisions. This structured pipeline ensures reproducibility, transparency, and end-to-end traceability across all policy versions managed in the system.

[0008] Fig. Figure 3 illustrates the end-to-end processing workflow executed by the automated system to decide on pre-authorization (PA), showing how a request progresses through context creation, deterministic graph processing, protected machine learning invocation, outcome generation, explanation creation, and audit persistence. At block 300 (PA request received), the system receives a PA request from a prescribing system, electronic health record (EHR), pharmacy, or care management interface, thereby initiating the decision workflow while adhering to latency constraints.The request proceeds to block 302 (Get Context), where the real-time context orchestrator assembles the necessary member data, including eligibility information, service history, usage management restrictions, and relevant clinical attributes, using schema-versioned adapters to ensure consistent, validated, and low-copy context creation. In block 304 (Traverse CDG-IR), the system deterministically executes the constrained decision graph compiled from versioned policy objects by sequentially evaluating node predicates and following explicitly declared edges until the specified protected evaluation points are reached.Where machine-assisted assessment is permitted, the process proceeds to Block 306 (Guarded ML Invocation), in which politically declared micromodels are invoked in a controlled manner. Their outputs influence the execution only when explicitly permitted by the CDG and bound to appropriate explanation templates, thus preventing uncontrolled model behavior. If missing inputs or unmet prerequisites are detected, execution is redirected to Block 316 (Deterministic Fallback), ensuring a stable, purely rule-based decision path and maintaining reproducibility. Both execution paths converge at Block 308 (Decision Outcome), where the system finalizes the findings regarding reimbursement, stepwise therapy requirements, fulfillment of clinical criteria, or rejection logic, delivering a final result.Subsequently, Block 310 (Explanation + Counterfactuals) generates transparent, human-readable reasoning, including clinician-level argumentation and minimal disruptive counterfactuals that describe changes capable of reversing the outcome. In parallel, Block 314 (Notify Pharmacy / EHR) transmits the decision and explanation to the prescribing and dispensing systems for immediate clinical implementation. Finally, Block 312 (Persist to Audit & Replay) stores policy version identifiers, input digests, traversal paths, timing metrics, decision outcomes, and explanations within the immutable audit and replay memory, enabling bit-for-bit reproducibility for regulatory audits and appeals.

[0009] Fig. Figure 4 illustrates the explanatory pipeline, showing how rule-based predicates, model-based feature assignments, and curated language templates converge to generate clinically accurate and member-understandable explanatory text. Block 400 (Edge Predicates) represents the logical predicates activated during traversal of the Constrained Decision Graph Intermediate Representation (CDG-IR). It captures which policy conditions were evaluated as true or false, including clinical criteria checks, dosage restrictions, stepwise treatment requirements, and historical utilization thresholds, thus providing the structured and rule-based foundation for narrative justification. Block 402 (Feature Mappings) captures quantitative and qualitative mappings generated when protected micromodels are invoked.Such mappings describe the relative importance of specific input features, including lab values, recency of claims, or treatment duration, in influencing model outputs, strictly within the limits permitted by the applicable guideline to ensure transparent and reproducible integration of machine learning signals. Block 404 (Template Library) stores guideline-compliant explanation templates that are mapped to specific graph edges, predicate classes, or model output scenarios. Each template is structured to generate both clinician-oriented and member-accessible language while ensuring consistency so that identical conditions produce identical explanations.These three inputs converge at Block 406 (Explanation Synthesizer), which deterministically combines activated predicates, permissible attributions, and corresponding template structures, resolves placeholders, formats supporting evidence, and ensures that only politically explained and audited elements are included in the final narrative. The synthesized output is provided via Block 408 (Outputs: Physician and Member Text), generating two synchronized explanation variants: physician-quality text, which retains clinical specificity and regulatory-level detail, and member-quality text, expressed in simplified, non-technical language suitable for patient communication. This ensures explainability by construction and transparency for regulators for each automated preauthorization decision.

[0010] Fig. Figure 5 illustrates the performance optimization architecture that ensures the automated pre-approval system maintains predictable, regulatory-grade response times even under high transaction volumes. Three fundamental, low-level optimization mechanisms feed into a unified latency budgeting framework, which is continuously monitored using percentage telemetry. Block 500 (Cache-Coherent Prefetch) implements proactive memory access optimizations aligned with CPU cache coherence protocols by preloading relevant member context fragments and CDG IR segments into the cache hierarchy before execution. This minimizes penalties for cache errors and avoids unpredictable runtime delays during real-time decision-making.Block 502 (Zero-Copy Transfer) eliminates unnecessary data serialization and duplication by enabling direct in-memory transfer of structured context objects between system components. This ensures that critical execution paths, including context assembly and decision engine traversal, operate with reduced CPU overhead and minimal latency jitter. Block 504 (Concurrency Controls) enables deterministic coordination of parallel workloads through mechanisms such as lock-free queues, controlled thread scheduling, and limited work stealing, thereby avoiding resource conflicts and ensuring that throughput increases do not cause latency spikes or compromise strict service-level guarantees.The outputs of blocks 500, 502, and 504 converge in block 506 (latency budgeting), where micro-budgets are allocated to individual stages of the pre-approval workflow to ensure that even the worst execution paths remain within predefined clinical latency thresholds, and where adaptive throttling and pipeline balancing are triggered when resource constraints are detected. Finally, block 508 (p50 / p95 telemetry) captures real-time latency statistics at the median (p50) and highest percentile (p95) levels, providing continuous transparency into system performance and forming a feedback loop that identifies deviations, regressions, or emerging bottlenecks before clinical impacts occur. Together, these elements form the core of the system. Fig.The components shown provide a deterministic, reproducible and high-performance execution environment capable of meeting point-of-care decision requirements under diverse and demanding operating conditions.

Claims

[1] A computerized system (100) for explainable automated pre-approval decisions within a digital pharmacy performance management platform owned by a payer, the system comprising: a) a policy and evidence capture level (110) configured to normalize payer benefit artifacts into typed and versioned policy objects; b) a constrained decision diagram (CDG) compiler (120) configured to compile the policy objects into a finite acyclic decision diagram with deterministic semantics; c) a real-time context orchestrator (130) configured to assemble member-specific context data using low-copy schema-versioned adapters; d) a hybrid decision engine (140) configured to deterministically traverse the CDG and invoke conditionally protected micromodels; e) a counterfactual explanation generator (150) configured to provide justifications based on [2] System according to claim 1, wherein the policy and evidence intake level (110) assigns cryptographic content identifiers to each policy object and maintains explicit parent-daughter relationships to enable rollback and differential comparison across policy versions. [3] System according to claim 1, wherein the CDG compiler (120) performs cycle detection, symbol resolution, predicate normalization, rejection of undefined or non-deterministic constructs and enforcement of side effect isolation to generate a deterministic execution plan. [4] System according to claim 1, wherein the real-time context orchestrator (130) uses zero-copy memory transfer and cache-coherent prefetch mechanisms to minimize data movement and execution jitter during decision processing. [5] System according to claim 1, wherein the hybrid decision engine (140) calls protected micromodels only on explicitly declared graph nodes and wherein the outputs of the micromodels influence graph navigation only when they are bound to predefined graph edges and associated explanation templates. [6] System according to claim 1, wherein the counterfactual explanation generator (150) combines activated edge predicates and permissible feature mappings with policy-bound templates to produce synchronized explanations of clinical quality and summaries of member quality. [7] System according to claim 6, wherein the counterfactual explanation generator further computes minimal perturbation counterfactual conditions capable of altering a decision outcome to guide resubmission or appeals. [8] System according to claim 1, wherein the immutable audit and replay memory (160) enables bit-perfect replay of previous authorization decisions by storing policy version identifiers, input digests, paths through the graph, decision outputs, explanations and timing metrics as content-addressed data records. [9] System according to claim 1, further comprising an appeal and override module (170) configured to insert new evidence and to re-execute a previous approval decision under an identical historical policy version, as well as to generate differentiated explanations that reflect changes in the outcome or reasoning.

Images