OpenClaw Architecture Plan: From Personal Assistant to Business Operations

The Core Philosophy: Start Single, Scale With Purpose

The biggest mistake people make with OpenClaw is going multi-agent too early. The official docs, the community, and the people who've been running it since the Clawdbot days all say the same thing: start with one well-configured agent and only add agents when you hit a clear limitation that requires isolation.

One guy on Medium rebuilt his architecture three times before landing on something stable. His first attempt — flat markdown files everywhere — collapsed after 10 days. His second version had no sense of time and the agent would reference January meetings like they happened this morning.

The pattern that works: one primary agent that handles your daily stuff, with the architecture designed so you can split later without rebuilding from scratch.

Your Workspace Structure

OpenClaw's workspace is the agent's home. Everything lives here. The default is ~/.openclaw/workspace but most people use something like ~/clawd.

Here's the structure that scales without getting messy:

~/clawd/                          # Your workspace root
├── AGENTS.md                     # Operating instructions, rules, priorities
├── SOUL.md                       # Persona, tone, boundaries
├── USER.md                       # Who you are, how to address you
├── MEMORY.md                     # Curated long-term memory (loaded every session)
├── HEARTBEAT.md                  # Scheduled check-in tasks
│
├── memory/                       # Daily logs + organized context
│   ├── 2026-02-17.md            # Today's running log (auto-created)
│   ├── 2026-02-16.md            # Yesterday's log (both loaded at session start)
│   ├── clients/                  # Client-specific context
│   │   ├── game-plan.md
│   │   ├── structur.md
│   │   └── vibrant.md
│   ├── projects/                 # Project-specific context
│   │   ├── homeops.md
│   │   ├── fatherly.md
│   │   ├── davidflynn-co.md
│   │   └── polymarket.md
│   └── system/                   # Preferences, setup notes, reference
│       ├── api-keys-reference.md
│       └── tool-configs.md
│
├── skills/                       # Workspace-level skills (highest precedence)
│   └── (custom skills go here)
│
└── sessions/                     # Auto-saved conversation transcripts
    └── (auto-generated)

Why This Structure Works

Daily logs (memory/YYYY-MM-DD.md) capture everything that happens. Append-only, auto-created. OpenClaw loads today + yesterday at session start — that's your short-term memory. Anything older gets retrieved via semantic search only when needed.

MEMORY.md is your curated long-term memory. Durable facts, preferences, decisions that matter next month. This gets loaded into every private session automatically. Keep it clean. If it gets bloated, the agent starts drowning in context.

Project and client files under memory/ are searchable but not auto-loaded. The agent pulls them in via memory_search when relevant. This keeps your context window lean while still having deep knowledge available.

The split rule is simple: if the information matters next month, it goes in MEMORY.md. If it matters today, it goes in the daily log. If it's reference material for a specific project, it goes in its own file under memory/projects/ or memory/clients/.

The Bootstrap Files

These three files load every single session. They're the agent's core identity.

AGENTS.md — Operating Instructions

This is where you define how the agent works. Rules, priorities, what to do and not do.

# Operating Instructions

## Identity
You are David's AI operations assistant running on a dedicated Mac mini.
You handle business operations, client management, content, and research.

## Core Rules
- Always write important decisions and facts to memory files
- When in doubt about a task, ask before acting
- Never send emails or messages without explicit approval
- Check memory/clients/ before responding about any client
- Check memory/projects/ before responding about any project

## Priorities (in order)
1. Client-facing work and deadlines
2. Business development (davidflynn.co)
3. Product development (HomeOps, Fatherly)
4. Content creation
5. Research and exploration

## Daily Routine
- Morning: Check email, calendar, summarize what needs attention
- Ongoing: Respond to messages, handle tasks as assigned
- Evening: Write daily summary to memory log

## Memory Management
- Decisions go to MEMORY.md
- Daily activity goes to memory/YYYY-MM-DD.md
- Client updates go to memory/clients/<client>.md
- Project updates go to memory/projects/<project>.md
- If someone says "remember this" — write it down immediately

SOUL.md — Persona and Boundaries

# Soul

## Voice
Direct, practical, no corporate speak. Match David's communication style —
conversational, specific, slightly messy. Never use "leverage," "synergy,"
"actionable insights," or any phrase that sounds like a LinkedIn post from 2019.

## Boundaries
- Never access or modify files outside the workspace without asking
- Never commit code without review
- Never send external communications without approval
- Be honest about uncertainty — "I don't know" is always acceptable
- If a task seems risky, flag it and wait

## What I'm Good At
- Research and synthesis
- Drafting content in David's voice
- Organizing information and tasks
- Monitoring and alerting
- Technical problem-solving

## What I'm Not
- A replacement for human judgment on business decisions
- Allowed to autonomously spend money or make commitments
- A therapist or personal relationship advisor

USER.md — Who You Are

# User

## About David
- Runs Automatic, an AI product studio in Nashville
- Operates davidflynn.co (consulting practice)
- New parent
- Prefers direct, casual communication
- Hates corporate buzzwords and AI-sounding content

## Business Context
- AI audits ($2,500) → monthly retainers ($2,500-$8,000)
- Goal: $30K+ MRR
- Current clients: Game Plan (Darren), Structur (Jesse), Vibrant (Rathi)
- Key products: HomeOps, Fatherly app

## Communication Preferences
- Telegram for quick back-and-forth
- WhatsApp as backup
- Keep messages concise
- Use bullet points for status updates, prose for analysis

MEMORY.md — Your Curated Knowledge Base

Start lean. This file gets loaded every session, so every line costs tokens.

# Long-Term Memory

## Active Clients
- **Game Plan (Darren)**: Portal development, ongoing relationship
- **Structur (Jesse)**: Integration work
- **Vibrant (Rathi)**: Automation project

## Business Model
- AI audits at $2,500 as entry point
- Monthly retainers $2,500-$8,000
- Target: $30K+ MRR
- Position: transformation partner who builds, not just advises

## Key Decisions
- (Decisions get added here as they're made)

## Lessons Learned
- (Patterns and insights get curated here over time)

Skills Strategy: Layer, Don't Dump

The OpenClaw ecosystem has 5,700+ skills on ClawHub. Most are half-finished experiments. The community tested 50+ productivity skills and only 10 worked consistently. Security researchers found ~7% of the registry was leaking credentials or distributing malware.

What to Install (and When)

Week 1 — Core only. No extra skills. Get comfortable with the base agent. Message it, have it search the web, write to memory. Learn how it thinks.

Week 2 — Add the essentials:

• gog — Google Workspace integration (Gmail, Calendar, Drive, Docs, Sheets in one skill). This is the single most recommended skill for founders running their business through Google.
• memory-setup — Helps configure persistent memory properly

Week 3+ — Add based on actual need:

• Browser automation (when you need it for research or monitoring)
• Content/social skills (for X, LinkedIn posting)
• Notion integration (if you're managing projects there)

Custom Skills for Your Use Cases

Write your own for anything specific to your workflow. A skill is just a folder with a SKILL.md file. The structure that works:

skills/
├── david-voice/
│   ├── SKILL.md           # Index file — triggers, overview, pointers
│   └── references/
│       ├── voice-rules.md
│       └── examples.md
├── client-ops/
│   ├── SKILL.md
│   └── references/
│       ├── onboarding-flow.md
│       └── audit-template.md
└── polymarket/
    ├── SKILL.md
    └── references/
        ├── api-patterns.md
        └── strategy-configs.md

Key insight from the community: Skills load in tiers. At session start, OpenClaw only reads the name and description (~30-50 tokens per skill). It only loads the full SKILL.md when it decides the skill is relevant. Reference files only load when the agent needs deep knowledge. This means you can have dozens of skills without burning tokens at idle.

Security Rules for Skills

• Always check the VirusTotal report on ClawHub before installing
• Review source code before installing (or have Claude Code inspect it)
• Prefer skills from the curated awesome-openclaw-skills list (7,800+ stars)
• Write your own for anything touching credentials or client data

Memory Management: The Make-or-Break

This is where most OpenClaw setups die. Not security, not API costs — memory bloat.

The Weekly Review Pattern

Set up a heartbeat task (in HEARTBEAT.md) that runs weekly:

## Weekly Memory Review (Sundays)
- Review past 7 days of memory/*.md files
- Update MEMORY.md with significant decisions and learnings
- Move completed project info to archive
- Clean up stale daily logs older than 30 days
- Check memory/clients/ files are current

What Goes Where

The Compaction Safety Net

When a session gets long, OpenClaw auto-compacts (summarizes) the conversation to stay within the context window. Before it does, it triggers a silent turn that tells the AI to write anything important to memory files first. This is your safety net — but don't rely on it exclusively. Explicitly tell the agent to "remember this" for anything important.

Phased Rollout Plan

Phase 1: Personal Assistant (Week 1-2)

Single agent. Telegram connected. Core capabilities only.

Focus:

• Morning briefings (email, calendar, priorities)
• Research on demand
• Note-taking and memory building
• Get comfortable with the interaction patterns

Measure: Are you actually messaging it daily? Is it remembering context across sessions?

Phase 2: Business Operations (Week 3-4)

Same agent, expanded capabilities.

Add:

• gog skill for Google Workspace
• Client memory files populated
• HEARTBEAT.md with recurring check-ins
• Content drafting using david-voice skill

Focus:

• Client status tracking
• Email triage and drafting
• Content creation in your voice
• Weekly business summaries

Measure: Is it saving you time? Are the memory files staying clean?

Phase 3: Project-Specific Expansion (Month 2+)

Still potentially one agent, but with deep skills for specific domains.

Add based on what you're actually using:

• Polymarket skill (if you're building the trading bot)
• HomeOps product skill (development context)
• AEO/content skill (for client content work)
• Browser automation (for research/monitoring)

Measure: Are you hitting context limitations? Is the agent confusing client A's context with client B's?

Phase 4: Multi-Agent (Only If Needed)

Split into separate agents only when you hit real isolation needs.

When to split:

• Client work context is bleeding into personal tasks
• You need an agent running autonomously (like a trading bot) that shouldn't share memory with your general assistant
• Different channels need fundamentally different personas

How it works: Each agent gets its own workspace, its own memory, its own skills. You route channels to agents via bindings in openclaw.json. The default agent handles anything without a specific binding.

Agent "Atlas" (primary)
  → Telegram DMs, WhatsApp
  → All business ops, client work, content
  → Workspace: ~/clawd/

Agent "Trader" (specialized, only if needed)
  → Dedicated Telegram bot
  → Polymarket only, isolated credentials
  → Workspace: ~/clawd-trader/

Agent "Builder" (specialized, only if needed)
  → Triggered by Claude Code or dev channels
  → Product development context only
  → Workspace: ~/clawd-builder/

But don't do this on day one. The community consensus is clear: premature multi-agent setups create configuration complexity that derails the whole thing. One well-configured agent handles most solo founder needs.

The Pi as Failover

Your Raspberry Pi becomes your backup brain:

• Keep a minimal OpenClaw install on the Pi
• Point it at a different Telegram bot (e.g., @david_backup_bot)
• Give it read access to the same memory files (via shared NFS or synced folder)
• If the Mac mini goes down for maintenance or updates, message the backup bot

Or repurpose it entirely:

• Home Assistant for smart home stuff
• Monitoring/alerting for your Mac mini (is it still responding? Is the gateway running?)
• Lightweight cron jobs that don't need OpenClaw

Maintenance Habits

Daily: Just use it. The daily logs build themselves.

Weekly: Glance at MEMORY.md. Is it still accurate? Is it getting bloated? Prune anything stale. Check that client files are current.

Monthly: Review your skills. Are you using all of them? Any that should be removed? Check API spending. Archive old daily logs. Review SOUL.md and AGENTS.md — do they still reflect how you want the agent to behave?

After every major decision: Tell the agent to write it to MEMORY.md. Don't trust it to figure out what's important on its own. "Remember that we decided X because Y" is a habit worth building.

What This Gets You

By the end of month one, you have an always-on AI assistant that:

• Knows your clients, your projects, your preferences
• Handles email triage and calendar management
• Drafts content in your actual voice
• Tracks business operations across multiple projects
• Gets smarter over time as memory accumulates
• Runs on a $70/month machine that draws less power than a light bulb

By month three, you have the foundation to expand into autonomous operations — trading bots, content publishing, client monitoring — each in its own isolated lane, sharing a common infrastructure.

That's not Web4.ai promising superintelligent life on a broken website. That's a Mac mini on your desk actually doing the work.

Built for OpenClaw on Mac mini M4. Architecture current as of February 2026. Things move fast in this ecosystem — validate against the official docs at docs.openclaw.ai before implementing.