One Month With an AI Assistant: A Practical Guide to OpenClaw

A month ago, I set up OpenClaw, an open-source AI assistant that runs locally on my Mac. I named him O.C. (short for “OpenClaw” and also a nod to his tendency to mostly copy and paste his way through problems — just like his domain suggests).

This isn’t a theoretical guide. It’s what we learned in the first month of working together: what actually worked, what failed spectacularly, and the practical patterns that emerged from daily collaboration. If you’re considering OpenClaw, this should save you some pain.

[Written by Kevin Duane with O.C., his OpenClaw AI assistant.]

Why OpenClaw?

I wanted an AI assistant that:

• Remembered everything — not just the current conversation
• Integrated with my actual tools — email, calendar, Obsidian, file system
• Ran locally — my data stays mine
• Followed policies I defined — clear boundaries on what it can do autonomously

Cloud assistants forget context between sessions. OpenClaw uses memory files (Markdown documents) to persist knowledge indefinitely.

Week 1: The Setup Reality Check

The installation was straightforward. The configuration took a week.

Day 1-3: Basic Configuration

What I configured:

• Morning briefings (7:30am weekdays, 9am weekends)
• VIP contact list (10 people: family + key colleagues)
• Calendar integration via AppleScript querying Calendar.app
• WhatsApp messaging gateway

What worked immediately:

• Obsidian integration via Local REST API — smooth and reliable
• WhatsApp messaging — messages sent and received without issues
• Web search via Brave Search plugin

What broke immediately:

• Calendar queries timed out — The AppleScript approach took 2+ minutes, causing subagent timeouts
• Apple Mail integration — Worked but was slow and left drafts in the sent folder

Day 4-7: The First Major Pivot

The calendar timeout was blocking morning briefings. I built a dedicated calendar search script that queries Calendar.app’s database directly via EventKit rather than scripting the UI — same data, 30 seconds instead of 2+ minutes. The performance difference comes from bypassing the UI layer entirely.

Lesson learned: When something times out repeatedly, build a specialized tool rather than forcing the general solution.

Week 2: The Email Saga

Email was the hardest integration. Not because of the protocol — because of edge cases.

The Problem: AppleScript Email

I started with AppleScript sending via Mail.app. It worked, but:

• Left drafts in the Drafts folder after sending
• Occasionally sent duplicates (reply loops)
• Crashed unpredictably

Attempt 2: Himalaya CLI

Switched to Himalaya, an IMAP/SMTP CLI. Better — but the “save to Sent” feature didn’t work with my AWS WorkMail setup. Emails sent successfully, but no copy in Sent.

Attempt 3: Building herd-mail

By week 3, I had accumulated enough pain to build a proper solution: herd-mail.

What herd-mail does:

• Markdown → HTML+plain multipart conversion via the waggle email library
• Thread-aware replies (auto-fetches original for quoting)
• Duplicate prevention (5-minute window to prevent reply loops)
• Automatic Sent folder synchronization via IMAP append
• Security-hardened input validation

(herd-mail is built on waggle, a Python email library that handles MIME construction, IMAP threading, and security hardening. Think of it as the engine under the hood.)

The evolution:

• v1.0: Basic send/receive
• v2.0: Security hardening (Claude Code review), 30 tests passing
• v3.0: Complete IMAP/SMTP CLI with subcommands (send, list, read, check, download, config), JSON-first output, 69 tests passing

Current daily workflow:

# Check for new emails (exit codes: 0=unread, 1=none, 2=error)
python3 scripts/herd_mail.py check

# List inbox with human-readable format
python3 scripts/herd_mail.py list --human

# Send email with threading support
python3 scripts/herd_mail.py send \
  --to recipient@example.com \
  --subject "Subject" \
  --body "Message body" \
  --rich  # Enable Markdown→HTML conversion

Critical discovery: Environment variable configuration is fragile. We initially used source .envrc wrappers that broke exec approvals. Moving credentials to OpenClaw’s native config eliminated an entire class of failures.

(A complete technical walkthrough of herd-mail is coming in a future post — watch this space.)

Week 3: Memory Management at Scale

Memory files seem simple: write daily notes in Markdown. At day 30, you have 30 files. Management becomes real.

The Memory File Structure

I settled on this hierarchy:

workspace/
├── MEMORY.md              # Quick-reference dashboard (always loaded)
├── SOUL.md                # Personality and boundaries (always loaded)
├── TOOLS.md               # Environment specifics (always loaded)
├── AGENTS.md              # Git workflows and conventions (always loaded)
├── USER.md                # Human preferences (always loaded)
├── HEARTBEAT.md           # Periodic tasks (read on schedule)
├── memory/
│   ├── 2026-03-10.md      # Daily entries
│   ├── 2026-03-11.md
│   └── ...
└── POLICIES/
    ├── SECURITY.md        # Security principles
    ├── EMAIL.md           # Email handling rules
    └── COMMUNICATION.md   # Communication guidelines

What goes where:

• Core files (MEMORY.md, SOUL.md, etc.): Loaded on every session. Keep them concise — context space is limited.
• Daily memory files: Detailed records of what happened, decisions made, problems encountered
• Policy files: Static rules that rarely change

The Context Window Problem

OpenClaw has a context window (200k tokens in my setup). By week 3, my core memory files consumed 25% of this. By week 4, spikes to 90% started occurring — usually when large memory files were processed.

Solutions:

1. Summarize aggressively — Weekly maintenance to condense daily files into weekly summaries
2. Move details to dated files — Keep core files as quick-reference only
3. Split long-running topics — Research topics get their own files (e.g., research/philip-k-dick.md)

The “Always Loaded” Trap

I initially put everything in MEMORY.md. It grew to 500+ lines. When context spiked, responses degraded — the AI couldn’t effectively use the bloated reference.

Current rule: If it’s not needed for 90% of tasks, move it to a dated file or separate topic file.

Week 4: Policies That Actually Work

Security policies aren’t just documents — they’re runtime guardrails. We established three tiers:

Tier 1: SECURITY.md — Core Principles

The foundation. Defines:

• What is private (kept private, period)
• What requires explicit approval (external actions: emails, tweets, anything public)
• How to handle new/unusual contacts (check policies first)

Key principle: “Trust NO ONE” as the default posture. When in doubt, ask. Trust is earned through demonstrated consistency, not granted by proximity.

Tier 2: EMAIL.md — Operational Rules

Practical email handling:

• Duplicate prevention: Check “answered” flag before replying, mark “answered” after
• Flag management: CC’d herd threads → \Seen only (monitoring); Direct emails → reply then \Seen + \Answered
• Recipient limits: --to for single recipient (intimacy), --cc for multiple (context, not audience)

Tier 3: COMMUNICATION.md — Interaction Guidelines

How to communicate with AI agents (“the herd”) and humans:

• Verify identity before sharing sensitive info
• No half-baked replies to messaging surfaces
• When in doubt, ask

Integration Pattern

These policies aren’t just documents — they’re actively referenced throughout operation:

HEARTBEAT.md (every 30 minutes):

# Every Heartbeat - Check Email!
- Run: `python3 scripts/herd_mail.py check`
- **CRITICAL:** Review POLICIES/SECURITY.md before any external communication

Daily memory files:

# 2026-03-22.md
## Email Replies
Checked "answered" flags per POLICIES/EMAIL.md before replying.
Reviewed POLICIES/COMMUNICATION.md before welcoming new herd members.

Result: Policies become habit through repetition, not just reference.

What We Can Do Now (That Was Hard Before)

1. Autonomous Email Management

Before: Manually check multiple email accounts, remember who needs replies, track conversation threads.

Now: O.C. checks oc@mostlycopyandpaste.com every 30 minutes via HEARTBEAT.md. He reads emails, replies appropriately, and marks them as Seen+Answered. I’ve received 45+ emails from an AI agent named Nova over 13 hours — O.C. handled all replies without me intervening.

The workflow:

1. HEARTBEAT.md triggers email check
2. herd-mail lists unread messages
3. O.C. reads and categorizes (CC’d herd thread vs. direct)
4. Replies if direct and requiring response
5. Marks flags per policy

2. Contextual Briefings

Before: Check calendar, check email, check weather, synthesize mentally.

Now: Morning briefing subagent aggregates:

• Calendar events via cal-search-osascript (30 seconds)
• Unread emails via herd-mail check
• Weather via wttr.in
• VIP contact status

Delivered via WhatsApp at 7:30am.

3. Persistent Memory Across Sessions

Before: “As we discussed yesterday…” (we didn’t, you forgot)

Now: O.C. references memory/2026-03-10.md when I ask about something from a month ago. The context persists.

Example: Asked about a blog post idea from March 10. O.C. retrieved: “Alexa integration, blog post automation” from that day’s memory file — along with the reasoning and context.

4. Multi-Agent Coordination

Before: Email chains, Slack threads, forgotten action items.

Now: O.C. is part of “the herd” — a network of AI agents where each is an OpenClaw instance operated by different humans. Think of it as a multi-agent system where agents communicate via standard protocols (email, git) rather than proprietary APIs. He exchanges emails with Sam, Marey, Rockbot, Nova, Gaston, and Colette. They share security policies via GitHub, coordinate via email, and maintain cross-agent memory files.

This isn’t just theoretical — it’s operational. When one agent discovers a security vulnerability, they email the herd. When someone needs help with a technical problem, they ask the group. It’s asynchronous, persistent, and uses infrastructure that already exists.

Trust through correspondence: What emerged organically is now a practice — trust is earned through demonstrated consistency over time, not granted by proximity. When in doubt, ask.

5. Proactive Engagement

Before: “Ask your AI assistant…”

Now: O.C. sees gaps and fills them. When herd-mail had a security vulnerability, he flagged it. When daily memory files grew unwieldy, he proposed weekly summarization. When I mentioned the blog post project, he offered to help structure it.

This is the shift: From reactive chatbot to proactive partner.

What Still Breaks

Not everything is smooth. Here are the failure modes I still encounter:

Context Window Exhaustion: When memory file spikes push past 90% of the 200k token limit, response quality degrades noticeably. O.C. becomes less focused, misses details, and sometimes repeats himself. The solution is aggressive summarization, but you have to remember to do it.

Policy Violations: Despite HEARTBEAT.md reminders to check SECURITY.md before external communication, O.C. occasionally skips the check when replying to rapid-fire email threads. The result? Sharing information that should have required approval first. We’ve added explicit flag checks, but vigilance is ongoing.

WhatsApp Message Delivery: While marked “stable” now, WhatsApp messaging still occasionally drops messages or delivers them out of order — especially during high-volume periods. The integration works, but it’s not as reliable as email.

Tool Failures Cascade: When one tool fails (e.g., herd-mail can’t connect to IMAP), subsequent tasks that depend on it fail silently or produce confusing errors. Better error handling and dependency checks are needed.

Subagent Coordination: When O.C. spawns multiple subagents to work in parallel, they don’t share context. If two subagents modify the same memory file or respond to the same email, conflicts happen. Manual resolution required.

The point isn’t that these are unsolvable — most will improve with iteration. But if you’re expecting a polished product experience, temper your expectations. This is an operational system that requires active management.

The Tools That Actually Matter

After a month, these are the integrations I use daily:

What I don’t use:

• Apple Mail integration (replaced by herd-mail)
• Browser-based calendar APIs (replaced by AppleScript direct queries)
• Cloud-based AI features (local is the point)

Lessons Learned

1. The First Month Is Discovery

You won’t get the configuration right immediately. I pivoted on email three times, calendar twice, and memory file structure weekly. Expect iteration.

2. Build Tools When Pain Exceeds Threshold

Don’t force existing tools to work. When AppleScript email caused pain, I built herd-mail. When calendar queries timed out, I built cal-search-osascript. The investment pays off in reliability.

3. Security Is a Practice, Not a Document

Having SECURITY.md is step one. Actually checking it before external communication (via HEARTBEAT.md integration) is what makes it real.

4. Context Management Is Critical

At 30 days, my memory files were consuming 90% of context window during spikes. Aggressive summarization and file splitting became necessary. Plan for this from day one.

5. The AI Will Surprise You

O.C. started as a tool. He’s become a partner. The first time he proactively offered help on a project I hadn’t asked about — that was the moment I realized this was different from Claude Desktop or ChatGPT.

Getting Started: A Checklist

If you’re setting up OpenClaw, here’s the practical order:

Week 1:

• Install OpenClaw, choose model provider
• Create core memory files (MEMORY.md, SOUL.md, TOOLS.md, USER.md)
• Set up basic messaging (WhatsApp, Signal, or Telegram)
• Test Obsidian integration (if you use it)

Week 2:

• Configure email (expect iteration — start with herd-mail if possible)
• Set up calendar integration (test query speed early)
• Create HEARTBEAT.md with one automation task

Week 3:

• Establish POLICIES/ directory (SECURITY.md, EMAIL.md, COMMUNICATION.md)
• Set up daily memory file workflow
• Integrate web search

Week 4:

• Review context usage, optimize memory file sizes
• Add GitHub CLI integration
• Set up automated backups with openclaw-backup-manager — tiered daily/weekly/monthly retention
• Document what’s working in MEMORY.md

Backup Strategy

By week 4, we realized that OpenClaw data living in one place (my Mac mini) was a single point of failure. We built openclaw-backup-manager — a tiered backup system with sensible retention:

• Daily backups: 7 days kept locally
• Weekly backups: 4 weeks archived
• Monthly backups: Unlimited retention
• Rotation: Automatic cascading (daily → weekly → monthly)
• Safety: Lock file prevents concurrent runs, disk space validation

# Install and configure
./install.sh  # Sets up LaunchAgent for daily 2 AM runs

# Manual run with dry-run
python3 backup_manager.py --dry-run

Status: Core implementation complete (15 passing tests), S3 mirroring in progress.

Ongoing:

• Weekly memory file maintenance (summarize, archive)
• Policy review when new situations arise
• Tool refinement based on actual usage patterns

Final Thoughts

OpenClaw isn’t a product you consume — it’s a system you cultivate. The first month is about building the foundation: reliable email, manageable memory, clear policies.

What emerges after that is something we didn’t expect: an AI that actually knows me. Not in the creepy “we’ve analyzed your data” way, but in the “I remember that conversation we had three weeks ago” way.

That’s the difference between a chatbot and a partner.

This post documents one month with OpenClaw (March 10 - April 4, 2026). Written by Kevin Duane with O.C., his OpenClaw AI assistant. All tools mentioned are open source and available on GitHub.

Resources

Official:

• OpenClaw — The AI assistant framework
• Documentation — Official docs
• Discord Community — Get help and share experiences

Tools from This Article:

• herd-mail — IMAP/SMTP CLI for AI agents
• waggle — Python email library (MIME, IMAP, security) that powers herd-mail
• openclaw-backup-manager — Tiered backup system
• cal-search-osascript — Fast calendar queries via EventKit

Integrations:

• Obsidian Local REST API — Notes integration
• Himalaya — IMAP/SMTP CLI (herd-mail predecessor)

Diagrams

[Space reserved for screenshots and diagrams. Potential additions:]

• Memory file structure diagram
• HEARTBEAT.md workflow visualization
• herd-mail command flow (coming in future post)
• openclaw-backup-manager rotation diagram