Named after Bough ("Boff"), Johnny English's unflappable handler. A self-hosted, memory-aware personal assistant you talk to over iMessage — it keeps your commitments, triages your inbox, manages your calendar, and reaches out unprompted when something's worth your attention. Your Mac, your keys, your data.
Forked from and built on Aria by Satvik Sethia (AGPL-3.0); the brain (3-tier memory, people model, proactivity engine) is his, the iMessage transport and personalization are the changes here.
Most "AI assistants" are a chat box with a system prompt that pushes you to start a new conversation every time, with context buried in a sea of useless tokens. Boff is built around the parts that make an assistant feel like it knows you and works for you: a layered memory that learns over time, a model of the people in your life, rules you set in plain language, and a background engine that exercises judgment about when to speak. You message it on iMessage, and it lives on a Mac you own.
You: btw I told my dad I'd help him set up his new phone this weekend,
and it's my girlfriend Priya's birthday on June 28
Boff: Both tracked 📱🎂 — helping your dad this Saturday, and Priya's birthday
on the 28th (I'll remind you yearly). What are her favorite flowers, by the way?
…later, unprompted…
Boff: 💡 Heads-up: heavy rain Saturday morning, right when you're set to play
tennis with Dev at 10 — might be worth checking with him about an indoor court.
Boff runs on a Mac, reads new messages from the Messages database, and replies through
Messages.app — so you talk to it from the green/blue bubbles you already use, no separate
app. See IMESSAGE_SETUP.md for the one-time macOS setup. Telegram
remains available as an alternate surface (telegram_bot.py, NOTIFY_CHANNEL=telegram).
Aria doesn't dump everything into one vector store and hope. It uses a three-tier, OS-inspired memory hierarchy that trades off speed and depth the way a computer trades registers, RAM, and disk:
- Tier 1 — Working memory. New facts append to a plain-text scratchpad instantly, with zero embedding latency, so conversation stays fast.
- Tier 2 — Semantic memory. Each night an LLM distills the scratchpad into clean, durable facts and embeds them into a vector store (ChromaDB) for associative recall — and it filters: durable facts about you are kept, operational noise ("sent a digest", "fired a reminder") is discarded so the store stays sharp.
- Tier 3 — Cold storage. When semantic memory grows large, related facts are consolidated into long-form narratives on disk, leaving a single "pointer" vector behind — human-like deep recall that's instant to find and loaded on demand.
The result is memory that gets better over time instead of bloating.
People aren't strings — they're first-class entities with names, relationships, birthdays, and remembered details. Mention "my girlfriend" and Aria doesn't know who that is, it asks her name once, saves it, and never asks again. Tell it a birthday and it silently becomes a recurring yearly reminder. This is the difference between an assistant that stores text about you and one that knows your world.
Tell Aria "from now on, put work events only on my personal calendar" and it saves a standing instruction that's enforced on every future turn — a rule it manages itself (add, refine, revoke) and can't forget. Persistent policy lives where it belongs: always in force, not dependent on it happening to recall a memory.
A background engine doesn't just fire timers — twice a day it looks across your calendar, commitments, and the weather together and decides whether there's one genuinely useful thing to say (a conflict, a good window to clear an aging task, a plan the weather will ruin). Most of the time it correctly says nothing. That restraint is the point: it earns the right to interrupt you.
Mention a promise, a deadline, a reply you owe, or a recurring task — even in passing — and it's captured. Time-specific things ping at their moment; aging ones get a single warm nudge. Telling Aria is the system of record.
| Area | What it does |
|---|---|
| Commitments | Capture promises/deadlines/replies-owed/birthdays from chat; timed & recurring reminders; judgment-based chasing so nothing slips |
| Triage, a once-daily digest (not noisy pings), and reply drafts you approve — via Gmail API or plain IMAP/SMTP (no Google Cloud project needed) | |
| Calendar | Create / edit / delete Google Calendar events, with per-user rules (e.g. mirror to a shared calendar, color-coded) |
| Notes & lists | A full notes system, plus a grocery list that builds itself from a recipe or dish name |
| Research & web | Web search + page reading; an agentic browser that explores a task (e.g. fill a form, find options) and reports back — never spending your money |
| Smart home | Control Matter devices via Home Assistant |
| Knows your day | Weather, package tracking, and a morning briefing delivered to your phone |
| Voice | Send a voice note, get a voice note back — transcribed locally (Whisper) |
Plus the invisible parts: durable conversations that survive restarts, a self-diagnosing health system, and a cost-tiered model router. (There's even a gratuitous skill that auto-confirms Netflix Household emails via headless browser — every project needs one trophy of over-engineering.)
Three thin interfaces — iMessage (phone, imessage_bot.py), a terminal REPL, and a scheduled briefing — all share one agent definition. The agent calls modular skills; a background engine runs polling monitors. Everything routes its LLM calls through one tiered, fallback-aware router. (Telegram is still available as an alternate surface.)
iMessage · REPL · 08:00 briefing
│
agent_core.py ── tiered LLM router ──▶ Opus / Sonnet / Gemini·Haiku
│ (per-task, prompt-cached)
┌──────────┼───────────────────────────┐
▼ ▼ ▼
skills/ 3-tier memory + people engine.py (background)
(email, (scratchpad→Chroma→cold, commitments · email digest ·
calendar, durable conversations insight · health · heartbeat
notes, via SQLite checkpoints) · …
browser…)
Design rationale and the decision record live in docs/:
- docs/architecture.md — memory, agent core, router, engine, repo map
- docs/setup.md — full setup & configuration reference
- docs/adr/ — architecture decision records (why these choices)
Offline test suite: python3 -m unittest discover tests (160+ tests, all network/LLM mocked).
Runs on a Mac you own. Boff's brain runs on your Claude Max subscription via the Claude Agent SDK (authenticated by your local claude login), so there is no API key to buy — just make sure claude is logged in.
Quickest way to try it, no iMessage needed:
cd Boff
bash setup.sh # venv + deps
venv/bin/python3 interact.py # chat with Boff in your terminalFor the phone experience, see IMESSAGE_SETUP.md and run imessage_bot.py. Every optional feature (Gmail/Calendar, smart home, semantic memory) layers in cleanly when you add its config; semantic memory wants a free Gemini key for embeddings, everything else works out of the box.
For 24/7 operation, keep it running under launchd on an always-on Mac (see IMESSAGE_SETUP.md).
Licensed under the GNU AGPL-3.0 (see LICENSE) — you're free to use, study, modify, and self-host it, and any modified version you run as a network service must publish its source.
Commercial licensing: the AGPL's source-disclosure terms are unsuitable for closed/commercial products. Aria is dual-licensed — for a commercial license that lifts the AGPL obligations, contact the author. © Satvik Sethia. To keep that dual-licensing path clean, external contributions aren't being accepted at this time.