Verne

Chapter I - The Idea

Why build your own agent?

Every AI assistant I tried forgot me the moment the chat window closed. Verne doesn't. He runs continuously on my own machine, holds a growing knowledge graph of my work and priorities, and reaches me where I already am - my messaging apps.

The inspiration came from an unexpected place: Singapore's Foreign Minister Vivian Balakrishnan, who built and runs his own personal AI agent on a Mac mini at home using the open-source NanoClaw framework. If a sitting cabinet minister can self-host a daily-driver AI agent, so can a founder.

Verne is my implementation of that idea - extended with persistent semantic memory, document integrations, and a two-agent architecture that separates business from personal life while sharing one brain.

Chapter II - The Voyages

What Verne does

VOYAGE 01

Strategic Sparring

Business strategy, positioning, and decision support - with a persona tuned to challenge assumptions and push back. No flattery, no filler. Truth over comfort is written into his system prompt.

VOYAGE 02

Memory That Compounds

A semantic knowledge graph stores facts, decisions, contacts, and timelines after every conversation - and recalls them before each reply. Embeddings run locally via Ollama. Nothing leaves the machine.

VOYAGE 03

Documents and Mail

Reads and writes Google Docs through custom MCP tools, keeps a running "Verne Notes" document, and drafts email in my voice - with a hard rule: nothing is ever sent without explicit confirmation.

VOYAGE 04

Always Within Reach

Lives on Telegram. Send a voice note from anywhere; he transcribes it, confirms what he heard, and acts. Each conversation runs in its own isolated Docker container.

VOYAGE 05

Professional Writing

Cover letters, LinkedIn posts, proposals, government submissions - drafted in my register, not generic AI prose. The persona file encodes voice, format rules, and per-channel formatting conventions.

VOYAGE 06

Deadline Watch

Tracks trademark filings, follow-ups, and time-sensitive windows. Scheduled tasks run on cron inside the host - a morning briefing lands before I am out of bed.

Chapter III - The Engine Room

Under the hood

Verne runs on NanoClaw v2 - an open-source personal-agent framework with a deliberately spartan design philosophy: a single Node.js host process, per-session Docker containers, and SQLite files as the only interface between them. Everything is a message.

Host and Container Split

A Node host routes platform messages; each agent session gets an isolated Bun-runtime Docker container running the Claude Agent SDK. Containers are ephemeral - killed and respawned freely.

Two-Database Message Bus

No IPC between host and agent. Each session has inbound.db (host writes, agent reads) and outbound.db (agent writes, host reads). One writer per file. Even/odd sequence numbers. That is the whole protocol.

Semantic Memory Layer

mnemon - a Go-based SQLite knowledge graph - hooks into the agent's turn lifecycle: recall before responding, store after. Embeddings via nomic-embed-text on local Ollama.

Zero-Credential Containers

API keys and OAuth tokens never enter the agent container. A OneCLI gateway proxies outbound HTTPS and injects credentials at request time - Google APIs are called with plain fetch(), no SDK, no stored token.

Persona as Code

Each agent group is a folder with its own CLAUDE.md - identity, focus areas, behavioral rules, formatting constraints. Verne's character is a version-controlled text file, not a fine-tune.

Custom MCP Tools

Google Docs integration is four hand-rolled MCP tools (list / read / append / create) speaking directly to the REST API through the credential proxy - about 300 lines of TypeScript.

 Telegram / WhatsApp
        |
        v
 +----------------+    writes     +--------------+
 |  NanoClaw Host | ------------> |  inbound.db  |
 |   (Node.js)    |               +------+-------+
 +-------^--------+                      | polls
         |                               v
         |                 +---------------------------+
         |                 |   Agent Container (Bun)   |
         |                 |  Claude Agent SDK         |
         |                 |  mnemon memory hooks      |
         |                 |  MCP tools (Docs, ...)    |
         |                 +------------+--------------+
         | polls                        | writes
 +-------+-------+                      v
 |  delivery ->  |               +--------------+
 |  back to chat | <------------ | outbound.db  |
 +---------------+               +--------------+

 credentials:  container -- HTTPS --> OneCLI proxy --> Google / APIs
               (keys injected at request time, never stored in container)

Chapter IV - The Crew

Two agents, one brain

Business - Strategy - Writing

after Jules Verne - who charted the unreachable

The strategic peer. Handles ventures, positioning, professional writing, IP deadlines, and ecosystem strategy. Opinionated by design: his persona file instructs him to challenge framing, flag cold pursuits, and never open with "Great question!"

Personal - Logistics - Daily Rhythm

Lumiere

after the Lumiere brothers - who lit up everyday life

The trusted EA. Morning briefings at 7:30 sharp, travel logistics, to-do tracking, quick capture to notes. Warm but precise - built to be steady when the day isn't.

Both agents run as separate NanoClaw agent groups - separate containers, separate personas, separate channel wirings - but query the same mnemon knowledge graph. What Verne learns about shifting priorities surfaces for Lumiere's planning, and vice versa. Separation of concerns; unity of context.

Chapter V - The Manifest

Technical manifest

Component	Choice	Why
Agent framework	`NanoClaw v2`	Open-source, minimal, auditable. Single host process + ephemeral containers.
Reasoning	`Claude Agent SDK` (Anthropic)	Full agentic loop - tools, file workspace, scheduled tasks - inside the container.
Host runtime	`Node.js + TypeScript + pnpm`	Routing, channel adapters, delivery, scheduling, approvals.
Agent runtime	`Bun` in Docker	Fast cold starts for per-session containers; bun:sqlite for the message bus.
Message bus	`SQLite x 2 per session`	One writer per file, no lock contention, fully inspectable with a single query.
Memory	`mnemon + Ollama (nomic-embed-text)`	Local semantic knowledge graph. Recall-before, store-after, on every turn.
Credentials	`OneCLI gateway`	Request-time secret injection. The agent container never holds a key.
Channels	`Telegram (Chat SDK) · WhatsApp (Baileys)`	Meet the user where they already are. Voice notes included.
Integrations	`Google Docs · Gmail · Apple Notes`	Custom MCP tools over REST - no heavyweight SDKs in the container.
Hardware	`MacBook (Apple Silicon)`	Self-hosted. The agent, its memory, and its data never leave my machine.