KinSync

KinSync — The family assistant that never turns a maybe into a yes

Imagine asking your family assistant, “Who's taking Dad to the clinic on Thursday?”

Someone proposed Arjun. Another family member approved the change. But Arjun hasn't accepted.

KinSync won't tell you Arjun is responsible.

KinSync is an open-source family-care coordination prototype that separates three events: proposing a handoff, approving it, and the named recipient accepting it.

Approval alone never transfers responsibility. Until the recipient explicitly accepts, the original person remains responsible in KinSync's records.

Built with TypeScript, MCP, MCP Apps, and SQLite, KinSync maintains persistent responsibility state, exposes an audit trail of successful and refused actions, and answers responsibility questions from recorded evidence rather than conversational assumptions.

Its central principle is simple: an AI assistant can carry the question, but it cannot manufacture the answer.

Inspiration

A thumbs-up is not a yes.

Imagine three siblings coordinating care for their father. Priya asks Arjun to take Dad to a clinic appointment on Thursday. Arjun responds with a thumbs-up. Priya assumes the responsibility has transferred. Arjun thinks he merely acknowledged the message.

Now two people have different understandings of who is responsible.

Family caregiving often involves coordinating appointments, errands, and responsibilities across busy schedules. Messaging apps help people communicate, but a message being seen, a request being approved, and a responsibility being accepted are three different things.

That distinction inspired KinSync — the family assistant that never turns a maybe into a yes.

Our guiding principle is simple:

An AI assistant can carry the question. It cannot manufacture the answer.

What it does

KinSync is a family-care responsibility coordination prototype built around explicit human agreement.

Instead of silently reassigning a responsibility when someone suggests a change, KinSync follows a structured handoff:

1. Proposal: A family member requests that someone else take responsibility.
2. Approval: An authorized family member approves the proposed handoff.
3. Acceptance: The intended recipient explicitly accepts responsibility.
4. Transfer: Only after acceptance does KinSync update the recorded responsible person.

Until the handoff is accepted, the original responsible person remains responsible in the system.

KinSync can also answer questions such as:

"Who's taking Dad to the clinic Thursday?"

If Arjun has not accepted, KinSync does not invent an agreement. It explains that Priya is still responsible and that Arjun has not yet said yes.

If no relevant agreement is recorded, it refuses to guess.

After acceptance, KinSync reports that Arjun is now the recorded responsible person, without claiming that the appointment actually happened.

The goal is to make family coordination more transparent, accountable, and trustworthy.

How we built it

KinSync is implemented as a self-hosted Model Context Protocol (MCP) server, using the MCP 2025-11-25 specification over sessionful Streamable HTTP.

The system includes:

• TypeScript application and MCP server: Exposes tools for reading household state, proposing handoffs, and processing authorized decisions.
• MCP Apps dashboard: Provides interactive controls for viewing responsibilities, approving proposals, accepting handoffs, and inspecting records.
• SQLite persistence: Stores household state and responsibility transitions across server restarts.
• Deterministic agent planner: Interprets supported requests and uses MCP tools without requiring paid LLM APIs.
• AgentAdapter restrictions: Prevents KinSync's planner from accessing human-only approval and acceptance actions.
• Server-side authorization: Enforces household membership, roles, and valid state transitions.
• Idempotency and concurrency protection: Handles repeated requests and guards against conflicting state updates.
• Transactional audit trail: Records server-side changes alongside the corresponding state transitions.
• Grounded responsibility answers: Uses live MCP tool results to answer questions without inventing acceptance.

The project runs locally without paid API keys or cloud infrastructure.

Our Alexa+ interaction is simulated through typed input. KinSync does not claim native Alexa+ integration, real voice recognition, or connectivity to an Alexa device.

All people and household records shown in the demonstration are synthetic.

Challenges we ran into

1. Preventing AI from acting as a human

The central technical challenge was ensuring that an automated planner could not approve or accept a handoff on behalf of a person.

We addressed this through KinSync's AgentAdapter, which excludes human-only tools from the planner's permitted capabilities and rejects attempted use.

We also tested deliberately prohibited planner actions.

An important boundary remains: the underlying MCP server exposes decision tools to connected clients, so production deployment would require stronger authenticated user identities and trusted authorization boundaries. We deliberately document that limitation rather than presenting the prototype as production-ready security.

2. Making responsibility transitions reliable

A responsibility handoff must behave correctly even when requests are repeated, rejected, declined, or issued concurrently.

We implemented validated state transitions, idempotency, compare-and-set concurrency checks, and transactional audit records.

3. Preventing misleading assistant answers

An assistant can sound confident even when its information is incomplete.

We built the responsibility-query workflow around actual persisted MCP records and added output-safety checks to prevent unsupported acceptance claims.

When the system cannot establish who agreed, it says so.

4. Demonstrating the system without native Alexa+ access

Because native Alexa+ integration was unavailable in our hackathon environment, we created an explicitly labeled simulation while keeping the MCP server, tool calls, dashboard interactions, database updates, and server restart real.

This allowed us to demonstrate the core engineering without implying integrations that do not exist.

Accomplishments we're proud of

Our biggest accomplishment is turning a simple principle — don't assume someone said yes — into an enforceable application workflow.

KinSync includes a working MCP server, an interactive MCP Apps interface, persistent responsibility tracking, authorization rules, concurrency protection, and an auditable handoff lifecycle.

The project has 236 passing automated tests covering its implemented behaviors.

The demonstration also includes a real server restart to show that responsibility agreements persist rather than existing only in a temporary chat session.

We are particularly proud that the assistant can say "I don't know" when no reliable agreement exists.

In a system involving human responsibility, that can be more useful than a confident but unsupported answer.

What we learned

Building KinSync reinforced several engineering lessons:

• Human consent should be represented explicitly in application state, not inferred from conversational language.
• AI tool permissions need enforceable application boundaries, not just prompt instructions.
• An assistant's answer should be grounded in authoritative records.
• Approval, acceptance, and completion are different events.
• Reliable state transitions, persistence, and auditability are essential when software coordinates real people.
• Transparent limitations make an AI prototype more credible.

What's next for KinSync

KinSync is currently a hackathon prototype, not a production caregiving service.

Future directions include authenticated household accounts, real notification delivery, deadline-aware reminders, richer scheduling integrations, and accessibility improvements.

We also see potential for the underlying responsibility-handoff pattern in other settings where AI assistants coordinate actions between people.

Before any real-world caregiving deployment, we would need to validate the workflow with users and strengthen authentication, privacy, and operational reliability.

KinSync's vision is not an assistant that makes decisions for everyone. It is an assistant that helps people coordinate while preserving their right to decide for themselves.

Built With

• claude
• github
• javascript
• mcp
• node.js
• ollama
• sqlite
• streamablehttp
• typescript