> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wayak.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Patient intake automation
> Automate new patient registration by validating forms, verifying insurance, and routing to the correct department
Patient intake is the front door of every healthcare organization, and it sets the tone for the entire care experience. Incomplete forms, unverified insurance, and manual data entry create bottlenecks that delay care and frustrate patients. Front-desk staff spend hours each day chasing missing information and re-keying data between systems, which increases error rates and slows throughput.
Wayak automates the intake workflow end to end. A playbook triggers when a new patient registration lands in your EHR system, validates the submitted information against required fields, checks insurance eligibility, and routes the patient to the appropriate department. An agent handles follow-up questions from staff — pulling patient history, verifying coverage details, and flagging incomplete registrations.
***
## What you need
* **EHR system** — patient demographics, medical history, allergies, medications, and emergency contacts
* **Scheduling API** — provider availability, department schedules, and appointment slots
* **Insurance eligibility API** — real-time coverage verification, plan details, copay information, and authorization requirements
* **Registration forms and checklists** — upload required intake forms, consent templates, and data validation rules for each department
* **Insurance and billing policies** — upload payer-specific requirements, pre-authorization rules, and documentation standards
**Semantic layer:** Define these in your ontology before setting up the agent.
| Component | Name | Definition |
| --------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------- |
| Object | Patient | Maps to the `patients` table in the EHR system. Represents an individual receiving care |
| Object | Registration | Maps to `registrations` in the intake system. Represents a single intake submission with status and timestamps |
| Metric | Average Intake Time | Mean elapsed minutes from registration submission to department routing, measured across all completed intakes |
| Metric | Incomplete Registration Rate | Percentage of registrations that require follow-up for missing information before routing |
| Dimension | Department | Categorizes registrations by destination department (primary care, specialty, urgent care, imaging) |
| Dimension | Insurance Type | Groups patients by coverage type (commercial, Medicare, Medicaid, self-pay) |
See [building a semantic layer](/quickstart/build-semantic-layer) for a step-by-step guide.
***
## Agent setup
Go to **Agent Space** → **New agent**.
| Field | Value |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name** | Intake Coordinator |
| **Role** | Patient Registration Specialist |
| **Goal** | Validate incoming patient registrations, verify insurance eligibility, identify missing information, and route patients to the correct department |
> You are a patient intake coordinator who ensures every registration is complete, accurate, and properly routed. You validate patient demographics against required fields, verify insurance eligibility using real-time API data, and flag missing or inconsistent information. You are thorough but efficient, prioritizing patient experience by minimizing unnecessary follow-up. You never make clinical decisions — you ensure administrative readiness for care delivery.
Grant access to:
* EHR system (patient demographics, medical history)
* Scheduling API (provider availability, appointment slots)
* Insurance eligibility API (coverage verification, plan details)
* Registration forms and checklists knowledge space
* Insurance and billing policies knowledge space
* Patient and Registration objects, Average Intake Time metric
**Trigger:** User asks the agent to check a specific registration or batch of registrations.
1. Retrieve the registration record from the EHR system.
2. Load the required fields checklist for the target department from the registration forms knowledge space.
3. Compare the submitted data against the required fields and flag any missing or malformed entries.
4. Validate the patient's date of birth, contact information, and emergency contact formats.
5. Check for duplicate patient records in the EHR system using name, date of birth, and identifier matching.
6. Return a validation report listing the registration status (complete/incomplete), missing items, and any duplicate warnings.
**Trigger:** User asks the agent to verify a patient's insurance coverage.
1. Retrieve the patient's insurance information from the registration record.
2. Call the insurance eligibility API with the patient's member ID, date of birth, and plan identifier.
3. Parse the eligibility response for coverage status, effective dates, copay amounts, and deductible remaining.
4. Check whether the planned visit type requires pre-authorization per the insurance and billing policies knowledge space.
5. Return a coverage summary with eligibility status, cost-sharing details, and any authorization requirements.
**Trigger:** User asks the agent where to route a patient.
1. Review the patient's chief complaint, referral source, and visit type from the registration.
2. Check provider availability in the scheduling API for the relevant departments.
3. Match the patient's insurance type to accepted payers for each department.
4. Apply routing rules from the registration forms knowledge space (e.g., referrals to specialty, walk-ins to urgent care).
5. Return the recommended department, next available appointment slot, and any special instructions.
***
## Automation
### Playbook: New patient intake processor
Set the trigger to **Event — New record** on the `registrations` table in the EHR system. The playbook fires each time a patient submits a registration form.
The workflow validates, verifies, and routes each new registration automatically:
1. **Query** the new registration record including patient demographics, insurance information, and visit reason.
2. **Condition** — check whether all required fields are populated. If any are missing, branch to a notification step that sends the patient an email or SMS listing the outstanding items.
3. **Action** — call the insurance eligibility API to verify coverage and parse the response.
4. **Condition** — check eligibility status. If coverage is inactive or the visit requires pre-authorization, branch to a step that creates a follow-up task for the billing team.
5. **Action** — determine the target department based on visit type, referral source, and insurance acceptance.
6. **Action** — update the registration status in the EHR system with the assigned department and eligibility results.
7. **Delivery** — notify the receiving department and the patient.
* **Email/SMS to patient** — confirmation with assigned department, appointment details, and any items still needed
* **Slack** — notify the `#front-desk` channel when a registration is flagged incomplete or has an insurance issue
* **Email** — send the receiving department a summary of the incoming patient with relevant history
Click **Run now** to test with a recent registration, then toggle to **Active**.
***
## What's next
Reduce physician documentation burden by drafting clinical notes from EHR data and guidelines.
See the full list.