Kin

Kin turns health records into proactive support for your whole family: spotting what needs attention, preparing next steps, and coordinating care so no one has to remember or manage everything alone.

Comment

Inspiration

If a doctor asked you what medications your parents take, what allergies they have, or what changed at their last appointment, would you know?

That question is where Kin started. We care about our families, but that does not automatically mean we understand their health information or know what they need next. Those gaps are easy to ignore until something becomes urgent.

Having a medical record somewhere does not solve the whole problem. Someone still has to find it, understand it, notice what matters now, and make sure the next step happens. In a family, that responsibility can fall on one person or get lost between people who each know only part of the picture.

Talking with the FinchNode sponsor pushed my thinking further. Even opening an app and knowing what to ask can be a barrier. What if health support appeared in everyday situations where people overlook it, such as preparing for a trip or following through after an appointment?

I wanted the experience to feel simple enough for someone who is older, tired, or already managing too much. They should not need to become good at prompting to get useful help.

That became Kin: a proactive family health companion that brings relevant information, practical next steps, and the people who can help into one place.

What Kin does

A private companion that makes records understandable

Each person has a private space to ask about their own health information. Kin can explain documented results, compare information across records, answer follow-up questions, and help prepare questions for a clinician.

The answer is connected to its evidence. Users can inspect the underlying record and its clinical date instead of relying on an explanation with no visible source. Dates matter because an old note should not silently become a statement about someone's current health.

Preparation without needing the right prompt

Kin can prepare appointment briefs, after-visit steps, and travel checklists without requiring someone to start a conversation. Eligible care instructions and upcoming trips provide context for practical preparation, such as gathering records, making a question list, checking supplies, or organizing support.

The purpose is to bring health into everyday planning. An upcoming trip, for example, should be an opportunity to prepare relevant information and questions before the person leaves.

Today: a clear next step

The Today view turns preparation, reminders, visits, and family tasks into swipeable cards organized around dates and priority. Instead of opening a dense dashboard and deciding where to begin, the user can see what needs attention and take a focused action.

Enabled check-ins and reminders appear while the app is open or when someone returns. Completing a step records the user's update; it does not verify that medication was taken or medical care occurred.

A family conversation with follow-through

The family chat is central to Kin because healthcare often involves more than one person. Understanding a record is useful, but someone may still need help preparing questions, organizing supplies, or following through on a visit.

Family members can exchange messages and create requests that can be accepted, declined, canceled, or completed. Responsibility becomes visible instead of remaining an assumption in a group conversation.

With auto-care enabled and the relevant sharing preference, eligible practical-support steps can also produce a generic family help request. The model's suggestion and the application's permission to act remain separate.

Selective sharing

Being in the same family should not mean automatic access to every private record.

A person can review and share a fixed snapshot of selected information. Their private conversation and other records remain separate. The family companion works from evidence actually shared into the family context, rather than silently accessing everyone's medical history.

Emergency information and family visits

Family-visible emergency cards hold selected medical information, emergency contacts, and a review timestamp. They are designed to make chosen details easier to find, not to replace a complete or independently verified medical history.

Kin also supports arranging and confirming synthetic appointment reservations for family members. This demonstrates the coordination workflow in a sandbox without claiming to contact a real healthcare provider.

How the AI works

The central technical decision was to separate what the model can suggest from what the application is allowed to do.

Structured generation instead of unrestricted actions

The server calls Gemini through its generateContent API with structured JSON responses and a low temperature. The default model in the submitted source is gemini-3.5-flash-lite, configurable through the environment.

The application distinguishes conversational responses, record-based answers, reminder requests, and planning. Model output is processed by application logic rather than treated as permission to execute arbitrary actions.

Permission-aware context

For a private response, Kin supplies authorized records belonging to that person. For a family response, record evidence is limited to explicitly shared snapshots. The current implementation bounds that family evidence to the latest twelve snapshots.

Recent conversation and saved plan summaries provide continuity within the relevant audience. Kin does not assume unlimited memory or put every family member's private records into a common model context.

Evidence checks before publication

Record-grounded output must identify its source and quote an exact, contiguous passage from the supplied evidence. Code checks the record IDs, quotations, and numerical claims against that context.

If validation fails, the system allows one bounded repair attempt using the same authorized evidence. An answer that still fails validation is rejected rather than published as a verified response.

The backend also rechecks membership, record revisions, and evidence after the model request. Information or permissions can change while an external request is running, so the initial check is not the only check.

These safeguards make grounding inspectable. They are not a guarantee of clinical accuracy, and Kin does not replace a clinician's judgment.

Constrained proactive planning

Deterministic rules identify eligible care events. Gemini then proposes one to four organizational steps from a fixed set of categories, including questions, records, instructions, supplies, travel, meals, and logs.

Plans must cite the evidence that triggered them. Separate application logic controls activation, completion, sharing, and reminder timing.

The current prototype checks for eligible work while the app is active and surfaces relevant state when the user returns. It does not claim to run a closed-app notification service.

How I built it and why this stack fits

Actually Intelligent (AI)

Kin connects explanation, preparation, and coordination. The intelligence is useful when it reduces the work between reading a record and taking an appropriate next step. I combined model-generated language with explicit evidence boundaries and predictable application behavior.

FinchNode: Personalized Healthcare

FinchNode provides synthetic health records through its demo API integration. The project also includes an account-backed sandbox connection path.

Kin normalizes structured records into readable evidence while retaining source identifiers, clinical dates, and synchronization metadata. This gives the companion traceable context for explanations and preparation.

The richer Kin-authored care simulation remains separately labeled. A failed FinchNode request should not silently turn into invented replacement records.

Gemini API

Gemini handles explanations, comparisons, follow-up answers, doctor-question preparation, and constrained planning. Structured output lets the application validate the result and route it to the appropriate experience.

I used the model for language and contextual interpretation while keeping access control and state changes in application code.

Spacetime: Real-time Backend

SpacetimeDB Maincloud stores persistent application state and supports real-time family coordination. Private tables are exposed through identity- and family-scoped views, and the React client subscribes to relevant changes.

This matters because family coordination is shared work. A task accepted in one person's session should appear in another person's view, and profiles, conversations, plans, reminders, and tasks should survive refresh.

Figma: Design

I used Figma to iterate desktop and mobile screens and build reusable components and design variables before bringing that direction into the React app with Codex.

The phthalo-green glass treatment gives Kin a recognizable identity, while the layout emphasizes focused actions and readable information. I repeatedly refined the balance between visual depth, conversation readability, and ease of use.

Frontend and deployment

The application uses React, TypeScript, and Vite, deployed on Vercel. Codex supported implementation throughout development.

Challenges I faced

Avoiding duplicate proactive work: Refreshing the same records should not produce another copy of the same plan. Event fingerprints based on relevant record content help recognize previously processed events.

Making privacy consistent: Hiding a screen is not enough. Private answers, family answers, planning, and sharing need consistent evidence and permission boundaries.

Keeping coordination reliable: Requests need a clear lifecycle and a named owner. I tested separate fictional profiles to verify that selected sharing and accepted tasks appeared in the other person's session.

Making failures understandable: Missing records, unavailable services, and invalid model output need clear handling. A loading indicator or confident explanation cannot substitute for a verified result.

Keeping the interface approachable: Health information can quickly become a wall of text. I kept returning to one question: can someone understand what matters and take the next step without unnecessary effort?

What I learned

Making an assistant feel effortless requires substantial structure underneath it. Relevant context, reliable sources, clear permissions, and predictable actions matter as much as the generated answer.

I am proud that Kin connects a complete workflow: a record supports an explanation, selected information can be shared, and a practical request becomes a responsibility another person accepts. I demonstrated that with fictional profiles, live Gemini responses, source evidence, and synchronized task states.

The family experience is important because information alone does not guarantee follow-through. People need a way to understand the situation together and know who is handling the next step.

Current scope and what comes next

The current build is a working prototype using fictional medical records and demo profiles rather than production authentication. Reservations are sandbox-only, reminders are in-app, and task completion represents a coordination update.

Real provider booking, calendar and Gmail connections, voice interactions, native widgets, closed-app push notifications, and verified medication-taking are not implemented.

A separate interactive phone concept explores how a Kin widget could open directly into a shared family briefing. It uses scripted sample data and illustrates a future native experience, separate from the working web app.

Next, I want to improve accessibility, test grounding against more varied records, evaluate the experience with families and caregivers, and develop clearer, revocable standing permissions for recurring support.

The goal is to make health support part of everyday life: understandable when someone needs context, proactive when preparation would help, and shared when a family can make the next step easier.

Built With

Share this project:

Updates

Submission history