Piumy▌

The switchboard doesn't reply — it routes and stores.

WhatsApp comes in through a minimal ARM board that never thinks. It receives, stores every message, and exposes a control surface over MCP. Replies come from whoever connects — your own AI agent on a machine with real RAM, or an API. The board just routes and draws a face.

   WhatsApp (dedicated number)
          │
          ▼
    SWITCHBOARD (Go, tiny board) ──► e-paper face (Python)
     · receives / stores  (SQLite)         reads status.json
     · per-chat mode: auto | advanced
     · anti-ban governor · whitelist
     · exposes MCP ───────────────┐
          │ auto                    │ advanced (queue, pull)
          ▼                         ▼
     cheap API                 AGENT over MCP  (your machine)
     (optional)                 Claude / Opus / OpenCode + tools

Every chat has its own rules. New ones arrive ignored.

Piumy never guesses. A brand-new chat lands as ignored — nothing gets answered until you say how. You write the rule for that chat — how to greet, what it may share, when to escalate, the tone, the language — and the connected AI reads it and treats every message there exactly that way. Rules are living: tweak them per chat, anytime.

  new chat   +56 9 ····         → ignored   (nothing is sent)
        │
        │   you set a rule — from the dashboard, or just by
        │   texting your Piumy number, in plain words:
        │   "answer sales questions, share the catalog,
        │    escalate to me if they want to buy"
        ▼
  same chat  +56 9 ····         → advanced ✓   (the AI handles it your way)

Set the rules two ways: from the terminal / dashboard, or straight over WhatsApp — message your dedicated Piumy number and tell it, in plain words, how to handle a contact. Whitelist by default; you're always in control.

It quietly backs up your WhatsApp.

Every message — text, photos, videos, voice notes, stickers — is stored in Piumy's own database as it arrives. If a contact deletes their chat, or you lose your phone, the history is still here: self-hosted, on your board, not locked inside a cloud you don't control. The memory belongs to the system, not to any one app.

It runs on a board you can hold in your hand.

A Raspberry Pi Zero 2 W with a 2.13" e-paper display, always on, sipping power. The face is glanceable across the room — you can tell it's alive without touching it.

Real pwnagotchi kaomoji — eyes that look around.

Not vectors — actual kaomoji, rendered 1-bit. Three eye styles cycle through a gaze loop and blink, and the face reacts to what's happening: a new message, the agent connecting, the battery draining. It settles into a calm, low-power idle when things are quiet. (The face up top is live — that's the real loop.)

Everything, on your LAN — no cloud.

A lightweight dashboard served by the same Go binary (LAN-only, login): the live face, the battery chart, WhatsApp link/QR, the anti-ban kill switch, per-chat rules, rate limits and the router whitelist.

Point your agent at it over MCP.

Piumy exposes its chats, queue and tools over MCP. Drop this into your MCP client (Claude Code, OpenCode) and your agent can triage the queue, read context and reply — at a human pace the governor enforces.

{
  "mcpServers": {
    "piumy": {
      "url": "http://piumy.local:8081/mcp",
      "headers": { "Authorization": "Bearer <token>" }
    }
  }
}

No hardware. No WhatsApp. One command.

The core writes status.json; the file adapter draws it as a face. Run it on your laptop today.

# 1) the core (Go) writes a state
cd core && go run . responding

# 2) render the face
cd ../adapters/display/file
pip install -r requirements.txt
python render.py            # -> display.png

Today, WhatsApp. Tomorrow, your gateway.

Piumy is built to grow. The same little board can carry a microphone, a speaker, buttons, a screen — and reach out to APIs and services on other platforms. The goal is a personal gateway that connects to almost anything, over robust encrypted tunnels — WireGuard-style, braiding hashes instead of trusting the open internet.

I'm a network engineer, so security isn't an add-on here — it's the starting point. And under the wiring there's a simpler why: to make life lighter for people who are stretched thin, and for anyone the everyday is harder on — and to find out how far AI can go, as real help and as company, in a world that keeps getting more chaotic and complex.

Donations are the cornerstone.

I'll be straight with you: without support, this stops here. Piumy is an MVP I've built on my own — and this is the exact point where it freezes for lack of funding. If the idea moves you, pay what you want (even $0 gets you everything — it's open-source and always will be). What you give is literally what lets the next piece exist.