a creative tablet OS for kids, powered by AI
Skill · Architecture · Marketplace · Drift · Skill Guide · Discussions
kids are creative. they have ideas all day long. but most of the tools we hand them are just consumption devices. watch this, play that, scroll through whatever.
KidBlocksOS flips that. it's an OS where the only thing you can do is create.
a kid opens a studio, says what they want to build ("a penguin game where I jump on ice"), and the system builds it. either instantly from a template or through an AI agent that generates a full interactive app from scratch. the kid plays it, sees how it works through a visual programming layer, and saves it to their library.
no app store. no ads. no tracking. no internet required for the core experience.
a Raspberry Pi is the brain. OpenClaw is the agent framework that runs natively on the device, handling all AI generation through its local gateway. XMTP is the messaging layer powering the peer-to-peer marketplace. payments settle in USDC on Base. the OS ships with OpenClaw installed and a dedicated agent configured out of the box.
this is a proof of concept. we're releasing the brain (the OpenClaw skill that powers generation) and full documentation on how everything fits together.
| included | open source |
|---|---|
| Imagination Engine Skill (OpenClaw) | ✅ |
| Architecture docs | ✅ |
| Skill usage guide | ✅ |
| OS shell and UI | no |
| pre-built image | no |
| template engine | no |
the skill is the interesting part. it's the full instruction set that teaches an OpenClaw agent to generate kid-safe interactive HTML5 apps from natural language. install it into any OpenClaw workspace and your agent knows how to build for kids.
we open sourced it because parents and educators should be able to read exactly what the AI is being told to do. and because the community can make it better.
the skill lives at skill/kidblocks-engine/SKILL.md. it's an OpenClaw agent skill that covers six creative studios with 40+ generation patterns.
|
🎮 Games platformer catcher maze whack-a-mole pong runner memory target |
📖 Stories branching narrative mad libs comic strip adventure |
🎵 Music piano beat maker sequencer sound board theremin music box |
🎨 Art freehand draw stamps color mixer pixel art kaleidoscope fireworks patterns |
🔬 Science solar system ecosystem weather sim body explorer chemistry dinosaurs gravity |
🔧 Tinker calculator clock/timer flashcards fortune teller dice roller palette gen animations |
three layers. not one.
| layer | where | what it does |
|---|---|---|
| client filter | before AI | regex catches violent, sexual, and inappropriate terms |
| skill rules | inside the OpenClaw agent prompt | explicit ban list plus safe reinterpretations |
| sandbox | after generation | iframe with allow-scripts only, no DOM escape possible |
the reinterpretation part matters. kids say stuff like "kill the enemies" because that's what they've seen in games. the AI doesn't refuse, it redirects:
| what the kid says | what gets built |
|---|---|
| "kill the enemies" | "help the friends" |
| "gun game" | "water balloon launcher" |
| "scary monster" | "friendly monster who needs help" |
| "war" | "pillow fort battle" |
the skill adjusts output based on the child's age.
| 5 to 6 | 7 to 8 | 9 to 10 |
|---|---|---|
| no fail states | gentle progression | real challenge |
| one choice per page | two to three choices | complex branching |
| very short sentences | paragraph length | longer narratives |
| simple interactions | multi-step | strategy elements |
this is an OpenClaw skill. you need OpenClaw installed.
# install the skill into your OpenClaw workspace
mkdir -p ~/.openclaw/workspace/skills/kidblocks-engine
cp skill/kidblocks-engine/SKILL.md ~/.openclaw/workspace/skills/kidblocks-engine/
# then tell your agent:
# "read the kidblocks-engine skill and make a dinosaur platformer for age 7"the agent reads the skill, follows the patterns and safety rules, and returns a JSON object with a complete HTML5 app and visual programming data.
on KidBlocksOS itself, the Electron shell talks to the local OpenClaw gateway through the Chat Completions API. the agent is preconfigured with the skill during first boot. kids never see any of this, they just describe what they want and it appears.
full details in the skill guide.
full breakdown: docs/architecture.md
kid says something
|
v
content safety filter (regex, blocks bad stuff)
|
v
template match? ----yes----> instant build (offline, no AI needed)
|
no
|
v
OpenClaw agent reads kidblocks-engine skill
|
v
agent generates complete HTML5 app
|
v
runs in sandboxed iframe (allow-scripts only)
|
v
kid plays their creation
a Raspberry Pi runs the whole thing. OpenClaw is installed natively and starts on boot as a systemd service. the gateway runs on localhost, never touches the open internet. 13 built-in templates cover the common cases without needing the agent at all.
- pin protected settings (hashed, not stored in plaintext)
- configurable screen time limits with break reminders
- bedtime enforcement that locks the device on schedule
- three safety levels: strict (no AI), standard (AI plus filtering), creative (9+)
- full activity log of every AI interaction, viewable behind the parent pin
| what | how |
|---|---|
| process isolation | dedicated user, minimal permissions |
| systemd hardening | ProtectSystem, NoNewPrivileges, ProtectKernelTunables |
| electron | context isolation, no node integration, CSP headers |
| network | OpenClaw gateway on localhost only, random auth token |
| storage | parent pin hashed with scrypt, filesystem permissions |
| generated content | sandboxed iframe, three layer content filter |
proof of concept. actively being built.
- six creative studios with 40+ patterns
- 13 offline templates
- OpenClaw agent with dedicated skill
- first boot setup wizard (14 steps, 10 languages)
- Lumen voice guide (ElevenLabs TTS through every wizard step)
- screen time, bedtime, break reminders
- content safety (three layers)
- parent pin (hashed)
- activity logging and guardian report
- voice input
- TTS output
- visual programming layer
- peer-to-peer marketplace over XMTP
- USDC payments on Base (kids see "coins")
- device wallet (self-custody, created during setup)
- parental spend limits and listing price caps
- marketplace watcher daemon (auto-accepts new devices)
- encrypted catalog delivery via XMTP DMs
- WiFi and volume widgets in setup wizard
- invite-based device auth (one-time codes, wallet signature verification)
- device provisioning tool (SD card or remote)
- mission control dashboard (maintainer web UI on port 8090)
- parent bridge via XMTP (Convos app integration, QR invite flow)
- marketplace purchase flow (buy via group, on-chain verification, app delivery)
- Drift: encrypted proximity exchange over BLE (StreetPass for KidBlocks tablets)
- OTA updates
- accessibility
- multi-device sync
kids build apps. kids sell apps. the marketplace is a peer-to-peer app store where every developer is under ten and every transaction settles on chain.
a parent walks through setup. the device generates a wallet, registers on XMTP (an encrypted messaging network), and sends a DM to the marketplace master wallet. a watcher daemon running on a Raspberry Pi picks up the request, adds the device to the marketplace group, and replies with the full app catalog over the encrypted DM.
why a DM and not the group? XMTP is end-to-end encrypted. new members cannot read messages sent before they joined. the watcher packages the current catalog and delivers it directly.
there are no servers, no APIs, no databases, no accounts. just wallets talking to wallets over encrypted channels. the XMTP group is the marketplace.
kids see apps with coin prices in a shop. they browse by studio (games, art, music, stories, science). under the hood, 100 coins equals 1 USDC. the conversion happens in the UI. all on-chain values are real USDC on Base.
kids never see wallet addresses, transaction hashes, gas fees, or dollar amounts. parents configure real USDC spend limits in the settings screen.
during setup, the OS generates a wallet on the device. the private key never leaves the device. the device registers on XMTP, sends an encrypted DM to the marketplace master wallet, and receives the catalog back in seconds. no accounts, no sign-up, no email. one encrypted DM and the device has a full marketplace.
- buyer sends a payment request to the group
- seller responds with an invoice
- buyer sends USDC directly to seller (one on-chain transaction)
- buyer broadcasts the transaction hash
- seller verifies on chain and delivers the app over XMTP
- seller's device sends a platform fee (one on-chain transaction)
six messages. two on-chain transactions. no middleman.
full documentation: marketplace / payment layer / XMTP messaging
when two KidBlocks tablets are near each other, they talk. no internet, no setup, no buttons to press. just Bluetooth.
we call it Drift. it runs in the background as a system service. each tablet advertises its presence over BLE and scans for others. when two devices find each other, they do a cryptographic handshake and swap encrypted profile cards. the whole exchange takes about three seconds.
the profile card has the kid's display name (chosen during setup, never a real name), their buddy character, their stats (encounters, apps bought, apps sold, coins earned), and a catalog of apps from their library. everything is signed with the device wallet so it cannot be faked.
the encryption is real. not toy crypto. Drift uses the same cryptographic primitives as XMTP's MLS ciphersuite: X25519 for the key exchange, ChaCha20-Poly1305 for authenticated encryption. ephemeral keypairs are generated fresh each boot and discarded after the exchange, so there is nothing to compromise later. the only difference from XMTP is the transport layer. where XMTP sends messages over the internet through gRPC, Drift sends them over Bluetooth Low Energy between two devices standing next to each other.
we built it this way on purpose. the XMTP team picked the right cryptographic primitives for encrypted messaging between wallet-identified devices. Drift uses those primitives over a transport that works with zero infrastructure. a kid at a park with no WiFi can still exchange cards with the kid on the next bench.
there is an eight hour cooldown per device, same as the original StreetPass on the Nintendo 3DS. passive BLE sniffers see nothing useful. parents can disable Drift entirely in settings.
Drift is a separate library. source and documentation: github.com/sleepycompile/drift
a notification pops up: "you drifted past CosmicFox." they tap it and see a card with the other kid's buddy character, their stats (encounters, apps bought, apps sold, total volume traded), and a list of apps from their library. over time they build a collection of encounters. there is a counter on the home screen. every pass is a small event.
the stats are real. they come from the device's marketplace activity log, project directory, and encounter history. apps listed, apps bought, coins earned, projects built. all pulled live and refreshed every five minutes.
the goal is the same as StreetPass. make the real world matter. give kids a reason to bring their tablet places. turn proximity into something that feels like discovery.
we need help with:
- new patterns for the studios (game types, instruments, science sims)
- safety rules (better filtering, more reinterpretations)
- age adaptation (smarter difficulty scaling)
- localization (translating prompts and safety rules)
- testing across different OpenClaw configurations
see CONTRIBUTING.md for details.
the imagination engine skill and all documentation are MIT.
the OS shell, templates, and image are proprietary.
built with 🧱 on Raspberry Pi · runs on OpenClaw
skill · architecture · marketplace · drift · guide · discussions
