50 days with OpenClaw: The hype, the reality & what actually broke

High-level summary

This is a 50-day field report from an early OpenClaw user who ran a persistent, self-hosted AI agent daily (early names: ClawdBot, MoltBot; now OpenClaw). The report functions as a long-form usage guide and honest review: setup recommendations, 20 concrete real-world use cases, what breaks, mitigation strategies, and a practical starter pack.

Core recommendations from experience: - Markdown-first: keep plain-text files in Obsidian to avoid vendor lock-in. - Separate contexts: use one channel per workflow. - Match model to task: use Opus for deep reasoning and cheaper models for routine work.

What OpenClaw is (technical/product overview)

• An always-on autonomous agent that runs on your server, VPS, Mac Mini, or Raspberry Pi.
• Integrates with messaging apps: Discord, Telegram, WhatsApp, iMessage.
• Extensible via:
  • Skills (ClawHub)
  • Cron jobs and subagents
  • Multi-model routing
  • File-based memory (markdown)
  • Nightly semantic indexing (QMD)
  • Integrations: APIs, Whisper, Excalidraw, Google Places, TRMNL e-ink
• Prompts, example configs, and setup guides are on GitHub. The author created a setup video that became part of the official docs and also built Clawdiverse.com to catalog community use cases.

Practical starter pack (what to deploy first)

Start with a small set of automations to get value quickly:

• Draft-only email triage with urgent alerts (agent reads and drafts but does not send).
• Daily morning briefing written to a markdown file (personalized brief saved to Obsidian).
• One Discord inbox channel for dropping links and messages (agent enriches and routes content).
• Bonus: bookmarks managed by the agent — drop a link and the agent summarizes, tags, and saves it to Obsidian (the author replaced Raindrop with this workflow).

Top architectural choices and patterns

• Markdown-first, file-based memory stored in Obsidian for portability and human readability.
• Discord migration strategy: channels-as-workspaces (separate contexts) and per-channel model routing to control cost and fit-for-purpose behavior.
• Subagents: an orchestrator spawns parallel subagents with their own contexts for robust research or long-running tasks (reduces main-context compaction).
• Regular cron jobs: auto-update skills, restart the gateway, and nightly backups of config/skills/memory to enable quick recovery.

20 representative use cases (grouped)

1) Background / always-on automation - Morning tweet/briefing scan → top items appended to Obsidian; auto video idea suggestions. - Heartbeat checks every 30 minutes (emails, calendar, services) → alerts for issues like billing failures or domain expiry. - Auto-updates and daily backups (restore in roughly 30 minutes).

2) Personal ritual / display - Daily “On This Day” woodcut-style images pushed to TRMNL e-ink display (with a quiz/mystery mode).

3) Research & content creation - Parallel research agents scraping Twitter, Reddit, Hacker News, YouTube, and forums → structured research files, outlines, and ranked video ideas (50+ pages produced for the author’s video). - YouTube analytics channel: natural-language queries over API data, synthesis, and recommendations. - Video idea research channel: accumulate sources/notes over weeks; the agent enriches snippets into usable outlines.

4) Summarization & knowledge capture - Summarize any URL/PDF/video into concise notes and save to Obsidian. - Bookmark ingestion and enrichment: agent replaces a paid bookmarking service and builds a knowledge graph in markdown.

5) Infrastructure & DevOps - Server inspection and fixes via API (kill zombie processes, restart apps, repair cron jobs, migrate packages). - Remote code fixes: create PRs, implement features, or debug from mobile (major dev work still done on desktop).

6) Daily-life assistant & family - Email triage and draft replies (human approval required before sending). - Calendar and event scheduling (e.g., family group scheduling via WhatsApp). - Voice-note transcription (Whisper), shopping/shop-finding with Google Places, weather alerts, reminders, and rehab exercise guidance.

7) Fun / experimental projects - Honeypot fake WordPress login page to detect bots (deployed automatically). - Auto-generated Excalidraw diagrams and architecture visuals produced on demand. - Home Assistant integration in progress for voice/chat control of lights, climate, and routines.

Community & extended use cases

People in the community use agents for:

• Running businesses (quoting, invoicing, lead gen)
• Controlling 3D printers
• Connecting to cars/Teslas
• Making voice calls and fact-checking live speakers
• Deploying from smartwatches

Clawdiverse.com catalogs community projects and use-case examples.

Failures, limitations, and concrete problems

• Memory loss / context compaction:
  • OpenClaw can silently compact conversation history and “forget” mid-conversation.
  • Mitigations: write important facts to files, use QMD semantic search, manage session boundaries, and launch subagents to isolate work.
• Cost reality:
  • Opus is expensive; multi-model routing is required (Opus for heavy reasoning, cheaper models for heartbeats and subagents).
  • The author provides a cost calculator and optimization tips.
• Tasks needing babysitting:
  • Complex multi-step browser automation and flaky extension sessions are brittle; the agent often performs better as an assistant than a fully autonomous executor.
• Security / prompt injection:
  • No foolproof general solution yet. Recommended practices: treat inbox content as potentially hostile, use draft-only modes, maintain allow/deny command lists, use Tailscale/VPN for connectivity, and run regular security audits (ClawHub security checks).
• Setup difficulty:
  • Rated around 7/10 — requires technical familiarity and security awareness.

Author’s scoring (subjective)

• Setup difficulty: 7/10
• Daily value once running: 9/10
• Reliability for simple workflows: 8/10
• Reliability for complex/browser workflows: 5/10
• Favorite features: Discord channel architecture with per-channel models; file-based markdown memory + nightly semantic indexing.
• Biggest pain: memory / context compaction.

Practical mitigations and tips

• Keep everything in plain markdown files (Obsidian) and run nightly embedding/indexing with QMD for semantic search.
• Separate workflows into channels and route routine tasks to cheaper models.
• Use subagents for heavy or multi-step tasks so the main context remains small.
• Maintain a strong security posture: run on private networks, restrict capabilities, run audits, and use draft-only modes for sensitive actions.
• Start small: pick 3 automations (email triage, daily briefing, Discord inbox + bookmarks) and iterate from there.

Resources mentioned

• GitHub repo with prompts and example configs (links noted by the author).
• Setup video (used to create official docs).
• ClawHub (skills) and Clawdiverse.com (community catalog).
• Tools/integrations referenced: Obsidian, QMD embeddings, Whisper, Excalidraw, TRMNL e-ink, Google Places, Tailscale.

Main speakers / sources

• Video narrator/author: an early OpenClaw adopter and creator of setup materials (unnamed in the transcript).
• Platforms and tools referenced: OpenClaw (ClawdBot / MoltBot history), ClawHub, Clawdiverse.com, GitHub (prompts), Obsidian, Opus model, Claude Code, Whisper, Excalidraw, TRMNL e-ink, Google Places, Tailscale.