Skipper · an agentic app platform for your family

What it does for you

One assistant. Every part of running the house.

Skipper is built around the way a household actually works: several people, lots of small commitments, and things that fall through the cracks. It plans, organizes, watches and remembers for each person, across every device.

Plans your day & week

Goals, projects and tasks, reminders, schedules and a to-do list, pulled together into a daily Prioritize view with three focus slots for what matters today.

Knows the whole family

Every member has their own login, role, reminders, focus and conversation. Parents and kids see what's theirs. "Remind me" means the person who asked.

Runs the kitchen

A family recipe collection with scaling and a cooking mode, plus a meal-idea library you can filter by effort, cuisine and ingredients: "something low-effort that uses potatoes."

Keeps the kids on track

Chores rotate across the kids with a morning list and check-off, and bounties let parents post paid jobs that kids complete for credit.

Looks after the house & cars

Home maintenance, appliances and insurance; vehicle service history and issues; an item locator for where things are stored; smart-home control through Home Assistant.

Tracks family health

Medications with refill reminders, recurring treatments, a medical event journal and lab results with trend history, for everyone in the house.

Researches for you

"Skipper, research the best way to insulate an attic in a cold climate." A while later you get a sourced write-up, filed in your documents and linked to the right project.

Remembers everything

Conversations and app records become long-term memory, then get organized into readable documents. The longer you use it, the more it knows about your family.

Speaks up on its own

Reminders fire on time, the project manager checks in on stalled work, and notifications reach you on the web, your phone, Discord, Pushover or email. It stays quiet when there's nothing new.

The apps

Every part of your household, one app away.

Each app has its own data, its own screen on the desktop and its own tools the assistant can use, so anything you can click you can also just ask for. These ship with the platform.

Goals · Projects · Tasks

Nested goals, projects and tasks with owners, due dates and dependencies. Optional two-way sync with Trello boards.

Prioritize

Three focus slots and a backlog that pulls automatically from tasks, reminders, schedules and to-dos.

Reminders & Timers

One-shot and recurring reminders, plus quick kitchen and pomodoro timers.

Schedules & Calendar

Recurring schedules with full repeat rules, shown on one calendar with reminders, tasks and to-dos.

Lists & To-Do

General lists and a "when I have time" to-do list for each person, with gentle nudges.

Documents & Brainstorming

A markdown editor with AI-assisted revisions, and an idea board with statuses, tags and flowcharts.

Recipes & Meals

Recipes with ingredients, steps, photos, scaling and cooking mode. A meal library to answer "what's for dinner?"

Chores & Bounties

Rotating chores with a daily list for each kid, and a job board where kids earn credit for extra work.

Home

Maintenance tasks, appliances, insurance and home issues in one place.

Automation

Home Assistant bridge: lights, switches, sensors and a low-battery finder, by click or by voice.

Auto

Vehicles, service records, issues, valuations and periodic condition reports.

Locator & Finder

Track where physical things are stored, with photos, and search across every app at once.

Medical

Medications and refills, treatments, visits, surgeries and lab results with trends.

Weather

Current conditions, hourly and 10-day forecasts for your home. No account or key needed.

Email

Connect Gmail and set inbox rules (label, archive, mark read) with a log of everything each rule did.

Folders, Images & Timeline

Organize anything into folders, keep a photo gallery, and see everything that changed across every app in one feed.

Calculators & Arcade

Scientific, compound-interest and loan calculators, and a small arcade of games including solitaire.

Routines

Save a prompt and a schedule, and Skipper runs it for you: a Monday-morning family summary, a weekly check on the garden.

Issues · Thinking · Jobs · System

Report a problem or request a feature from inside the app, see what Skipper is working on in the background, and manage backups, members and settings.

Optional apps

Install more by cloning an app into the apps/ folder and restarting. Or write your own.

Scriptures Bible reader

Scrum family standup

Homeopathy remedy inventory

Anime stream + watch history

The desktop

Everything in one place.

Skipper home screen — all apps in one view

Home screen — every app, one click away

Voice

"Hey Skipper." "Done."

Voice is built to feel like talking to someone in the next room. Ask, and you get the shortest useful answer in a calm, everyday tone. No repeating your question back, no offers to do more. Turn the lights off and you hear one word.

01 / WAKE

On-device wake word

A small voice satellite (a Raspberry Pi with a speakerphone, or any PC) or the Android app listens for "Hey Skipper" locally. Nothing goes to the cloud until you say it.

02 / LISTEN

No waiting for the beep

Audio from just before and during the chime is kept, so you can talk straight through it.

03 / WHO

Knows who's talking

Optional speaker identification tells family members apart, so "remind me" and personal data follow the right person.

04 / ACT

Same brain, same tools

The satellite is a thin client. The platform holds the memory, the tools and the keys, and runs the conversation with OpenAI's realtime voice models.

05 / ANSWER

Short, calm answers

If a lookup takes a moment you hear "Checking." Then the answer, and nothing more.

Integrations

It plugs into the systems you already live in.

Every integration is optional and off until you add it. They all feed the same assistant and the same memory.

Discord

Chat with Skipper in DMs or channels, and get notifications there.

Home Assistant

Lights, switches, sensors and scenes, by click, chat or voice.

Trello

Keep goals, tasks and checklists in sync with your boards.

Gmail · Resend

Inbox rules on incoming mail, and outbound email for notifications and reports.

Mobile push · Pushover

Notifications to the Android app or through Pushover.

Brave Search

Web search for chat answers and research jobs.

Google Drive

Automatic off-machine backups of your database.

Printers

Print documents and recipes to a real printer on your network.

Away from home

Reach Skipper from anywhere through Cloudflare Tunnel, Tailscale or your own domain.

In use

A real desktop, with the assistant beside it.

Every app opens in the web desktop with chat alongside, so you can click or ask, whichever is faster.

Goals with chat alongside

To-Do list

A Discord DM with Skipper

Under the hood

How it works.

The rest of this page covers the technical side: one mind behind every surface, how apps plug in, how tools are chosen, how memory is built and how background work runs.

Architecture

Many surfaces. One mind.

Skipper is a single entity with one continuous memory, whether you type on the desktop, speak to a satellite, message it on Discord or tap the phone app. Like a person with a phone at each ear, it talks to each family member individually but is still one mind.

One Mind

Voice

Web Desktop

Android

Discord

App Tools

Memory

One running log, filtered per person.

Every message, reminder, nudge and background result is written to a single ordered log in Postgres. Your conversation on the desktop is just a view of that log filtered to you. Nothing said on one surface is lost on another.

The log is also the attention queue. When something needs a response, whether a message from you or an alarm from an app, Skipper picks it up in order. Work for different people runs side by side, but each person's conversation happens one turn at a time, so it never talks over itself.

Every surface and every background job builds its context the same way, from the same log and memory. That's why a proactive nudge knows what you said in chat this morning.

Three layers of the one mind

The voice

Everything that speaks to the family: chat on every surface and the project manager that checks in on goals. One mouth per conversation.

The hands

Longer work Skipper does on its own: research, drafting, working through tasks on goals you've given it. Hands never talk to you directly. When a result is worth sharing, they raise it and the voice tells you.

The subconscious

Background upkeep: digesting conversations into memory, organizing memories into documents and summarizing older history. It never speaks; it keeps what the mind draws on in good shape.

The project manager

Goals, projects and tasks aren't a passive list. A project manager reviews them on a daily rhythm, looks for work with no date, no owner or no movement, and checks in with the right person. It suggests next steps from what you're already doing and never invents work you didn't ask for.

New installs start with a "Get started with Skipper" goal. The project manager walks you through introducing your family, configuring settings and trying each app, and closes items out as you do them.

Your choice of model

Pick an AI provider and model in the web UI during setup. OpenAI is the default and fully tested, with separate tiers for a smart model and a fast model and adjustable reasoning effort. Connectors for Anthropic, Gemini, DeepSeek, Kimi, Qwen, Grok, Mistral, Llama and local models through Ollama are available as experimental options.

Apps don't talk to a model directly. They go through the platform, so switching providers changes every app at once.

The app platform

Apps are plugins. Adding one is adding a folder.

Skipper isn't a monolith with features hard-coded in. The platform discovers apps when it starts and wires each one into the assistant, the API, the database and the desktop. The platform never depends on a specific app, and apps talk to each other only through the platform.

What's in an app

Every app lives in apps/<id>/. Most files are optional; the loader picks up whatever is there.

manifest.yaml. Name, entity types, settings, keywords that route requests to it, and help text.
tools.py. Functions the assistant can call.
routes.py. A REST API mounted at /api/apps/<id>/.
ui/. The app's React screen on the desktop.
migrations/. SQL for the app's own Postgres schema.
handlers.py. Event subscriptions, background jobs and skills.

Each app keeps to itself

Every app gets its own schema, app_<id>. The loader refuses foreign keys that reach into another app's tables, so apps share data through platform services such as links, events, notifications and memory. If an optional app fails to load, it's marked degraded and the rest of Skipper keeps running.

# apps/meals/manifest.yaml — abbreviated id: meals name: Meals description: Meal idea generator + library. entity_types: - prefix: "ml" name: Meal table: meals tool_category: description: Browse and manage meals. keywords: - what's for dinner - meal ideas - something with chicken # apps/meals/tools.py def find_meals(filters: str) -> str: """Find meals matching filter criteria.""" ... # callable by the assistant

The same structure is used by the apps that ship with Skipper and by apps in their own repositories, so anyone who can write a manifest and a few Python functions can give their family a new capability.

The tool router

Hundreds of tools. Only the right ones in play.

Handing a model every tool at once makes it slower and more easily confused. Skipper's router reads each message for keywords and entity references, picks the matching tool categories, and hands the model only those tools, along with the matching app's guidance.

How it routes

Tools are grouped into categories, one or more per app. Each category declares its tools and the phrases that should bring it in. A message that touches two areas ("remind me to buy chicken for Tuesday's dinner") pulls both.

A few meta-tools are always present, so if the assistant needs something outside the current set partway through a turn, it asks for it and keeps going. In a voice session, "open the recipes app" narrows the tools to that app.

# a turn arrives user: "remind me at 4 to call the vet" router: keywords → [reminders] router: tools → create_reminder, list_reminders, snooze, ... router: guide → reminders guide // every other category stays out of the prompt skipper: create_reminder("call the vet", "16:00") skipper: "Done."

Memory

Three sources. Background digestion. Semantic recall.

Memory isn't a side cache. Conversations, app records and things you ask it to remember all flow into one long-term store, so the next conversation already knows what changed.

Source 1

Explicit memories

"Remember that Sam is allergic to peanuts." Tagged, linked to the people and records it's about, and traceable to the conversation it came from.

Source 2

App records

When a recipe, service record or reminder changes, a digest of it goes into memory, so "when did we last rotate the tires?" just works.

Source 3

Chat facts

After each conversation, a background step pulls out the facts worth keeping. It runs after the reply is sent, so you never wait for it.

Auto documents

From memories to a self-organizing knowledge base.

Memories don't just pile up. A background process reads new memories, sets aside the operational noise, and decides what's worth writing down. It creates and updates readable documents (topic indexes, reference notes, running journals) in a folder tree you can browse in the Folders app.

Recall is hybrid: vector similarity (Postgres + pgvector) finds candidates, then tags, people and linked records narrow them down. Structured data also stays first-class in each app, so it's queryable and visible on screen, not only recalled.

# Self-organizing folder tree Folders/ ├─ Health/ │ ├─ Allergies & medications.md │ └─ Lab results — running notes.md ├─ Home/ │ ├─ Maintenance lessons.md │ └─ Appliance warranties.md ├─ Kitchen/ │ └─ Family favorites.md └─ Topic index.md # Each document evolves over time. # The process decides when to create, # update or reorganize, and ignores # its own writes on the next pass.

Background work

A real job system. Concurrent. Cancellable. Observable.

Skipper doesn't only respond; it does work. Research, document revisions, printing, routines and scheduled jobs all run on one engine, whether you started them, the assistant did, or a schedule did.

What makes it dependable

Limits by job type. Research can run two at a time while printing runs one.
Clean cancellation. Cancel a job partway and it stops safely.
Live progress. The Jobs app shows each job's progress and log as it runs.
Survives restarts. Job state lives in Postgres; after an update or reboot, work picks up where it left off.
Self-paced background loops. Background work checks in more often when busy and backs off when there's nothing to do.
Your conversation comes first. Background thinking yields while you're talking to Skipper.

# register a handler register_handler("research", run_research, max_concurrent=2) register_handler("print", run_print, max_concurrent=1) # submit from chat, a schedule, or the UI submit_job("research", config={ "query": "insulating an attic in a cold climate", "link_entity_id": "p-attic-project", }) # inside a handler async def run_research(job, ctx): ctx.update_progress(10, "Searching the web...") if ctx.is_cancelled(): return ...

Example · research

"Skipper, research the best way to insulate our attic."

You ask and go on with your day. When it's done, you get a sourced document filed with the right project, and Skipper lets you know.

01 / PLAN

Plan the searches

The request is split into several targeted search queries.

02 / SEARCH

Gather sources

Web search results are de-duplicated across queries and ranked.

03 / READ

Read each page

Pages are fetched, stripped of navigation and clutter, and summarized against your question.

04 / WRITE

Write it up

The summaries become one sectioned document with citations.

05 / DELIVER

File and notify

It's filed in your documents, linked to the goal or project, remembered, and you're told it's ready.

And it can revise.

Ask for more ("go deeper on vapor barriers and add a section on doing it yourself versus hiring it out") and a revision job runs new searches and rewrites only the sections that need it, instead of starting over.

Details that matter

Quick, quiet and careful.

Small decisions that add up to an assistant people actually want to use every day.

Focused tool sets

A handful of relevant tools per turn instead of hundreds, so answers are faster and more accurate.

Direct tool calls

Tools run in-process with next to no overhead.

Memory after the reply

Fact extraction runs once you already have your answer.

Notification cooldowns

Skipper won't nag about the same thing again until something has changed.

Delivery you can trust

Notifications go to each person's preferred channel and report what was actually delivered.

Names, not IDs

Internal record IDs stay internal. You see titles and names.

Blockers first

Goals, projects and tasks are ordered by their dependencies, so blockers never sit below the work they block.

Talk through the chime

Voice keeps the audio from before the chime, so there's no waiting for a beep.

Backups built in

Database and project backups on a schedule, locally or to Google Drive.

Updates from the app

When a new version is ready, update from inside Skipper. Database migrations run on their own.

Run it yourself

Your hardware. Your data.

Skipper is open source under the MIT license. Clone it, run one command, and finish setup in your browser.

Getting started

One launcher. ./skipper.sh (or skipper.bat on Windows) asks whether you want Docker or a native install, writes your configuration and starts everything.
Runs almost anywhere. Linux, macOS, Windows (with WSL) or a Raspberry Pi 5 booting from an SSD.
Guided first run. An onboarding wizard sets up your account, timezone and AI provider, then you add the rest of the family.
Always on. skipper service install starts it with the machine.

Privacy

Skipper sends nothing to us. No telemetry, no crash reports, no version pings. Your data lives in your own Postgres database and goes only to the AI provider you choose and the integrations you turn on.

# get it git clone https://github.com/familycaptain/skipperbot-platform.git cd skipperbot-platform # start it (Docker or native — it asks) ./skipper.sh # then open http://localhost:8000 # later skipper update skipper service install

Skipper on GitHub

Built with

The stack.

Platform

Python 3.12FastAPIasyncioWebSockets MCPPostgreSQL 18pgvectorDocker OpenAI Responses APIOpenAI Realtimediscord.py

Web

React 19ViteTailwind CSS 4CodeMirror 6 RechartsHLS.jsPWA

Voice & mobile

Picovoice PorcupineRaspberry PiResemblyzer KotlinJetpack ComposeFirebase Messaging

Integrations

Home AssistantTrelloGmailResend PushoverBrave SearchGoogle Drive Cloudflare TunnelTailscale