What Is Arclight?

Building local AI/ML solutions for public health

The Problem

Practical implementation of machine learning and artificial intelligence is significantly lacking on the front lines of public health. While many proposed solutions show promise in controlled academic settings, actual implementation is challenged by data fragmentation, data bias, privacy concerns, domain oversights, or a reliance on computing infrastructure unavailable to under-resourced local health departments.

Whether the health emergency is a new outbreak of an existing pathogen, a novel virus, a drug-resistant fungus, an environmental toxin, or a bioterror attack, the first contact between pathogen and the public health system will be the outbreak investigation conducted by local health departments. The impact generated by aiding this process with ML/AI tools is considerable, and currently unaddressed.

Our Solution

Arclight is an open-source, domain-specific reasoning model designed to empower epidemiologists and public health professionals with real-time decision support during outbreak investigations. The model is designed to run locally, on device via a cross-platform app, and incorporate reasoning and RAG capabilities built around the ONNX format and released across three key stages (open-source ONNX model, containerized Streamlit POC, and cross-platform Flutter app).

Design Goals and Exclusions

Arclight will assist field epidemiologists and public health professionals when investigating potential infectious disease outbreaks. Arclight will exclusively process information on-device to protect PHI, eliminate infrastructure costs, and add direct oversight by the end-user.

Specific Arclight functions will evolve over time, but will generally will be designed to support epidemiologists during the following phases of an outbreak investigation:

Integrating existing public health surveillance data
Processing case reports and investigative notes
Refining the case definition based on collected information and alternative diagnoses
Organizing case reports based on population, location, and time
Developing etiological hypotheses based on observed notes and reference data.

Arclight deployment will include only Android, Linux, and Windows devices. Model performance will be constrained by the demands of on-device processing, to include available modules in the required tech stack. Arclight will not replace established decision support tools used for policy development, outbreak forecasting, or other use cases requiring large data sets and server-grade processing power; rather, it fills a gap at the local level.

Technical Methodology and Implementation

Arclight’s architecture is built on a modular, cross-platform framework that prioritizes on-device execution to ensure absolute privacy for Protected Health Information (PHI) and independence from cloud infrastructure. The methodology for integrating machine learning capabilities into the application is divided into model development and front-end integration.

Modular Process Flowchart

Below is a visual representation of the lifecycle of an Arclight ML module, from development to on-device output:

---
config:
  theme: neo
  look: neo
  layout: dagre
---
flowchart TD
    subgraph Baseline Model Development
        Dev("Pre-Training")
        Fine("Early Fine-Tuning")
        Open("Open-Source Model Comparison")
        Eval("Model Evaluation")
        Sel("Model Selection")
        Dom("Domain-Specific Finetuning")
        On("Final Evaluation")
    end
    subgraph Reasoning and RAG Capabilities
        Data("Reference Data Curation and Cleaning")
        Inp("Reference Library Expansion Functions")
        Proc("Embedding and Vectorization")
        Ret("Query, Search, Retrieval Functions")
        Reas("Base Domain Reasoning and Alignment")
        Cont("Context-Grounded Fine-Tuning")
    end
    GPL("Deploy under GPL 3.0 license")
    subgraph Streamlit POC
        UI("UI Mockup")
        Opt("Model Quantization and Optimization")
        Int("Model Integration")
        Dock("Dockerize")
    end
    subgraph Flutter Module
        Pre("Data Import & Preprocessing in Dart")
        Loc("Local Model Execution")
        Out("Output Formatting & Display")
    end
    Dev --> Fine
    Fine --> Eval
    Open --> Eval
    Eval --> Sel
    Sel --> Dom
    Dom --> On
    On --> Data
    Data --> Inp
    Inp --> Proc
    Proc --> Ret
    Ret --> Reas
    Reas --> Cont
    Cont --> GPL
    Cont --> UI
    UI --> Opt
    Opt --> Int
    Int --> Dock
    Dock --> GPL
    Dock --> Pre
    Pre --> Loc
    Loc --> Out
    Out --> GPL

Model Fine-Tuning and ONNX Export

The core domain-specific language model is adapted and optimized for local, low-latency execution with reasoning and RAG support.

Domain Focus: Fine-tune and adapt an open-source language model specialized for public health and epidemiological reasoning.
RAG Integration: Embed an on-device Retrieval-Augmented Generation pipeline to ground reasoning against validated epidemiological literature and local case data.
Export & Quantization: Export the model and retrieval pipelines into the open ONNX format, applying quantization to optimize memory usage and performance across desktop and mobile devices.

Containerized Streamlit POC

Prior to the full mobile and desktop rollout, a containerized prototype is constructed using Streamlit to validate workflows and user experience:

Rapid Prototyping: Build a web-based proof-of-concept to test local language model querying, RAG integration, and visual outputs with stakeholders.
Containerization: Package the Streamlit interface and quantized ONNX runtime inside a Docker container to ensure reproducible testing across different evaluation environments.
Workflow Validation: Gather user feedback on interactive reporting features—including dynamic maps, tables, and epidemic curves—to refine UI/UX specifications before native app development.

Flutter and Dart Integration

The core application is built using the Flutter framework, enabling a single codebase to deploy across Android, Windows, and Linux. For the local language model and RAG pipeline, a standardized process is followed within the Dart codebase:

Front-End Design: Develop the responsive front-end user interface components in Flutter to capture inputs (text, audio, images).
Data Import & Preprocessing: Write robust data ingestion and preprocessing handlers in Dart to prepare inputs for model compatibility.
Model Execution: Invoke the quantized ONNX model locally using cross-platform ONNX Runtime bindings in Dart to run inferences and RAG retrieval strictly on-device.
Output Formatting: Capture the inference results, process and format them (generating charts, tables, maps, or textual decision support), and display them within the UI.

This workflow ensures on-device reasoning and privacy preservation across all target platforms.