Agentic Workflow for Ophthalmology Pre- and Post-Op Patient Management

This primary agent initiates the workflow upon a booked surgery. It ingests patient data from the EHR/PM system, triggers automated insurance verification via payer APIs, and checks for missing pre-op requirements (e.g., recent physical, lab work). It creates a patient-specific timeline and assigns tasks to downstream agents, handling exceptions like coverage gaps by routing to financial counselors.

A specialized agent manages the pre-surgical pathway. It schedules required tests (e.g., biometry, corneal topography) by interfacing with clinic scheduling (PMSI) or external lab APIs. It delivers personalized video and written education on medications (e.g., antibiotic drops), fasting, and transportation, confirming understanding via simple quizzes. Missed tests or unclear responses trigger SMS/portal alerts to care coordinators.

This agent executes a time-based recovery protocol post-surgery. Starting 24 hours post-op, it conducts automated check-ins via patient-preferred channel (SMS, voice), asking standardized questions about pain, vision clarity, and medication adherence. Responses are scored; normal results log to the EHR, while concerning answers (e.g., severe pain, worsening vision) immediately escalate via priority alert to the on-call nurse or surgeon's mobile device.

Not a user-facing agent, but a critical middleware component. It manages bidirectional sync between the agentic workflow and core healthcare systems: pushing structured data (e.g., education completion, check-in responses) to the EHR (Epic, Cerner) and pulling schedule updates from the PMS. It also maintains a immutable audit trail of all agent actions, patient interactions, and escalation events for compliance (HIPAA) and clinical review.

This logic layer manages all deviations from the standard pathway. It classifies exceptions (financial, clinical, scheduling) and routes them with context to the appropriate human queue in tools like ServiceNow or the PMS. For example, a patient reporting severe pain is routed to the Urgent Clinical Triage queue with full interaction history, while a transportation issue is routed to Patient Resources. It ensures no edge case is dropped.

This component monitors the entire workflow's performance. It tracks KPIs like cancellation reasons, time-to-test-completion, and escalation rates, providing dashboards for practice administrators. Using this data, it can suggest optimizations—for example, adjusting the timing of education based on patient engagement patterns or identifying systemic bottlenecks in the testing supply chain.

The workflow's core is a bidirectional API connection to the practice's EHR (e.g., Epic, Cerner, NextGen). This enables agents to:

• Pull patient demographics, surgical plans (laterality, IOL type), and medication lists for personalization.
• Push completed pre-op questionnaires, consent forms, and post-op check-in data directly into the patient chart.
• Listen for HL7 ADT messages to trigger workflow phases (e.g., 'Scheduled' → start pre-op sequence). Without this real-time sync, agents operate on stale data, creating clinical risk and manual rework.

Agents must interact with the PMS (e.g., Athenahealth, Nextech, ModMed) to manage the surgical timeline. Key integrations include:

• Reading provider block schedules and booked procedure slots to time communications.
• Writing follow-up appointments (e.g., 1-day, 1-week post-op) based on surgical outcome and clinic protocol.
• Updating patient statuses (e.g., 'Pre-Op Clearance Complete') to inform front-desk staff. The orchestration layer uses these hooks to prevent communication blasts during cancellations and auto-fill newly opened slots from the waitlist.

Secure, multimodal communication is non-negotiable. The workflow depends on:

• Patient Portal API (e.g., MyChart, FollowMyHealth) for sending secure forms, educational videos, and collecting structured data.
• Twilio or Vonage APIs for automated, interactive SMS/voice calls for reminders and simple check-ins (e.g., "Press 1 if your pain is >5").
• Email Service Provider (ESP) API for longer-form instructions and satisfaction surveys. Agents route interactions by patient preference and message urgency, with all outbound logs written back to the EHR for a complete audit trail.

Pre-op coordination requires interfacing with fragmented diagnostic systems. The workflow agent must:

• Ingest HL7 ORU messages from biometry devices (e.g., Zeiss IOLMaster, Alcon Lenstar) to confirm IOL calculations are complete.
• Query external lab APIs (e.g., Quest, LabCorp) to verify pre-op bloodwork results are in and normal.
• Interface with ASC/Hospital ADT systems to confirm the patient is on the surgery schedule. This creates a unified 'clearance dashboard' for surgeons, replacing manual phone calls and chart hunting to reduce day-of-surgery cancellations.

Safety requires hard-coded rules and dynamic routing. The workflow depends on:

• Rules Engine: Embedded logic (e.g., IF post-op pain score >7 AND vision decline = 'Yes' THEN escalate) to triage patient responses.
• Nurse Triage System/Staff Alerting API: Integration with platforms like Spok or direct SMS/Teams alerts to route urgent issues to the on-call team.
• Audit Logging Database: Every agent action, data access, and escalation must be written to an immutable log for compliance (HIPAA) and performance review. This control layer is what allows safe automation at scale.

Few clinics have all systems on modern APIs. A practical build requires:

• Orchestration Platform: A tool like LangGraph or Temporal to manage stateful, long-running patient journeys across weeks.
• Integration Platform as a Service (iPaaS): Such as Zapier or Make for lightweight, non-clinical connections (e.g., sending marketing nurture emails via Mailchimp post-recovery).
• Legacy System Connectors: For PMSs without open APIs, browser automation agents (Playwright) may be needed to simulate UI actions for data entry, adding complexity but enabling automation where APIs are absent. The architecture must plan for phased rollout, starting with API-ready systems.