Pebble

A dedicated AI learning device for kids. Voice-first. Parent-managed. Built solo at TreeHacks 2026 in 36 hours.

Why

30% of US teens use AI chatbots daily. A third of them prefer talking to AI over talking to people. Common Sense Media found that every major chatbot fails to safely handle young people's mental health. A 14-year-old died by suicide after bonding with an AI companion.

Kids are already using AI unsupervised, at scale, and nothing out there was built for them. Parents have no visibility. No control. The "kid-safe" AI tools that exist are dumbed-down wrappers that children outgrow fast.

Pebble is a purpose-built Android device that runs a voice-first AI tutor, managed entirely by parents. It's not an app. It's an appliance for learning.

What It Does

For kids: Tap the orb, ask a question, hear an answer. Pebble connects to Canvas LMS, knows your courses and deadlines, and teaches through Socratic questioning and interactive quizzes. It doesn't give answers. It teaches.

For parents: A real-time web dashboard showing every conversation, every study session, every time the AI redirected away from something unsafe. Set the age group (elementary, middle, high, college+), block specific topics, set daily time limits. The dashboard isn't a token gesture. It's the product's other half.

For college students: The same powerful tutor, minus the parental guardrails. Full Canvas integration, guided study sessions, mastery tracking, proactive deadline alerts. Self-managed.

Safety

This is the part I care about most. If you're building AI for children, safety can't be a system prompt disclaimer. It has to be architectural.

Pebble uses three layers:

1. Heuristic detection - After every response, the backend scans for redirect phrases as a fallback, catching safety events the model didn't explicitly flag.
2. Explicit tooling - The model can call flag_safety_redirect to formally log when it redirects away from a blocked topic, with structured metadata that flows to the parent dashboard.
3. Emergency lockout - For critical violations, emergency_lock_device immediately locks the device, flags the conversation for parent review, and pushes a real-time alert. No further interaction until a parent unlocks it.

Every interaction is also shaped by age-calibrated guardrails. A 7-year-old gets simple words, lots of encouragement, one concept at a time. A 16-year-old gets full vocabulary, Socratic questioning, college prep focus. Parents can block custom topics on top of the defaults. And all of this is enforced before any model delegation happens, so safety guardrails hold regardless of which model is doing the work.

Architecture

Three components:

Android App (Kotlin/Compose)          Backend (Node.js/TypeScript)          Web Dashboard (React)
├── On-device ONNX Whisper STT        ├── Express API server                ├── Parent auth
├── Voice orb UI (4 states)           ├── Claude agentic tool-use loop      ├── Child device linking
├── Interactive quiz overlay          ├── Canvas LMS proxy                  ├── Activity feed
├── Study session progress            ├── Multi-model delegation            ├── Progress tracking
├── Drawing canvas + vision           ├── Web scraper (external syllabi)    ├── Safety redirect log
├── Kiosk mode lockdown               ├── Parent account system             ├── Guardrail settings
└── ElevenLabs TTS (system fallback)  ├── Safety enforcement pipeline       └── Proactive alerts
                                      ├── PostgreSQL persistence
                                      └── SSE streaming

Privacy: Speech recognition runs entirely on-device with Whisper. No child's voice ever leaves the phone.

Model delegation: Claude Haiku handles primary chat (fast, cheap). It delegates to Sonnet for moderate complexity and Opus for hard problems. GPT and Gemini are also available via OpenRouter. Haiku always acts as the safety gatekeeper before any delegation.

Canvas integration: Courses, assignments, grades, announcements, modules, pages. External course websites (like math department sites that Canvas doesn't know about) are detected and scraped automatically.

Voice Conversation Flow

1. Kid taps the orb. Audio recorded at 16kHz mono.
2. ONNX Whisper transcribes on-device. Transcript sent to backend.
3. Claude runs an agentic tool-use loop (up to 10 iterations, 20+ tools available).
4. SSE streams back: tool status, text deltas, quiz events, study session updates, safety events.
5. Response spoken via ElevenLabs TTS (or system TTS as fallback).
6. Orb transitions: idle -> listening -> thinking -> speaking -> idle.

Study Sessions

Say "help me study for math" and Pebble pulls real assignments from Canvas, identifies weak topics from past mastery data, and walks you through active recall. Interactive quizzes with instant grading. It remembers what you got wrong last time and comes back to it. Mastery scores persist across sessions.

Running It

Backend

cd backend
npm install
npm run db:migrate    # PostgreSQL migrations (idempotent)
npm run dev           # Development server with verbose logging

Needs a .env with: ANTHROPIC_API_KEY, DATABASE_URL (PostgreSQL), PORT (default 3001). Optional: OPENROUTER_API_KEY for GPT/Gemini delegation.

Android

Open android/ in Android Studio. Set BACKEND_URL, ELEVENLABS_API_KEY, and ELEVENLABS_VOICE_ID in android/local.properties. Default backend URL for emulator: http://10.0.2.2:3001.

Web Dashboard

cd web
npm install
npm run dev           # Vite dev server
npm run build         # Builds to dist/ (served by backend as static files)

Demo UI (Splash Site)

cd demo-ui
npm install
npm run dev

Stack

• Android: Kotlin 2.1, Jetpack Compose, ONNX Runtime, Retrofit, minSdk 26
• Backend: Node.js, TypeScript (strict), Express, PostgreSQL, Anthropic SDK, Claude Agent SDK
• Web: React 19, TypeScript, Vite, Tailwind CSS
• AI: Claude (Haiku/Sonnet/Opus), GPT-4o, Gemini 2.5 Pro via OpenRouter
• Speech: ONNX Whisper tiny.en (on-device STT), ElevenLabs (cloud TTS)

Background

This started as a voice-first study companion for college students. Canvas integration, on-device speech recognition, cloud inference for tutoring. That was the plan going into TreeHacks.

Then, past 1 AM on Sunday, with submissions due at 9:30 that morning, I pivoted to children. I added a full parent management system, a real-time web dashboard, age-calibrated guardrails across four tiers, content blocking, device locking, and a multi-layered safety architecture. The college experience stayed intact as the top tier, but the product became something bigger: an AI learning device that parents can actually trust.

Building for kids forces you to think harder. When your user is a 7-year-old, "it usually works" isn't good enough.

Built With

Built solo by Zane St. John at TreeHacks 2026 (Stanford, Feb 14-16).

License

MIT. See LICENSE.