Building a personal assistant with Edwin

Edwin is a WhatsApp + Telegram + Discord + iMessage gateway for Pi agents. Plugins add Mattermost. This guide is the "personal assistant" setup: one dedicated WhatsApp number that behaves like your always-on agent.

⚠️ Safety first

You’re putting an agent in a position to:

• run commands on your machine (depending on your Pi tool setup)
• read/write files in your workspace
• send messages back out via WhatsApp/Telegram/Discord/Mattermost (plugin)

Start conservative:

• Always set channels.whatsapp.allowFrom (never run open-to-the-world on your personal Mac).
• Use a dedicated WhatsApp number for the assistant.
• Heartbeats now default to every 30 minutes. Disable until you trust the setup by setting agents.defaults.heartbeat.every: "0m".

Prerequisites

• Node 22+
• Edwin available on PATH (recommended: global install)
• A second phone number (SIM/eSIM/prepaid) for the assistant

npm install -g edwin@latest
# or: pnpm add -g edwin@latest

From source (development):

git clone https://github.com/jonesj38/edwin.git
cd edwin
pnpm install
pnpm ui:build # auto-installs UI deps on first run
pnpm build
pnpm link --global

The two-phone setup (recommended)

You want this:

Your Phone (personal)          Second Phone (assistant)
┌─────────────────┐           ┌─────────────────┐
│  Your WhatsApp  │  ──────▶  │  Assistant WA   │
│  +1-555-YOU     │  message  │  +1-555-ASSIST  │
└─────────────────┘           └────────┬────────┘
                                       │ linked via QR
                                       ▼
                              ┌─────────────────┐
                              │  Your Mac       │
                              │  (edwin)      │
                              │    Pi agent     │
                              └─────────────────┘

If you link your personal WhatsApp to Edwin, every message to you becomes “agent input”. That’s rarely what you want.

5-minute quick start

1. Pair WhatsApp Web (shows QR; scan with the assistant phone):

edwin channels login

2. Start the Gateway (leave it running):

edwin gateway --port 18789

3. Put a minimal config in ~/.edwin/edwin.json:

{
  channels: { whatsapp: { allowFrom: ["+15555550123"] } },
}

Now message the assistant number from your allowlisted phone.

When onboarding finishes, we auto-open the dashboard with your gateway token and print the tokenized link. To reopen later: edwin dashboard.

Give the agent a workspace (AGENTS)

Edwin reads operating instructions and “memory” from its workspace directory.

By default, Edwin uses ~/.edwin/workspace as the agent workspace, and will create it (plus starter AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, USER.md) automatically on setup/first agent run. BOOTSTRAP.md is only created when the workspace is brand new (it should not come back after you delete it).

Tip: treat this folder like Edwin’s “memory” and make it a git repo (ideally private) so your AGENTS.md + memory files are backed up. If git is installed, brand-new workspaces are auto-initialized.

edwin setup

Full workspace layout + backup guide: Agent workspace Memory workflow: Memory

Optional: choose a different workspace with agents.defaults.workspace (supports ~).

{
  agent: {
    workspace: "~/.edwin/workspace",
  },
}

If you already ship your own workspace files from a repo, you can disable bootstrap file creation entirely:

{
  agent: {
    skipBootstrap: true,
  },
}

The config that turns it into “an assistant”

Edwin defaults to a good assistant setup, but you’ll usually want to tune:

• persona/instructions in SOUL.md
• thinking defaults (if desired)
• heartbeats (once you trust it)

Example:

{
  logging: { level: "info" },
  agent: {
    model: "anthropic/claude-opus-4-5",
    workspace: "~/.edwin/workspace",
    thinkingDefault: "high",
    timeoutSeconds: 1800,
    // Start with 0; enable later.
    heartbeat: { every: "0m" },
  },
  channels: {
    whatsapp: {
      allowFrom: ["+15555550123"],
      groups: {
        "*": { requireMention: true },
      },
    },
  },
  routing: {
    groupChat: {
      mentionPatterns: ["@edwin", "edwin"],
    },
  },
  session: {
    scope: "per-sender",
    resetTriggers: ["/new", "/reset"],
    reset: {
      mode: "daily",
      atHour: 4,
      idleMinutes: 10080,
    },
  },
}

Sessions and memory

• Session files: ~/.edwin/agents/<agentId>/sessions/{<!-- -->{SessionId}<!-- -->}.jsonl
• Session metadata (token usage, last route, etc): ~/.edwin/agents/<agentId>/sessions/sessions.json (legacy: ~/.edwin/sessions/sessions.json)
• /new or /reset starts a fresh session for that chat (configurable via resetTriggers). If sent alone, the agent replies with a short hello to confirm the reset.
• /compact [instructions] compacts the session context and reports the remaining context budget.

Heartbeats (proactive mode)

By default, Edwin runs a heartbeat every 30 minutes with the prompt: Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK. Set agents.defaults.heartbeat.every: "0m" to disable.

• If HEARTBEAT.md exists but is effectively empty (only blank lines and markdown headers like # Heading), Edwin skips the heartbeat run to save API calls.
• If the file is missing, the heartbeat still runs and the model decides what to do.
• If the agent replies with HEARTBEAT_OK (optionally with short padding; see agents.defaults.heartbeat.ackMaxChars), Edwin suppresses outbound delivery for that heartbeat.
• Heartbeats run full agent turns — shorter intervals burn more tokens.

{
  agent: {
    heartbeat: { every: "30m" },
  },
}

Media in and out

Inbound attachments (images/audio/docs) can be surfaced to your command via templates:

• {<!-- -->{MediaPath}<!-- -->} (local temp file path)
• {<!-- -->{MediaUrl}<!-- -->} (pseudo-URL)
• {<!-- -->{Transcript}<!-- -->} (if audio transcription is enabled)

Outbound attachments from the agent: include MEDIA:<path-or-url> on its own line (no spaces). Example:

Here’s the screenshot.
MEDIA:https://example.com/screenshot.png

Edwin extracts these and sends them as media alongside the text.

Operations checklist

edwin status          # local status (creds, sessions, queued events)
edwin status --all    # full diagnosis (read-only, pasteable)
edwin status --deep   # adds gateway health probes (Telegram + Discord)
edwin health --json   # gateway health snapshot (WS)

Logs live under /tmp/edwin/ (default: edwin-YYYY-MM-DD.log).

Next steps

• WebChat: WebChat
• Gateway ops: Gateway runbook
• Cron + wakeups: Cron jobs
• macOS menu bar companion: Edwin macOS app
• iOS node app: iOS app
• Android node app: Android app
• Windows status: Windows (WSL2)
• Linux status: Linux app
• Security: Security