kincall

Inspiration

A missed phone call can mean very different things when someone lives alone, has reduced mobility, or simply depends on a small circle of people around them.

I wanted to build something that goes beyond sending another notification. If a person says they need help, someone should actually take ownership of that request — and the person should know what is happening.

That idea became KinCall: a voice-first safety net that keeps people connected to the people who care about them, turning a simple check-in into coordinated human support when it matters.

What it does

KinCall checks in with a person through a natural phone conversation and understands whether everything is fine or whether support may be needed.

When help is required, KinCall reaches the person's trusted circle one contact at a time until someone confirms they can step in. It then calls the person back with a clear outcome, so they are never left wondering whether anyone is coming.

Instead of replacing human care, KinCall helps make sure the right human actually gets involved.

The experience is designed around a simple promise:

Check in. Find someone who can help. Close the loop.

How we built it

KinCall is a full-stack application built with Next.js, TypeScript, Supabase/PostgreSQL and CALL-E.

I deliberately separated the system into two layers.

The voice agents handle what AI is good at: having natural conversations and converting them into structured information.

A deterministic orchestration engine then handles the important decisions: whether support is needed, who should be contacted next, when retries are allowed, when the cascade should stop, and what final outcome should be communicated.

The workflow uses three main agent roles:

• a Companion Agent for the initial check-in;
• Family Agents for trusted contacts;
• a Notification Agent for the final callback.

I also built a complete dashboard and timeline so every step of the process remains visible.

For safe development and judging, KinCall includes a fake/no-call mode by default, allowing the full workflow to be demonstrated without placing any real phone calls. Live mode requires explicit configuration and uses only the operator's own consenting phone numbers.

Challenges we ran into

The hardest part was not making an AI agent place a phone call. It was deciding what the system should trust after that call.

An AI model can interpret a conversation, but I did not want it to independently decide whether somebody should be contacted. I therefore designed a strict boundary: AI interprets; deterministic code decides.

I also had to handle many situations that look simple until they happen in a real phone workflow: someone not answering, a contact declining, uncertain results, bounded retries, a callback that may itself go unanswered, and preventing the same person from being called twice after a crash or restart.

Another challenge was making the project reusable rather than tied to my demo data. I refactored KinCall so a new user can create their own Supabase project, profiles, trusted contacts and phone numbers without depending on any of my original data.

Privacy and safety also shaped the implementation from the beginning: phone numbers are validated and masked, fictional numbers are blocked from live calls, consent is required, and secrets or personal data never live in the repository.

Accomplishments that we're proud of

I'm especially proud that KinCall became much more than a scripted hackathon demo.

The application now supports complete end-to-end workflows, including trusted-circle escalation, bounded retries, outcome callbacks, persistence, crash recovery and a user-facing timeline.

I built 982 passing tests across 66 test files, covering the decision engine, orchestration, API routes, fake and live boundaries, arbitrary user-created profiles, trusted-contact ordering and failure scenarios.

KinCall can also be cloned by a completely new user and run safely with their own data — or evaluated entirely in memory with no Supabase account and no real calls.

Finally, KinCall was accepted into the official CALL-E awesome-phone-call-agents repository, where my contribution was reviewed and merged into main.

What we learned

The biggest lesson was that reliable agentic systems are not about giving AI more control.

They are about deciding where AI should stop.

Natural-language understanding is incredibly useful for extracting meaning from a conversation, but decisions with real-world consequences benefit from deterministic rules, explicit states and auditable transitions.

I also learned that "the call succeeded" is not the same as "the problem was solved." A good system has to follow the entire chain until somebody takes responsibility — and communicate that outcome back to the original person.

That closed-loop thinking ended up defining KinCall.

What's next for KinCall

The next step is turning KinCall from a hackathon project into a service that families and care organizations could realistically use.

I want to add secure user accounts, easier onboarding, configurable check-in schedules and a production deployment while keeping the same consent-first model.

I also see KinCall becoming multi-channel. A trusted contact who misses a call could receive a follow-up message, while the phone remains the primary interface for the person being checked on.

Longer term, KinCall could support larger care networks, richer availability rules and integrations with existing care platforms — while preserving the principle at the heart of the project:

technology should coordinate care, not replace it.

Built With

• agent
• agents
• api
• call-e
• conversational
• css
• e.164
• github
• human-in-the-loop
• machine
• next.js
• node.js
• orchestration
• outputs
• postgresql
• react
• rest
• state
• structured
• supabase
• tailwind
• typescript
• vitest
• voice