Project Info

kin.ai

This project did not submit a demo video on Devpost.

Inspiration

Most Americans grow up watching their parents do the impossible. During the day, they raise us. At night, they're on the phone with grandparents across the country: coordinating doctors, translating diagnoses, wiring money for medications, and carrying the invisible weight of loving someone who is aging and far away. They were the middle of a sandwich they didn't really sign up for: children on one side, aging parents on the other, and no infrastructure to hold any of it together. That's the sandwich generation. An estimated 53 million Americans living it right now -- managing careers, raising kids, and simultaneously trying to keep an eye on a parent who insists they're fine. They lose an average of $304,000 in lifetime wages to caregiving. They spend 24 hours per week on tasks that are invisible to everyone else. 1 in 5 has reduced their work hours. 1 in 10 has left their job entirely. For the elderly, the numbers are just as devastating. 1 in 4 adults over 65 falls each year. 40% of seniors don't take their medications as prescribed. 70% of hospital readmissions are preventable, caused by missed medications, skipped follow-ups, and symptoms nobody caught in time. The hardest part isn't the logistics. It's the guilt. The 2am anxiety. The phone call you didn't make. The signal you missed. The moment you realize you haven't actually checked in since Tuesday. We built Kin because we've watched that guilt eat people alive. And because we believe the right infrastructure could make it unnecessary.

What it does

Kin is a shared family health command center. It's a living dashboard that gives every sibling, caregiver, and doctor a real-time, complete picture of an elderly parent's health and daily needs. No more scattered group texts. No more one sibling carrying everything. No more finding out too late. The Shared Dashboard One view for the entire care team. Upcoming appointments, medication schedules, refill deadlines, wellness trends over 30/60/90 days, family task assignments, and live health status. Always up to date, visible to everyone. Medication Intelligence Kin tracks every medication, sends refill reminders before prescriptions run out, and uses Gemini Vision to scan pill bottles and automatically flag dangerous drug interactions. Family Coordination Tasks get assigned across siblings. Expenses get tracked and split. Everyone sees the same information. No one is left out of the loop and no one has to be the designated worrier. Longitudinal Wellness Monitoring Kin builds a 90-day health baseline -- tracking pain levels, mood, medication compliance, and cognitive patterns over time. It doesn't just tell you how Mom is doing today. It tells you if she's been slowly declining for three weeks. Daily AI Check-In Calls Every morning, Kin places an automated wellness call and asks your parent how they're doing -- in plain conversation, no app required. Whisper transcribes the call. Claude analyzes it for clinical signals: mood, pain, medication compliance, confusion markers, red flags. Within 60 seconds of the call ending, the whole family receives a complete health update. It's not the main feature -- it's the heartbeat of the platform. The daily data point that makes everything else smarter. Visual Wellness Assessment Kin uses MediaPipe computer vision to perform facial wellness scans — detecting fatigue, tremors, facial asymmetry, and alertness changes that could signal an early stroke or neurological event. Trends are tracked over time, not flagged in isolation.

How we built it

Frontend: Next.js 15, React, Tailwind CSS, deployed on Vercel Voice AI: Twilio Voice API for outbound daily calls with multi-question TwiML conversation flow Transcription: OpenAI Whisper for real-time speech-to-text from call recordings Clinical Intelligence: Anthropic Claude for extracting mood, pain levels, medication compliance, and red flags from transcripts Computer Vision: Google Gemini Vision for medication bottle scanning and drug interaction detection Real-time Alerts: Twilio WhatsApp API for instant family notifications Database: Supabase (PostgreSQL) for longitudinal health tracking Face Analysis: MediaPipe Holistic for 468-point facial landmark wellness assessment

Challenges we ran into

Let's be honest. The biggest challenge wasn't technical — it was me. I'm a product thinker at heart. I came into this hackathon with a strong vision for user journeys, family dynamics, and the emotional reality of caregiving. What I didn't come in with was the technical depth to execute everything I imagined. That gap showed up constantly. Twilio's TwiML XML parsing broke at 1am because of an unescaped ampersand in a URL parameter. Vercel's serverless functions timed out silently at 10 seconds while Whisper was still transcribing. Supabase migrations failed mid-build and took down half the data layer. A2P 10DLC SMS regulations blocked delivery entirely, forcing a full pivot to WhatsApp at 3am. Every one of these was a wall I had to figure out how to climb with limited sleep and limited experience. Features I had fully designed — real-time voice streaming, predictive crisis modeling, Google Calendar sync — didn't make it because I ran out of time and technical runway. What this build represents is a product thinker's honest first attempt at a full-stack AI healthcare platform. The foundation is real. The user journey is right. The gaps are a roadmap, not a failure.

Accomplishments we're proud of

We built a live, end-to-end AI healthcare loop that actually works. A real phone call goes out. A real person answers. Whisper transcribes their words. Claude extracts clinical intelligence from natural speech. A WhatsApp alert arrives on a real phone within 1 minute. That entire pipeline, from voice to insight to family notifications, is deployed and running in production. We're proud that Margaret, the elderly parent in our demo, doesn't interact with any AI. She answers a phone call. That invisibility ( AI working in the background so the human experience stays human ) is the design principle we're most proud of. The best healthcare AI disappears. We're also proud of building something emotionally honest. Kin isn't a productivity tool. It's an anxiety reducer. It's the thing that lets you sleep at night knowing someone is watching, even when you can't be there. Getting that emotional truth right mattered as much to us as getting the code right.

What we learned

Building with LLMs in a real product context is fundamentally different from building with traditional APIs. LLMs aren't deterministic. They hallucinate. They return malformed JSON when you least expect it. They hit rate limits at the worst possible moment. Designing around that uncertainty — building fallbacks, validating outputs, prompting defensively — is a skill that took most of the weekend to develop. We learned that prompt engineering is product design. The difference between Claude returning clean structured JSON with mood, pain level, and a one-sentence clinical summary versus an unstructured paragraph — that's entirely determined by how precisely you define the task. Vague prompts produce vague outputs. In healthcare, vague is dangerous. We learned something deeper about what AI is actually good for in healthcare. It's not diagnosis. It's not replacing doctors. It's the connective tissue between visits — the daily signal that builds a longitudinal picture no single appointment ever could. A doctor sees your parent for 15 minutes every three months. Kin talks to them every morning. That asymmetry is where AI creates real value: not in the dramatic intervention, but in the quiet accumulation of data that makes the intervention unnecessary. We learned that family caregiving is a coordination problem as much as a medical one. The hardest part of caring for an aging parent isn't finding good doctors — it's making sure three siblings in three cities all have the same information at the same time. Technology that solves coordination reduces burnout. And we learned that the sandwich generation doesn't need more apps. They need less to manage. Every design decision in Kin was made through that lens: does this reduce cognitive load, or add to it?

What's next

for Kin.ai What needs to be fixed first: The data infrastructure needs a rebuild. Several Supabase migrations broke mid-hackathon, meaning the crisis prediction score is currently pulling from seeded mock data rather than real call history. Before anything else, the data pipeline needs to be reliable, validated, and properly structured. The AI models need tighter prompting and real training data. Claude's clinical extraction is promising but inconsistent without a large enough dataset of real wellness call transcripts. With real data, the prompts can be condition-specific — Margaret's diabetes means her medication questions should look different from a patient with early dementia. The roadmap: Google Calendar sync — OAuth integration so appointments automatically appear in the dashboard without manual entry, and the family never misses a follow-up HIPAA compliance pathway — encrypting PHI at rest, audit logging, and business associate agreements before any clinical deployment EHR integration — direct read/write access to Epic and Cerner so physicians can see Kin wellness trends without leaving their existing workflow Better model training — personalized clinical intelligence built on condition-specific prompting and longitudinal user data Predictive crisis scoring — 30-day hospitalization risk modeling based on wellness trends, medication adherence, and social isolation signals Kin is a foundation. The product vision is clear. The path forward is building infrastructure worthy of the problem — and worthy of the 53 million people carrying it.

Kin — AI Caregiving Platform

The command center for family caregiving. Kin monitors aging parents through daily AI voice check-ins, clinical signal analysis, and a shared family dashboard — so caregivers catch health crises before they happen.

Live Demo: kin-douaemaaroufs-projects.vercel.app
Built at: TreeHacks 2026

The Problem

53 million Americans are unpaid caregivers for an aging parent. They lose an average of $304,000 in lifetime wages. They spend 24 hours per week on invisible tasks. And 70% of hospital readmissions are preventable — caused by missed medications, skipped follow-ups, and symptoms nobody caught in time.

Kin is the infrastructure that was missing.

Features

Shared Family Dashboard — One view for every sibling, caregiver, and doctor. Upcoming appointments, medication schedules, refill deadlines, wellness trends, and family task assignments in real time.
Daily AI Voice Check-Ins — Kin calls your parent every morning, asks wellness questions in natural conversation, transcribes with OpenAI Whisper, analyzes with Claude, and sends the whole family a WhatsApp alert within 60 seconds.
Medication Intelligence — Tracks prescriptions, sends refill reminders, and uses Gemini Vision to scan pill bottles and flag dangerous drug interactions.
Visual Wellness Assessment — MediaPipe facial landmark analysis detects fatigue, tremors, and asymmetry over time.
Family Coordination — Task assignment, expense tracking, and shared visibility across the entire care team.
Benefits Navigator — Claude-powered chat for navigating Medicare, Medicaid, and caregiver support programs.

Tech Stack

Layer	Technology
Frontend	Next.js 15, React, TypeScript, Tailwind CSS
Deployment	Vercel
Database	Supabase (PostgreSQL)
Voice Calls	Twilio Voice API + TwiML
Transcription	OpenAI Whisper
Clinical AI	Anthropic Claude
Computer Vision	Google Gemini Vision
Face Analysis	MediaPipe Holistic
Alerts	Twilio WhatsApp API
Drug Data	OpenFDA API

Getting Started

Prerequisites

Node.js 18+
npm or yarn
Accounts for: Twilio, OpenAI, Anthropic, Google AI Studio, Supabase

Installation

git clone https://github.com/douaemaarouf/kin.git
cd kin
npm install

Environment Variables

Create a .env.local file in the root directory:

# Supabase
NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key
SUPABASE_SERVICE_ROLE_KEY=your_service_role_key

# Anthropic
ANTHROPIC_API_KEY=your_anthropic_key

# OpenAI
OPENAI_API_KEY=your_openai_key

# Google Gemini
GEMINI_API_KEY=your_gemini_key

# Twilio
TWILIO_ACCOUNT_SID=your_account_sid
TWILIO_AUTH_TOKEN=your_auth_token
TWILIO_PHONE_NUMBER=your_twilio_number
TWILIO_CAREGIVER_PHONE=whatsapp:+1XXXXXXXXXX

# App
NEXT_PUBLIC_APP_URL=http://localhost:3000

Run Development Server

npm run dev

Open http://localhost:3000

Deployment

Deploy to Vercel

Push your code to GitHub
Import the repository at vercel.com
Add all environment variables from .env.local in Vercel → Settings → Environment Variables
Deploy

Important: Disable Vercel Authentication (Deployment Protection) so Twilio webhooks can reach your API routes, or configure a Protection Bypass token.

Twilio Setup

Purchase a phone number in the Twilio Console
Set the Voice webhook URL to: https://your-vercel-url.vercel.app/api/twilio/twiml
For WhatsApp alerts, join the Twilio Sandbox at +1 415 523 8886 by texting join <your-sandbox-word>
Add TWILIO_CAREGIVER_PHONE=whatsapp:+1XXXXXXXXXX to your env vars

Supabase Setup

Run the following migration in Supabase → SQL Editor:

create table if not exists check_in_calls (
  id uuid default gen_random_uuid() primary key,
  call_sid text unique,
  contact_id text,
  contact_name text,
  phone_number text,
  status text default 'pending',
  transcript text,
  response_data jsonb,
  call_duration integer,
  completed_at timestamptz,
  created_at timestamptz default now()
);

Project Structure

src/
├── app/
│   ├── api/
│   │   ├── anthropic/stream/     # Claude streaming chat
│   │   ├── gemini/               # Gemini Vision medication scan
│   │   ├── twilio/
│   │   │   ├── check-in-call/    # Initiates outbound call
│   │   │   ├── twiml/            # TwiML greeting + first question
│   │   │   ├── next-question/    # TwiML second question
│   │   │   ├── final-question/   # TwiML third question
│   │   │   ├── hangup/           # TwiML hangup
│   │   │   ├── recording-complete/ # Whisper + Claude + WhatsApp
│   │   │   └── call-status/      # Call status webhook
│   │   └── voice-analysis/       # Wellness trend analysis
│   ├── dashboard/                # Overview page
│   ├── check-ins/                # Kin Check + voice check-in
│   ├── benefits/                 # Kin Chat + Claude assistant
│   ├── family-coordination-hub/  # Family tasks + expenses
│   └── medication-manager/       # Medications + Gemini scanner
├── components/
│   └── common/                   # Sidebar, navigation
└── lib/
    ├── anthropic-client.ts
    ├── gemini-client.ts
    ├── twilio-client.ts
    └── supabase/

The Demo Flow

Open the dashboard — see Margaret's wellness score, upcoming appointments, and family tasks
Navigate to Kin Check → enter a phone number → hit Call Margaret Now
Answer the call — AI asks three wellness questions in natural conversation
Hang up — within 60 seconds, a WhatsApp message arrives with the full clinical summary
Navigate to Kin Chat → ask Claude about Medicare benefits or caregiver support programs
Navigate to Records → click Scan Medication → point camera at a pill bottle → Gemini extracts drug info and flags interactions

Available Scripts

npm run dev        # Start development server
npm run build      # Build for production
npm run start      # Start production server
npm run lint       # Run ESLint

License

MIT

Built with ❤️ at TreeHacks 2026

Analysis

Compare with all teams

View

Metric

douaemaarouf
50
Cursor
12

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
Google GeminiIn code
JavaScriptIn code
Next.jsIn code
OpenAIIn code
ReactIn code
SQLIn code
SupabaseIn code
Tailwind CSSIn code
TypeScriptIn code
Node.jsClaimed
PostgreSQLClaimed
VercelClaimed

11 of 14 appear in the indexed code. 3 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

CursorCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

638 KB

Source files

123

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.