Integration

AI Integration with Eyefinity Self-Service Kiosks

Add AI-powered navigation, real-time insurance verification, and personalized optical recommendations to Eyefinity's self-service kiosk ecosystem using its SDK and backend APIs.

Get in touch Learn more

Architect reviewing LLM integration architecture on laptop, system diagrams visible, modern technical office setup.

ARCHITECTURE & ROLLOUT

Where AI Fits in the Eyefinity Kiosk Workflow

Integrating AI into Eyefinity's self-service kiosks transforms passive check-in stations into intelligent assistants that handle verification, navigation, and personalized guidance.

AI integration connects directly to the Eyefinity Kiosk Software SDK and backend services, focusing on three core surfaces: the check-in/registration flow, the insurance verification module, and the post-check-in optical product discovery screen. At check-in, a voice and gesture navigation agent can guide patients through the process, using the kiosk's camera and microphone for accessible interaction. During insurance verification, an AI agent can call payer APIs in real-time via the kiosk's backend, scrubbing eligibility data and presenting a plain-language summary of benefits and patient responsibility before they even see the front desk.

The most impactful integration is often the upsell prompt for optical products. By connecting to the Eyefinity product catalog API and the patient's historical purchase data, an AI can generate personalized, context-aware suggestions (e.g., 'Based on your last frame purchase and today's prescription update, we have new blue-light lens options in stock'). This isn't a generic pop-up; it's a grounded recommendation that uses the kiosk as a low-pressure sales assistant, with suggestions queued for the optician's review in the main Eyefinity PM system.

Rollout is typically phased, starting with a single kiosk in a low-risk area (e.g., a waiting room) to monitor performance and patient interaction. Governance is critical: all AI interactions must be logged to the kiosk's audit trail, and any data processed (like insurance cards or voice snippets) must remain ephemeral or be immediately encrypted and synced to the secure practice management backend. The final phase involves scaling the validated AI workflows across the kiosk network, managed centrally through Eyefinity's kiosk management console.

AI FOR SELF-SERVICE KIOSKS

Kiosk Integration Surfaces and Eyefinity APIs

Enhancing Kiosk Accessibility with AI

Integrating AI into Eyefinity's kiosk SDK allows for intuitive, hands-free patient interaction. This layer sits atop the standard touch interface, using the device's camera and microphone for:

Gesture Recognition: Enabling patients to navigate menus (e.g., swipe left/right, select) with simple hand motions, reducing touchscreen fatigue and improving accessibility.
Voice Commands: Processing natural language queries (e.g., "I'm here for my 10 AM appointment" or "I need to update my insurance") to trigger specific kiosk workflows via the Eyefinity API.
Real-time Feedback: Providing visual or audio cues to confirm action recognition, ensuring a smooth user experience.

Implementation involves deploying a lightweight AI model on the kiosk or using a secure cloud endpoint, with results mapped to standard kiosk SDK functions like navigateToScreen() or populateFormField().

EYEFINITY SELF-SERVICE KIOSK INTEGRATION

High-Value AI Use Cases for Optometry Kiosks

Integrating AI with Eyefinity's self-service kiosk ecosystem transforms passive check-in stations into intelligent workflow hubs, reducing front-desk burden and improving patient experience through voice, vision, and real-time data.

Voice & Gesture Navigation

Enable hands-free, accessible kiosk interaction using natural language commands and simple gestures. Patients can check in, request forms, or ask for assistance without touching the screen, powered by local speech-to-text and the Eyefinity Kiosk SDK for command execution.

Touchless

Accessibility boost

Real-Time Insurance Verification

At check-in, the kiosk uses a patient's insurance card scan (OCR) or entered details to perform a real-time eligibility check via payer APIs. It flags coverage issues, estimates patient responsibility for co-pays, and updates the Eyefinity patient record before the visit starts.

Pre-visit

Issue resolution

Intelligent Form Pre-Fill & Validation

Leverage the patient's EHR history to auto-populate intake forms on the kiosk. Use AI to validate entries in real-time (e.g., date formats, required fields) and flag inconsistencies with past data, reducing errors and speeding up the registration process.

Minutes -> Seconds

Form completion

Personalized Optical Product Upsells

Analyze the patient's appointment type, purchase history, and current frame/lens inventory to display contextual promotions on the kiosk screen post-check-in. For example, prompt patients due for new lenses or highlight frames that match their previous style preferences.

Relevant prompts

Increased attach rate

Automated Document Capture & Classification

Guide patients to scan insurance cards, IDs, or referral forms using the kiosk's camera. AI extracts and validates key fields, classifies the document type, and attaches it to the correct patient record in Eyefinity, eliminating manual upload and filing.

Batch -> Real-time

Document processing

Queue Management & Patient Triage

Integrate kiosk check-in data with the practice's waitlist and schedule. Use simple rules to prioritize or triage patients based on appointment urgency, provider readiness, or completed intake status, sending smart alerts to staff via the Eyefinity backend.

Reduced wait times

Patient flow

EYEFINITY SELF-SERVICE KIOSK INTEGRATION PATTERNS

Example AI-Enhanced Kiosk Workflows

These workflows illustrate how to embed AI agents and automation into Eyefinity's self-service kiosk ecosystem using its kiosk software SDK and backend APIs. Each pattern connects real-time patient interaction with secure, governed AI tool calling to reduce front-desk burden and improve patient experience.

Trigger: Patient approaches the kiosk and initiates a session.

Workflow:

Context Pull: The kiosk software uses the Eyefinity API to fetch the patient's upcoming appointment details, pre-filled demographic data, and any outstanding forms.
AI Agent Action: A multimodal AI agent (processing camera feed and microphone input) enables hands-free interaction:
- Gesture Navigation: The agent interprets simple hand gestures (e.g., swipe to navigate, tap to select) for patients who prefer not to touch the screen.
- Voice Commands: Patients can say, "Check me in for my 2 PM appointment," or "Update my insurance." The agent uses speech-to-text and natural language understanding to map the intent to kiosk UI actions.
- Form Assistance: For any required forms, the agent uses a Retrieval-Augmented Generation (RAG) system over the practice's policy documents to answer patient questions in real-time (e.g., "Why do you need this consent form?").
System Update: Upon successful check-in and form submission, the agent calls the POST /api/v1/kiosk/checkin Eyefinity endpoint, updating the patient's status in the schedule and attaching the completed digital forms to their record.
Human Review Point: If the AI agent detects a discrepancy in insurance information or an incomplete form that requires staff interpretation, it flags the check-in for front-desk review and sends a silent alert to the staff dashboard.

Technical Note: This requires integrating a vision/voice service (like Azure Cognitive Services) with the kiosk's local SDK, with all patient data processed securely and never stored on the kiosk itself.

EYEFINITY KIOSK INTEGRATION

Implementation Architecture: SDKs, APIs, and Data Flow

A production-ready architecture for adding AI to Eyefinity's self-service kiosks, connecting its kiosk software SDK to real-time insurance, optical, and patient data.

The integration connects to two primary surfaces: the Eyefinity Kiosk Software SDK for the front-end user experience and the Eyefinity Practice Management API for backend data operations. The AI layer acts as a middleware service, subscribing to kiosk events (e.g., check-in_started, insurance_card_scanned, product_browsed) via the SDK's webhook system. For each event, the service calls the Practice Management API to fetch real-time context—such as patient history, active insurance plans, or optical inventory—before executing an AI-driven workflow. Common data objects include Patient, InsuranceEligibility, Appointment, and OpticalProduct records.

Implementation flows follow specific kiosk interaction points:

Gesture/Voice Navigation: Audio and video streams from the kiosk are processed by a secure, on-premises edge service for gesture recognition and speech-to-text, converting natural language commands into structured API calls (e.g., "check my benefits" triggers a real-time eligibility call).
Real-Time Insurance Verification: When a patient scans an insurance card, the AI service uses OCR extraction, calls the payer's eligibility API via Eyefinity's clearinghouse connection, and returns a plain-language summary of benefits, co-pays, and coverage limits to the kiosk screen in under 10 seconds.
Optical Upsell Prompts: By analyzing the patient's appointment reason, prescription history, and current frame inventory (via the OpticalProduct API), the system generates context-aware prompts on the kiosk, such as recommending photochromic lenses for a patient with a new sunglasses prescription.

Rollout and governance require a phased approach, starting with a single-kiosk pilot. Key considerations include:

Data Privacy: All PHI stays within the Eyefinity ecosystem; AI prompts are de-identified where possible, and all API calls use Eyefinity's existing OAuth 2.0 roles and scopes.
Offline Resilience: The kiosk SDK supports offline queues, so AI-enhanced features gracefully degrade to standard workflows if the middleware service is unavailable.
Audit Trails: Every AI-generated suggestion or action is logged back to the Eyefinity audit log via a dedicated AI_Interaction object, linking the kiosk session ID, patient ID, and the specific data used for the recommendation for full traceability.

EYEFINITY KIOSK INTEGRATION PATTERNS

Code and Payload Examples

Capturing Kiosk Events for AI Processing

Eyefinity's kiosk software SDK emits events for user interactions, which can be captured and sent to an AI service for real-time response. This pattern uses a local webhook listener on the kiosk device to process events before forwarding them to your secure AI endpoint.

python
# Example: Kiosk event handler in Python
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)
AI_ENDPOINT = "https://your-ai-service.inferencesystems.com/process"

@app.route('/kiosk/webhook', methods=['POST'])
def handle_kiosk_event():
    event_data = request.json
    
    # Common Eyefinity kiosk event types
    event_type = event_data.get('eventType')
    patient_id = event_data.get('patientId')
    kiosk_id = event_data.get('kioskId')
    
    # Enrich event with context from local EHR cache
    enriched_payload = {
        "event": event_type,
        "patient_context": get_patient_summary(patient_id),  # Local cache lookup
        "kiosk_session": event_data,
        "timestamp": event_data.get('timestamp')
    }
    
    # Send to AI service for intent classification & response generation
    ai_response = requests.post(AI_ENDPOINT, 
                                json=enriched_payload, 
                                headers={"Authorization": "Bearer YOUR_API_KEY"})
    
    # Return AI-suggested action to kiosk UI
    return jsonify({"ui_action": ai_response.json()})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

This handler sits between the kiosk software and your AI service, enabling low-latency responses while maintaining security through local data caching.

AI-ENHANCED KIOSK WORKFLOWS

Realistic Time Savings and Operational Impact

This table illustrates the tangible operational improvements when integrating AI into Eyefinity's self-service kiosk ecosystem, focusing on common patient and staff workflows.

Workflow / Metric	Before AI	After AI	Implementation Notes
Patient Check-in & Registration	Manual data entry, form scanning, staff-assisted insurance card handling	Automated OCR for insurance cards, smart form pre-fill, gesture/voice navigation	Uses kiosk SDK for camera access and real-time API calls to patient records; reduces front-desk burden by ~70%
Real-time Insurance Eligibility Verification	Staff makes phone calls or uses separate portal; takes 5-10 minutes per patient	Automated API call triggered at kiosk; results in 30-60 seconds	Integrates with Eyefinity's insurance module APIs; status displayed on kiosk screen; flags issues for staff
Optical Product Upsell Prompting	Generic flyers or staff memory-based suggestions	Personalized recommendations based on patient history and current Rx	Leverages Eyefinity's optical inventory and patient history APIs; displays targeted prompts during checkout flow
Visit Reason Triage & Routing	Patient selects from static list or tells front desk	Conversational NLP to capture symptoms, routes to correct department/forms	Uses local speech-to-text and intent classification; updates Eyefinity scheduling module with visit type
Co-pay & Balance Estimation	Staff manually checks benefits and calculates	Automated estimation using verified insurance and account balance	Calls Eyefinity's financial APIs in real-time; provides clear payment options on kiosk
Form Completion & Signature Capture	Paper forms, manual review for completeness	Interactive digital forms with real-time validation, e-signature capture	Uses kiosk's touch interface and document storage APIs; forms auto-attach to patient chart
Kiosk Health & Maintenance	Reactive IT tickets for frozen screens or hardware issues	Predictive alerts for low supplies, automated error log analysis	AI monitors kiosk software logs and device metrics via management APIs; enables proactive support

AI INTEGRATION WITH EYEFINITY SELF-SERVICE KIOSKS

Governance, Security, and Phased Rollout

A practical blueprint for deploying, securing, and governing AI features on Eyefinity's kiosk platform.

Deploying AI on Eyefinity's self-service kiosks requires a security-first architecture that treats the kiosk as a zero-trust edge device. Implementation typically involves a local agent on the kiosk OS (Windows/Linux) that handles secure sessions, biometric opt-in flows, and real-time data validation before any PHI is transmitted. This agent calls a secure, dedicated API gateway—separate from core practice management APIs—that brokers requests to AI services for tasks like insurance card OCR, voice intent recognition, or upsell recommendation. All PHI is encrypted in transit using TLS 1.3 and never persisted in AI service logs; prompts are dynamically constructed from session-specific tokens to prevent data leakage.

A phased rollout is critical for managing change in a clinical setting. We recommend a three-stage approach:

Phase 1: Pilot a single high-value workflow, such as AI-assisted insurance verification, at one location. This limits scope, allows for intensive user observation, and validates the integration with Eyefinity's PatientCheckIn API and backend eligibility services.
Phase 2: Expand to multi-modal interaction, adding voice navigation for accessibility and gesture control for hygiene. This stage integrates with the Eyefinity Kiosk Software SDK to capture input events and requires rigorous testing on the specific kiosk hardware models in use.
Phase 3: Scale AI-driven personalization, enabling optical product upsell prompts based on the patient's history (via Eyefinity's OpticalHistory API) and real-time inventory. This phase introduces a human-in-the-loop approval step where staff can review and modify AI suggestions before they are presented to the patient, ensuring clinical and business appropriateness.

Governance is enforced through role-based access controls (RBAC) in the kiosk admin console, detailed audit trails of all AI interactions linked to the patient record, and a regular review cycle of AI-generated content and prompts. Performance is monitored not just for uptime, but for operational impact metrics like check-in time reduction, insurance capture accuracy, and patient satisfaction scores from integrated surveys. This structured approach ensures the AI integration enhances efficiency without disrupting the trusted patient-provider relationship or the security of the Eyefinity ecosystem.

Enabling Efficiency, Speed & Accuracy

Intelligent Analysis, Decision & Execution

We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.

Talk to Us

Search across company data

Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.

Useful when people spend too long searching or get different answers from different systems.

Enterprise searchRAGPermissions

Automate internal workflows

Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.

Useful when repetitive work moves across multiple tools and teams.

AI agentsWorkflow automationGovernance

Add AI to products and internal tools

Build assistants, guided actions, or decision support into the software your team or customers already use.

Useful when AI needs to be part of the product, not a separate tool.

AI integrationDecision supportModel routing

AI INTEGRATION WITH EYEFINITY SELF-SERVICE KIOSKS

Frequently Asked Questions

Common questions about implementing AI-driven features for Eyefinity's self-service kiosk ecosystem, covering technical architecture, security, and practical rollout.

The integration typically follows a hybrid architecture where lightweight AI models run on the kiosk for real-time responsiveness, while complex processing is handled by secure cloud APIs.

Local Kiosk Layer: The Eyefinity kiosk software SDK is extended with modules for:
- Gesture/Voice Recognition: Using on-device models (e.g., TensorFlow Lite) for basic navigation commands to reduce latency and enable offline functionality.
- Camera/OCR Processing: Capturing insurance cards or IDs locally before securely transmitting extracted data.
Cloud API Layer: The kiosk makes authenticated API calls to your backend services, which orchestrate calls to:
- LLM APIs (OpenAI, Anthropic, Azure OpenAI) for generating personalized upsell prompts or answering complex patient questions.
- Insurance Verification Services to perform real-time eligibility checks using the data captured at the kiosk.
Data Sync: Results (e.g., insurance status, generated recommendations) are sent back to the kiosk for display and simultaneously posted to the relevant Eyefinity Practice Management records via its REST APIs to ensure data consistency.

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.

Limited slotsGet a Free AI Consultation

How We Work

Custom AI workflows for your Business

One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.