Build your own AI second brain on a small box.

The build moment.

The useful version of a personal AI is smaller than most people think. One cheap machine, one memory folder, one message interface, one loop.

What you are building:

• A second brain that knows your notes, briefing docs, decisions, and meeting history.
• Reachable from WhatsApp, Telegram, Slack, or Discord — the apps already on your phone.
• Answers questions on demand. Drafts messages. Condenses incoming reports. Briefs you before meetings.
• Runs on a Raspberry Pi 5 on your desk. Costs about $60 of hardware plus pennies per query of Claude API.
• Built from two open-source pieces glued together: NanoClaw (the harness) and the LLM Wiki pattern (the memory).

The most interesting part is not the hardware. It is the constraint. A tiny always-on box forces the architecture to stay simple: message in, read memory, call the model, write back, update the wiki. The bottleneck is not money or hardware. The bottleneck is knowing what to build. That is what this practice fixes.

The two ideas.

NanoClaw + LLM Wiki = personal AI second brain. Two small ideas, big leverage.

NanoClaw — the harness

NanoClaw is a minimal self-hosted agent harness. Think of it as “Claude Code, but for a single user, always running, with hooks for messaging apps.” You write your own tools, your own connectors, your own personality. NanoClaw runs the loop — receive message → call model → run tools → respond — in 24/7 unattended mode.

The LLM Wiki pattern — the memory

the now-standard observation: LLMs have amnesia between conversations, and dumping raw documents into a vector store (vanilla RAG) is the wrong fix. Better: extract structured knowledge from each source into a wiki of clean, cross-referenced notes. Then at query time, retrieve the relevant wiki pages, not raw source chunks.

Why this matters:

• The wiki compounds. Every source you read makes the wiki smarter. Vector RAG doesn’t compound — it just indexes harder.
• The wiki is readable. You can scan it. You can edit it. You can show it to your accountant. RAG is invisible.
• The wiki cites itself. Each page knows where its facts came from. Provenance is built in.
• The wiki is small. Tens of MB, not the 100 GB of raw source documents that fed it.

Together, NanoClaw is the body, the LLM Wiki is the mind. You build both. Neither one is more than a weekend project on its own. Together they are the “don’t-dare-switch-it-off” system.

The architecture.

Six boxes, six arrows. Once you see it, the rest of this practice is filling in each box.

How a single turn flows

1. You send a message to one of your connected apps: “What did I commit to at the Jakarta summit last March?”
2. The connector forwards it to NanoClaw running on your Pi (or Mac mini).
3. NanoClaw calls Claude with: the user message + a system prompt + a list of tools (read-wiki, search-web, calendar, etc).
4. Claude decides to call read_wiki("Jakarta summit") and gets back the structured page from your wiki.
5. Claude composes the answer.
6. NanoClaw sends it back to your messaging app.

Notice what is not in this diagram: nothing about training, no GPU, no vector database. The LLM Wiki replaces vector RAG. The intelligence is rented from Claude. The orchestration is fifty lines of Python.

Pick the hardware.

Two paths. Start cheap unless you already know you need local inference.

The Raspberry Pi 5 is what we’ll write toward in this practice, because it is the smallest leap of faith. $60 is “why not” money. A Mac mini works identically — we’ll note Mac-specific paths where they differ.

Install & first run.

One file, one dependency, one key. The whole brain in this practice is nanoclaw_demo.py — a single ~330-line script you download and run. You do not need a Raspberry Pi to start; your laptop is the Pi for today.

Step 1 — Get the file

Download the canonical demo brain — code-examples/nanoclaw_demo.py. Right-click that link → Save Link As… into a fresh folder, or pull it with curl:

Copymkdir nanoclaw && cd nanoclaw
curl -O https://d154gd40skpa9c.cloudfront.net/workshops/code-examples/nanoclaw_demo.py

Step 2 — Install the one dependency and set your key

The demo’s only requirement is the anthropic SDK (see its docstring). A virtualenv keeps it tidy:

Copypython3 -m venv .venv && source .venv/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..."   # from console.anthropic.com

Step 3 — First run: see the empty wiki

The script has three subcommands: index, ingest <url>, and query "...". Start with index — it creates the wiki/ folder and prints its (empty) table of contents:

Copypython nanoclaw_demo.py index
# # Wiki Index
# _(empty — feed me sources)_

That is the useful starting point: a brain with a memory folder and no memories yet, ready to learn. Unit 06 fills the wiki; Day 02 makes it earn its keep.

When the install fights back

Four failures account for nearly every stuck install. Symptom on the left, fix on the right.

The LLM Wiki pattern.

Every source the brain reads goes through the same loop: extract entities and claims, file them into named wiki pages, cross-link, log the source. This is the LLM Wiki idea.

Four operations, each one a small skill the brain has:

The wiki itself is just a folder of markdown files. Each file has frontmatter (title, type, sources) and a body. Cross-links use [[wiki-link]] syntax. There’s an index.md that gets updated on every file write.

Copy# Wiki layout — picked because it works in Obsidian, Logseq, plain editor.
wiki/
├── index.md                ← table of contents · updated on every write
├── log.md                  ← append-only journal of operations
├── people/
│   └── public-official-profile.md
├── concepts/
│   └── llm-wiki-pattern.md
├── places/
│   └── jakarta-summit-2024.md
└── meta/
    └── dashboard.md        ← queries over the wiki itself

The wiki is human-readable on purpose. You can drop into Obsidian and edit a page. The brain notices on its next pass. The model and the human share the same source of truth.

The brain in your chat app.

Stop reading the code. Open Telegram first, or WhatsApp if you already have the Business API wired. Type to your brain like you’d type to a smart friend. This is what the rest of the practice is in service of.

Wiring it up — the short version

WhatsApp is the most-used messenger; it is also the trickiest connector (the Business API has a setup process). Telegram is the easiest path to a working brain in 20 minutes, and the conversation experience above is identical. Most participants start with Telegram and graduate to WhatsApp once the brain is earning its keep.

• Telegram — 20 min. Talk to @BotFather, get a token, set TELEGRAM_TOKEN, run the connector.
• WhatsApp — 60 min. Meta Business API (free tier for personal) or Twilio (~$0.005/msg).
• Slack / Discord / Signal — same shape. Each is ~50 lines of glue.

The exact code lives at /workshops/code-examples/telegram_connector.py — about 115 lines. Read it; understand it; then forget it. The connector is plumbing — the value is in the conversations above. It does one thing: a URL you send becomes an ingest; anything else becomes a query against your wiki.

The skill catalog.

Twenty skills the brain can ship with. Each is one prompt template, one tool registration, and one short markdown spec. Add your own — the brain composes.

Twenty skills shown. Twenty more will exist by the time you finish reading this page, because someone in your cohort will have invented one. Skills are composable: the calendar skill calls the wiki, the wiki calls the research skill, the research skill calls ingest, the ingest writes back to the wiki. Adding a twenty-first skill is one markdown file and one tool registration. The compound is the point.

Use case: daily briefing.

The 6am brief is the skill that earns the “don’t-dare-switch-it-off” quote. It is also where the wiki, the calendar, and the watch lists all converge into one message.

Use case: ingest as you go.

Forward anything — a Stratechery post, a PDF, a screenshot of a slide, a voice note from a walk — and the brain files it as structured knowledge in your wiki. After ninety days the wiki has the shape of your professional brain.

Use case: ask the brain.

Now the wiki is rich, the interesting verb is no longer “summarize.” It is “know.” You stop asking the model. You start asking yourself, mediated by the model, against the body of knowledge you’ve been compounding.

Always-on, always-listening.

The reason the system becomes hard to switch off is that it is awake when you are not. At 3am the new report lands. By 3:01 the relevant briefing is filed. By 6am your morning brief includes it.

What “always-on” requires in practice:

• The Pi runs as a service. Systemd on Pi, launchd on Mac. Auto-restart on crash. Auto-start on boot.
• Persistent network. Wired Ethernet if you can. Wifi with a static lease if you can’t.
• Persistent storage. The wiki lives in a git repo. NanoClaw commits after every ingest. If the SD card dies, you restore from GitHub.
• Inbound access. For webhook-style connectors (Slack, WhatsApp Business), you need a public URL. Cloudflare Tunnel is the no-cost path. ngrok works as a paid alternative.
• Observability. A daily “health” ping to yourself: messages received, ingests performed, errors. If you didn’t get the health ping, the Pi is down.

Copy# /etc/systemd/system/nanoclaw.service
[Unit]
Description=NanoClaw second brain
After=network.target

[Service]
Type=simple
User=you
WorkingDirectory=/home/you/nanoclaw
Environment=ANTHROPIC_API_KEY=sk-ant-...
Environment=TELEGRAM_TOKEN=...
ExecStart=/home/you/nanoclaw/.venv/bin/python telegram_connector.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now nanoclaw. The Pi reboots. NanoClaw comes back. The wiki is intact. Your brain didn’t skip a beat.

Imagine.

This is not science fiction. It is a small loop, a memory folder, and enough discipline to keep feeding it. Imagine what you can build once the first version is running.

Six things people build using exactly this pattern:

• A founder’s investor brain. Every meeting note, every cap table, every pitch deck. “What did I tell Sequoia about churn last September?”
• A clinician’s case brain. Every patient encounter (anonymized), every paper read. “Have I seen a presentation like this before?”
• A teacher’s student brain. Every student observation, every parent conversation. “Who in my class is at risk this semester?”
• A parent’s family brain. Every conversation, every milestone, every doctor’s note. “What was the name of the violin teacher she liked?”
• A writer’s ideas brain. Every thought worth saving, every draft, every published piece. “What did I almost finish last year that’s worth picking up?”
• A team’s shared brain. A wiki shared across a small company. Same architecture, multi-user. The Pi sits in the office.

The pattern is general because the human need is general. We all carry around context that we forget. Our jobs would be easier if we had a careful colleague with infinite memory who only spoke when asked.

The pattern makes the important point obvious: this is two evenings of work. The bottleneck was always knowing what to build. The first working loop is the field guide.

Your closing exercise

1. Today: order the Pi (or pull a Mac mini out of a drawer).
2. Saturday morning: install NanoClaw, wire up Telegram, send your first message.
3. Saturday afternoon: ingest five sources you read this week.
4. Sunday: schedule the daily briefing.
5. By Sunday night: you will own a second brain that will get more useful every day for as long as you keep it on.

A small box, a real memory, and a loop you keep.

End · Practice 05 · NanoClaw on Pradhya