Kinwise

Kinwise is a child-friendly AI companion with guardian supervision.

Comment

Inspiration

AI is becoming an everyday learning tool, but most AI chat experiences aren't designed around the relationship between children and their guardians. Children deserve the freedom to ask questions, explore ideas, and learn at their own pace. At the same time, guardians need meaningful ways to understand and support that exploration.

We built Kinwise — Curiosity, with care. to bring those two needs together.

Instead of treating child safety as simply blocking certain questions, we wanted to create an AI learning companion that combines personalized learning, thoughtful safety responses, and real-time guardian supervision.

Our goal was to make AI feel less like an unsupervised black box and more like a learning experience families can navigate together.

What it does

Kinwise is a native iOS AI learning companion with two experiences: one for children and one for guardians.

For children, Kinwise provides a conversational AI assistant powered by Google Gemini. Children can ask educational questions, revisit previous conversations, and benefit from persistent memory. For example, if a child mentions building a volcano for a science project, Kinwise can remember that context through Backboard and help them continue the project in a later conversation.

Every eligible message goes through a safety-aware backend pipeline. Gemini produces both a proposed response and structured safety information in a single API call. Our FastAPI backend then applies deterministic safety rules before deciding what the child can see.

For guardians, Kinwise provides a dashboard with conversation activity, usage metrics, safety information, and remote access controls. Guardians can pause or resume a child's AI access, with changes delivered immediately to the child's app through an authenticated WebSocket.

Kinwise also integrates Spectrum iMessage. When high- or critical-severity safety events occur, the system can notify guardians without including the child's actual words. Guardians can reply with commands such as PAUSE or RESUME to control access directly through iMessage.

Kinwise supports real family structures through many-to-many guardian–child relationships. A guardian can supervise multiple children, and a child can have multiple guardians with equal permissions. Additional guardians join through an invitation process requiring confirmation from the inviting guardian.

The result is an AI learning experience that connects curiosity, personalized memory, safety awareness, and guardian intervention.

How we built it

We built Kinwise as a native iOS application backed by a Python API and several integrated services.

SwiftUI — Native iOS experience

We used Swift 6 and SwiftUI to build separate child and guardian interfaces within one application. Children have their own accounts and conversation experience, while guardians can manage linked children, view dashboard information, and control access.

FastAPI — The central backend

FastAPI handles authentication, authorization, conversation processing, safety enforcement, guardian relationships, and real-time updates.

Guardians register with email and password, while child accounts must be created by an authenticated guardian. Passwords are hashed with Argon2id, and sessions use short-lived access tokens and rotating refresh tokens.

Google Gemini — Conversation and safety classification

We use Gemini's generateContent API with structured JSON output.

Instead of making separate requests for safety classification and response generation, Kinwise makes one Gemini call per eligible child message. That call returns both a proposed answer and safety metadata.

Our backend validates the result and applies deterministic safety rules. If a child is paused, Gemini is not called. If a guardian pauses access while generation is in progress, the response is withheld.

Tiger Data — Persistent application data

We use Tiger Data's PostgreSQL database with SQLAlchemy and Alembic to store user accounts, guardian–child relationships, conversations, messages, safety events, access states, and usage information.

Guardian dashboard metrics are calculated from real persisted records rather than hardcoded values.

Backboard — Persistent AI memory

We integrated Backboard assistants and memories to preserve useful context across conversations.

Each child has isolated memory, and the backend controls what information is safe to store. This lets Kinwise remember learning interests and projects without treating every conversation detail as something that should be remembered permanently.

Spectrum (Phonton 2.0) — Guardian iMessage integration

We built a Node.js bridge using spectrum-ts to connect Spectrum iMessage with our FastAPI backend.

Spectrum (Phonton 2.0) receives incoming guardian messages, while FastAPI determines the appropriate reply and handles commands such as PAUSE and RESUME. When a guardian supervises multiple children, commands must specify the child's username.

WebSockets — Real-time intervention

An authenticated WebSocket connection keeps the child app synchronized with the backend's access state. When a guardian pauses or resumes access, the child's interface updates without requiring a manual refresh.

Challenges we ran into

Balancing safety with a natural conversation experience

A child-friendly assistant needs to do more than reject unsafe requests. We had to distinguish between requests for dangerous instructions, expressions of distress, and sensitive disclosures where a child may actually need support.

We addressed this with structured Gemini output and deterministic backend policies. We also designed safety notifications to avoid including the child's actual words, reducing unnecessary disclosure of sensitive information.

Reducing AI latency without removing safety checks

Making separate Gemini requests for classification and response generation would increase latency and cost. We designed a single-call structured-output approach that returns both pieces of information, then validates the result on the backend.

The challenge was ensuring that a faster architecture did not mean blindly trusting the model's own assessment.

Supporting multiple guardians securely

Real families don't always fit a one-parent, one-child account model. We wanted multiple guardians to have equal permissions without introducing unnecessary primary and secondary roles.

That required many-to-many relationships, secure invitations, password confirmation, authorization checks, and protection against removing a child's final active guardian.

Making pause and resume reliable

Pausing an AI assistant sounds simple until a request is already being generated. We had to ensure the backend, not just the UI, enforced the child's access state.

Our solution checks access before calling Gemini and again before delivering the response, while WebSockets update the child interface in real time.

Connecting iMessage to backend actions

Integrating Spectrum required bridging a Node.js messaging service with our Python backend, mapping incoming messages to guardian accounts, and handling commands for guardians supervising more than one child.

We also had to distinguish between a working hackathon messaging flow and stronger identity verification that would be necessary in production.

Working within the hackathon environment

The backend could be tested with simulated provider adapters, but our development environment had only Command Line Tools available, so we could not launch the iOS target in Simulator there. This reinforced the importance of separating backend testing from native-device validation.

Accomplishments that we're proud of

We connected multiple technologies into one coherent safety workflow.

Kinwise brings together Gemini, Backboard, Tiger Data, Spectrum, FastAPI, and SwiftUI around a single experience rather than treating each integration as an isolated feature.

We built a one-call Gemini architecture.

Each eligible message uses one structured generation request, followed by backend safety enforcement. Paused children trigger zero Gemini calls.

We implemented persistent, child-isolated memory.

Backboard gives Kinwise continuity across conversations, helping the assistant remember appropriate learning context instead of starting from scratch every time.

We designed for real family relationships.

Our many-to-many model allows multiple guardians to supervise multiple children equally, with secure invitations and protection against leaving a child without an active guardian.

We connected guardian actions to immediate child-side behavior.

A pause initiated from the guardian experience or through Spectrum iMessage changes the backend access state, and the child's app receives the update through WebSocket.

We treated privacy as part of safety.

Kinwise does not automatically include a child's exact words in high-severity notifications, and its safety policy distinguishes sensitive disclosures from ordinary unsafe requests.

What we learned

Building Kinwise taught us that responsible AI is a systems problem, not just a prompting problem.

A model can classify a message and propose a response, but the application still needs authentication, deterministic policies, data isolation, authorization, and reliable enforcement.

We also learned that persistent AI memory needs boundaries. Remembering a child's science project can make learning more engaging, but not every piece of personal information should become long-term memory.

Another major lesson was that real-time controls must be enforced by the backend. Disabling a button in the UI isn't enough when requests can already be in progress.

Finally, we learned that designing for families requires flexibility. Equal guardian permissions, multiple guardian relationships, and child-specific accounts made our data model more realistic, even though they introduced additional complexity.

The biggest takeaway was that trustworthy AI experiences emerge from how the entire product is designed, not from the AI model alone.

What's next for Kinwise

Kinwise is a DubHacks 2026 MVP, and we see several opportunities to develop it further.

Stronger guardian identity verification

We want to add verified phone ownership, secure confirmation for high-impact messaging commands, email verification, and account recovery. The current Spectrum flow is a hackathon integration, not a production-grade identity verification system.

More advanced child-safety protections

Future work includes independent safety evaluation, adversarial testing, expert-reviewed safeguarding procedures, and more nuanced handling of sensitive disclosures.

Better learning experiences

We want to introduce personalized learning goals, educational activities, progress tracking, and age-appropriate explanations that build on Backboard memory.

Richer guardian insights

We plan to expand the dashboard with useful learning summaries, topic trends, and privacy-aware insights that help guardians support their children's curiosity without unnecessary surveillance.

Production-ready infrastructure

We would add shared pub/sub for multi-instance real-time updates, stronger operational monitoring, provider failure recovery, and comprehensive native iOS testing.

Privacy, consent, and compliance

Before any real-world deployment involving children, Kinwise would need appropriate guardian verification, privacy controls, data retention policies, legal review, and child-safety expertise.

Our long-term vision is to make Kinwise a trusted space where children can explore AI confidently and families can stay meaningfully involved.

Curiosity, with care.

Built With

Share this project:

Updates

Submission history