Openclaw Macroclaw Integration

OpenClaw + MacroClaw: Research & Integration Plan

Research date: February 16, 2026 Goal: Understand OpenClaw configuration, solve iPhone calling, and design task orchestration for Joe's running CS task list

1. What Is OpenClaw?

OpenClaw (formerly Clawdbot/Moltbot) is an open-source autonomous AI agent created by Peter Steinberger (PSPDFKit founder). It went viral in late January 2026, hitting 145,000+ GitHub stars. On Feb 14, Steinberger announced he's joining OpenAI and moving the project to an open-source foundation.

Core idea: It's an "OS for AI agents" — not a chatbot, but an execution environment. It runs locally on your machine, connects to messaging platforms (WhatsApp, Telegram, Slack, iMessage, Discord, Signal, etc.), and autonomously executes real tasks: shell commands, browser automation, file operations, email, calendar, and more.

Key components: - Gateway: Node.js WebSocket server (port 18789) — connects all messaging platforms, routes messages, manages sessions, runs cron jobs, enforces access control - Agent Runtime: Assembles context (session history + memory + skills), invokes the LLM, executes tool calls, persists state - Skills: Markdown playbooks in skills/<skill>/SKILL.md — contextually injected into prompts. 100+ preconfigured, agent can generate new ones autonomously - Memory: SQLite + vector embeddings for semantic search of past conversations. MEMORY.md for curated long-term facts. Daily logs in memory/YYYY-MM-DD.md - Canvas: Agent-generated interactive HTML served on port 18793

Repo: https://github.com/openclaw/openclaw

2. Why Installation Is Challenging

The Top Problems (in order of frequency)

1. Node.js version (35% of failures) OpenClaw requires Node 22+. Not 18, not 20. Most people have older versions. Fix: nvm install 22 && nvm use 22.

2. Sharp native dependency (Apple Silicon) The sharp image processing library fails to compile on M-series Macs without Xcode CLI tools. Fix: xcode-select --install and set SHARP_IGNORE_GLOBAL_LIBVIPS=1.

3. PATH not updated after install openclaw: command not found — npm global bin isn't in PATH. Fix: add export PATH="$(npm config get prefix)/bin:$PATH" to .zshrc.

4. Gateway won't start Port 18789 conflict (stale process or another service). Fix: lsof -i :18789 to find the culprit, openclaw gateway restart, or openclaw doctor --fix.

5. Windows — not supported natively Must use WSL2. Many people try PowerShell first and get cryptic errors.

6. Config validation is strict openclaw.json uses JSON5 but validates against a strict schema. Typos in field names silently ignored or cause hard errors depending on the field. openclaw doctor is the diagnostic tool.

7. WhatsApp linking fragility The QR code pairing for WhatsApp (via Baileys library) is brittle. Sessions can drop, requiring re-pairing. Only one Gateway per host can hold a WhatsApp session.

8. Permission/authentication layering Multiple auth layers (Gateway token, channel DM pairing, tool sandboxing, model provider API keys) create confusion. Most errors fall into: local config → gateway validation → upstream provider rejection.

Recommended Install Path for Joe's Mac

# 1. Ensure Node 22+
nvm install 22 && nvm use 22

# 2. Install OpenClaw
curl -fsSL https://openclaw.ai/install.sh | bash

# 3. Run setup wizard (configures model, links first channel)
openclaw setup --install-daemon

# 4. Verify
openclaw doctor
openclaw status --all

Config file: ~/.openclaw/openclaw.json (JSON5, hot-reloads most changes)

3. The Phone Calling Problem: iPhone vs. Twilio

What OpenClaw Offers (Voice Call Plugin)

OpenClaw has a @openclaw/voice-call plugin that supports outbound calls via: - Twilio - Telnyx (ClawdTalk) - Plivo

The problem: All three give you a different phone number. It's a VoIP number, not your iPhone number. When you call someone, they see an unfamiliar number, not "Joe Newbry." This defeats the purpose of acting on your behalf.

The plugin config looks like:

{
  "plugins": {
    "entries": {
      "voice-call": {
        "config": {
          "provider": "twilio",
          "fromNumber": "+1XXXXXXXXXX",
          "credentials": { ... }
        }
      }
    }
  }
}

Verdict: OpenClaw's built-in voice calling is Twilio-style — separate number, not your iPhone. This is NOT what you want.

What MacroClaw Already Solves

Your existing MacroClaw project already nails this problem: - Uses macOS Continuity to place calls through your actual iPhone via FaceTime - Calls show your real caller ID - Chatterbox TTS speaks in your cloned voice - MLX Whisper STT transcribes the caller locally - Claude drives the conversation from Markdown goal files - BlackHole 2ch + aggregate audio device routes audio in/out of the call

This is exactly the "call from my number" solution. No Twilio needed.

The Integration: OpenClaw Orchestrates, MacroClaw Calls

The right architecture is:

OpenClaw (brain/orchestrator)
    ↓ decides "time to make a call"
    ↓ generates goal file from task context
    ↓ triggers MacroClaw
MacroClaw (phone calling engine)
    ↓ places call via iPhone Continuity
    ↓ TTS speaks, STT listens, Claude converses
    ↓ returns transcript + outcome
    ↓ reports back to OpenClaw
OpenClaw (updates task status, decides next action)

How to wire it: Create an OpenClaw AgentSkill or tool that: 1. Writes a goal .md file based on the task context 2. Shells out: cd ~/dev/MacroClaw && npm run call -- --to "+1XXXXXXXXXX" --goals goals/generated-task.md 3. Reads the transcript JSON from calls/call-*.json 4. Reports outcome back to the conversation

This could live as a custom OpenClaw skill in skills/phone-call/SKILL.md:

---
name: phone-call
description: Place a real phone call from Joe's iPhone using MacroClaw
---
# Phone Call Skill

When the user or a task requires making a phone call:
1. Write goals to ~/dev/MacroClaw/goals/<task-name>.md
2. Run: cd ~/dev/MacroClaw && npm run call -- --to "<number>" --goals goals/<task-name>.md
3. Wait for completion
4. Read transcript from calls/ directory
5. Report outcome and update task status

4. Orchestrating the Task List (CS Running CSV)

Understanding the CSV

Joe's task list is a massive spreadsheet with ~200+ active items spanning: - Personal admin: Cancel subscriptions, insurance changes, reimbursements - Family health: Mom's Parkinson's care team, Scott's treatment, Ways2Well trips - Career: Job board applications, freelance platforms, A16z application - Financial: Loans, HSA transfers, Brex limits, bitcoin purchases - Projects: Solar, blog posts, running, business ideas - Relationship maintenance: Email threads, follow-ups, Reddit outreach

Each row has: a link, a description, date columns tracking progress, status, and outcome.

How OpenClaw Can Work Through This

Architecture: The Task Loop

┌─────────────────────────────────────┐
│         openclaw.json config         │
│  - cron: daily morning task review   │
│  - heartbeat: 30 min check-ins      │
│  - model: claude-sonnet-4-5         │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│       Task Manager Skill             │
│  Reads: ~/tasks/tasks.json           │
│  Prioritizes by: due date, blocked   │
│  state, last-touched, category       │
│  Outputs: next 3-5 actionable items  │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│       Task Executor Loop             │
│  For each task:                      │
│    1. Assess what's needed           │
│    2. Can I do it autonomously?      │
│       YES → execute (email, browse,  │
│              research, call)          │
│       MAYBE → draft action, ASK JOE  │
│       NO → skip, flag for human      │
│    3. Update task status             │
│    4. Log what happened              │
│    5. Move to next task              │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│       Learning / Memory              │
│  - Remember patterns (this task      │
│    type always needs X)              │
│  - Track velocity (tasks/day)        │
│  - Note Joe's preferences from       │
│    feedback                          │
│  - Get faster over iterations        │
└─────────────────────────────────────┘

Converting the CSV to a Task System

Step 1: Convert CSV to structured JSON

{
  "tasks": [
    {
      "id": "task-001",
      "name": "Cancel Homeaglow service",
      "category": "personal-admin",
      "link": "https://mail.google.com/...",
      "status": "pending",
      "last_action": "Sent email",
      "last_action_date": "2026-01-20",
      "autonomy_level": "full",
      "actions_needed": ["check for response", "follow up if no response"],
      "context": "Email sent to cancel service, waiting for confirmation"
    },
    {
      "id": "task-002",
      "name": "Dr. Ballon Vagal Nerve Stimulation",
      "category": "family-health",
      "link": "...",
      "status": "waiting",
      "last_action": "Sent message, no response",
      "autonomy_level": "ask-first",
      "actions_needed": ["follow up", "check with other care team if no response"],
      "context": "For Mom's Parkinson's. Sent message asking about vagus nerve stim for depression."
    }
  ]
}

Step 2: Classify each task by autonomy level

Level	Description	Examples
`full`	OpenClaw can do it without asking	Check email thread status, research a topic, draft a follow-up
`draft-and-ask`	Prepare the action, show Joe for approval	Send an email, make a phone call, submit a form
`ask-first`	Needs Joe's input before even starting	Family health decisions, financial moves, job applications
`human-only`	Can't be automated	Physical tasks (backpack, toothbrush), in-person meetings

Step 3: Set up OpenClaw cron jobs

// ~/.openclaw/cron/jobs.json
[
  {
    "name": "Morning Task Review",
    "schedule": { "kind": "cron", "expr": "0 7 * * *", "tz": "America/Los_Angeles" },
    "sessionTarget": "main",
    "wakeMode": "now",
    "payload": {
      "kind": "systemEvent",
      "text": "Time for morning task review. Read ~/tasks/tasks.json, pick the top 5 most actionable items, and work through them. For each: assess status, take action if autonomous, draft and present if needs approval, skip if human-only. Update the task file after each action."
    }
  },
  {
    "name": "Afternoon Follow-up",
    "schedule": { "kind": "cron", "expr": "0 14 * * *", "tz": "America/Los_Angeles" },
    "sessionTarget": "main",
    "wakeMode": "now",
    "payload": {
      "kind": "systemEvent",
      "text": "Afternoon follow-up round. Check for responses to morning actions. Follow up on any waiting tasks that are overdue. Report progress to Joe."
    }
  },
  {
    "name": "Weekly Deep Review",
    "schedule": { "kind": "cron", "expr": "0 9 * * 0", "tz": "America/Los_Angeles" },
    "sessionTarget": "isolated",
    "payload": {
      "kind": "agentTurn",
      "message": "Full task list review. Read all tasks, identify stale items (no action in 2+ weeks), suggest items to close or escalate, calculate velocity metrics, and generate a weekly summary.",
      "model": "opus"
    },
    "delivery": {
      "mode": "announce",
      "channel": "whatsapp",
      "to": "joe"
    }
  }
]

The "Stop and Ask" Pattern

OpenClaw cron jobs cannot pause mid-execution to ask questions. But the main session approach solves this:

Morning cron fires in the main session (not isolated)
Agent works through tasks, taking autonomous actions
When it hits a draft-and-ask task, it sends you a WhatsApp/iMessage message with: "I'm working on [task]. Here's what I'd do: [draft]. Should I proceed? Reply YES/NO/modify"
You reply on your phone
Agent receives your reply in the same session, continues working

This creates the interactive loop you want — the agent works, pauses when uncertain, gets your input, and continues.

Learning and Getting Faster

OpenClaw's memory system enables this naturally:

MEMORY.md: Agent writes learned patterns: "Joe always wants follow-up emails to be brief and direct" or "For family health tasks, always CC Dad"
Daily logs: memory/YYYY-MM-DD.md tracks what happened each day
Session continuity: Main session carries full conversation history, so the agent remembers what you said about similar tasks
Skill generation: When a task pattern repeats (e.g., "check job board, apply if good match"), the agent can write a new skill for it

Over time: - First pass: Agent asks about everything ("Should I follow up on this email?") - Week 2: Agent learns patterns ("Follow-ups go out 3 days after no response") - Month 2: Agent handles 70% of tasks autonomously, only asking for novel situations

5. Specific Task Categories and How OpenClaw Handles Them

Email Thread Follow-ups (largest category)

Tool: Browser automation or Gmail API via skill
Flow: Open thread → check for new replies → if no reply in X days → draft follow-up → send (or ask Joe first)
Example: "Chad has a path towards apartment ownership in Brooklyn" — check thread, see if there's anything new, draft next message if needed

Job Board Monitoring (arc.dev, gun.io, gofractional, etc.)

Tool: Browser automation + web scraping
Flow: Visit each board → search for relevant jobs → compare against profile → apply or flag
Skill: skills/job-search/SKILL.md with criteria, resume versions, cover letter templates

Family Health Coordination

Autonomy: ask-first — always show Joe before sending
Flow: Draft message to care team → present to Joe → send on approval
Memory: Track who responded, what was said, next steps

Financial Tasks

Autonomy: draft-and-ask for transfers, full for checking balances
Flow: Check account status → draft action → get approval → execute

Phone Calls (via MacroClaw integration)

Trigger: Task requires a phone call (e.g., "Call Ways2Well", "Reschedule Ezra")
Flow: Generate goal file → trigger MacroClaw → wait for transcript → update task
Autonomy: Always draft-and-ask (confirm the call before dialing)

6. Implementation Roadmap

Phase 1: Get OpenClaw Running (Day 1)

[ ] Install OpenClaw (curl -fsSL https://openclaw.ai/install.sh | bash)
[ ] Ensure Node 22+ (nvm install 22)
[ ] Run setup wizard (openclaw setup --install-daemon)
[ ] Configure Anthropic API key
[ ] Link WhatsApp or iMessage channel
[ ] Verify with openclaw doctor

Phase 2: Convert Task List (Day 1-2)

[ ] Export CSV to JSON (write a quick script)
[ ] Classify each task by autonomy level
[ ] Add action descriptions and context
[ ] Store at ~/tasks/tasks.json

Phase 3: Build Task Manager Skill (Day 2-3)

[ ] Write skills/task-manager/SKILL.md
[ ] Define task reading, prioritization, and status update logic
[ ] Set up cron jobs (morning review, afternoon follow-up, weekly deep review)
[ ] Test with 5 simple tasks first

Phase 4: Add Phone Calling (Day 3-4)

[ ] Write skills/phone-call/SKILL.md that invokes MacroClaw
[ ] Fix MacroClaw critical bugs first (objective detection, retry logic, HTTP timeouts)
[ ] Test with a low-stakes call (e.g., dentist appointment)
[ ] Wire transcript feedback into task status

Phase 5: Expand and Learn (Week 2+)

[ ] Let the agent run morning reviews for a week
[ ] Provide feedback on its decisions ("good call" / "don't do that")
[ ] Watch MEMORY.md grow with learned patterns
[ ] Gradually increase autonomy levels as trust builds

7. Risks and Mitigations

Risk	Mitigation
Agent sends embarrassing email	All emails are `draft-and-ask` until trust is established
Agent makes unwanted phone call	Phone calls always require explicit approval
WhatsApp session drops	Set up Telegram as backup channel
Agent gets stuck in a loop	Set `maxConcurrentRuns: 1` and timeouts on all cron jobs
Privacy/security of task data	Everything runs locally, no cloud storage
Agent goes rogue with shell access	Use sandboxing for non-main sessions, review tool logs

8. Key Takeaways

OpenClaw is the orchestration brain, MacroClaw is the phone calling body. Don't try to use OpenClaw's Twilio-based voice plugin for calling from your number. Use MacroClaw for that.
Installation is genuinely annoying but solvable. Node 22+, sharp on Apple Silicon, and WhatsApp linking are the three big hurdles. Budget 1-2 hours for a clean install.
The task loop is the killer feature. OpenClaw's cron + main-session + memory system is purpose-built for exactly what you want: an agent that works through a list, asks when unsure, and learns over time.
Start with email follow-ups (lowest risk, highest volume). Graduate to phone calls once the pattern is proven.
The "stop and ask" pattern works via main-session cron + messaging channel replies. Not built-in to cron jobs, but achievable through the main session architecture.