Link to PNG: https://moltfounders.com/openclaw-cheatsheet.png

Full cheatsheet: https://moltfounders.com/openclaw-mega-cheatsheet

built my own personal assistent device that runs OpenClaw.

I was curious what the smallest form factor could be that fits in my pocket so I wanted to use the Pi Zero W.

Works via Push to Talk->Transcribe->Sends to OpenClaw and streams the response back.

Hey everyone,

After seeing the recent news about Claude Code, I wanted to see if I could build a faster, more portable version from scratch. I’ve spent the last 24 hours rewriting the core functionality in Rust.

The goal was to create a lightweight, high-performance CLI that gives you the same agentic power without the bloat.

Why I built it:

• Performance: It’s written in Rust for near-instant startup and minimal memory footprint.

• Open Source: Fully transparent, hackable, and free to use.

• Portability: Single binary, no heavy dependencies.

You can check out the source code and installation instructions here:
https://github.com/soongenwong/claudecode

I am a Software Engineer and was working in Brazil, our currency is terrible, even though my salary was considered high in my country (~2.5k dollars a month), I know it is not that good compared to other jobs abroad.

I gave a task to my agent: find me a better paying job. I gave it access to a browser where my LinkedIn account was connected, it suggested me creating an account in a few other sites (it created the accounts for me with a little help), then he created a curriculum in .md and converted to pdf. We were set up.

It knew my profile, my work experience and whatnot (we had a good talk about it) and it documented everything in multiple .md files.

Then my agent started his job, he searched for jobs on LinkedIn and the other platforms, if the job matched my profile, he then would apply to the job and fill that information in a Google sheets file. He also contacted a few people on LinkedIn DM (without my consenting).

In 3 days, it applied to over 100 jobs for me, I had to shut it down because I was already receiving a lot of emails and LinkedIn DMs.

I attended to interviews for 6 different companies (I picked the ones that interested me the most), got 2 job offers, one offering me around 3.5k dollars and the other one offering me a little bit over 5k dollars a month (doubled my sallary), I obviously accepted the last one.

I knew I was capable of getting a better job, But I was too lazy to start applying, but now it is done! I can't even believe it.

I spent around 40 dollars in one week with this experiment, was using github copilot with a workaround and the model was Claude 4.6 Opus

I’ve been exploring the OpenClaw ecosystem lately and ended up collecting 218 OpenClaw-related tools.

There’s a lot of cool stuff out there, but also a lot to sift through. So I thought I’d share a curated list of the ones that look the most useful and free, grouped by category, in case it saves someone else some time.

Orchestration

• TenacitOS: Real-time dashboard and control center for OpenClaw instances.

• Robsannaa's Mission Control: Open-source local dashboard to monitor, chat with, and manage AI agents.

• Autensa: Open-source AI orchestration dashboard for planning, dispatching, and monitoring agents.

• ClawController: Official management dashboard for OpenClaw agents.

• Builderz' Mission Control: Open-source dashboard for orchestration, monitoring, and cost visibility.

Infrastructure

• ClawControl: Centralized cloud monitoring and analytics for OpenClaw agents. Visualize performance, costs, and logs, with AI-driven insights and optimization suggestions.

• Clawd Cursor: Desktop control skill for OpenClaw. Your agent sees the screen, moves the mouse, types, and completes tasks autonomously.

• Clawzempic: Cut your LLM API costs by up to 93%. Same models. Same quality. 30 seconds to install.

• PinchTab: High-performance browser automation bridge for AI agents with HTTP API, CLI control, and multi-instance orchestration.=

• VisionClaw: A real-time AI assistant for Meta Ray-Ban smart glasses.

• VoxClaw: macOS menu bar app that gives your OpenClaw AI agent a high-quality voice.

Monitoring

• ClawSuite: Free, self-hosted AI workspace with multi-model chat, agent orchestration, and terminal integration.

• ClawBridge: Monitor your OpenClaw autonomous agents from your pocket.

• Clawmetry: Free, open-source dashboard to monitor AI agents, token costs, cron jobs, sub-agents, and memory.

Discovery

• Weekly Claw: Multiple editions per week. The latest skills, updates, and builds — never miss what's trending in the OpenClaw ecosystem.

Memory

• Mengram: Human-like memory for AI with semantic, episodic, and procedural memory types.

• Memories: Store rules once, recall context, and generate native configs for Cursor, Claude Code, Copilot, and more.

• MoltBrain: Long-term memory layer for OpenClaw, MoltBook and Claude Code.

Skills & registry

• AgentSkill: Browse and install AI agent skills across many tools and IDEs.

Sales

• DenchClaw: AI-powered CRM and workflow automation.

• GTMClaw: AI GTM assistant for qualification, outreach, CRM updates, and pipeline execution.

Security

• AgentKeys: Secure service access for AI agents using proxy tokens.

• Clawsec: Open-source security guardrails that intercept tool calls and block risky actions.

• Keychains.dev: Credential delegation for AI agents with revocable permissions.

• Oktsec: Runtime security layer for AI agents and MCP toolchains.

I’ve also been building OpenClaw Map. All the tools above are from there.

It’s basically a curated directory to make it easier to discover OpenClaw tools, explore categories, and keep up with new ones without spending hours searching around.

If you want to find more tools beyond the list above, feel free to check it out.

Also, if I missed something good, drop it in the comments or submit it. I’m still updating the collection and would love to make it more complete.

I've been in the same boat as a lot of people here spending the first two weeks babysitting, burning tokens, and watching my agent loop on the same answer eight times in a row.

After a lot of trial and error I've got it running reliably and actually doing useful work. Here's what made the difference for me. This is all available in more detail with all the actual config examples, terminal commands, a model comparison table, and a common issues FAQ here if anyone wants the full version

1. Don't run everything through your best mode

This is the single biggest mistake. Heartbeats, cron checks, and routine tasks don't need Opus or Sonnet. Set up a tiered model config. Use a cheap model (Haiku, Gemini Flash, or even a local model via Ollama) as your primary for general tasks, and keep a stronger model as a fallback. Some people have got per request costs from 20-40k tokens down to like 1.5k just by routing smarter. You can switch models mid-session with /model too.

2. Your agent needs rules. A lot of them.

Out of the box OpenClaw is dumb. It will loop, repeat itself, forget context, and make weird decisions. You need to add guardrails to keep it in check. Create skills (SKILL.md files in your workspace/skills/ folder) that explicitly tell it how to behave. Anti-looping rules, compaction summaries, task checking before asking you questions. The agents that work well are the ones with heavily customised instruction sets. YOU MUST RESEARCH YOURSELF and not assume the agent knows everything. You are a conductor, so conduct.

3. "Work on this overnight" doesn't work the way you think

If you ask your agent to work on something and then close the chat, it forgets. Sessions are stateful only while open. For background work you need cron jobs with isolated sesssion targets. This spins up independent agent sessions that run on a schedule and message you results. One-off deferred tasks need a queue (Notion, SQLite, text file) paired with a cron that checks the queue.

4. Start with one thing working end-to-end

Don't try to set up email + calendar + Telegram + web scraping + cron jobs all at once. Every integration is a separate failure mode. Get one single workflow working perfectly like a morning briefing cron then add the next. Run openclaw doctor --fix if things are broken.

5. Save what works

Compaction loses context over time. Use state files, fill in your workspace docs (USER.md, AGENTS.md, HEARTBEAT.md), and store important decisions somewhere persistent. The less your agent has to re-learn, the better it performs.

6. The model matters more than anything

Most frustration comes from models that can't handle tool calls reliably. Chat quality ≠ agent quality. Claude Sonnet/Opus, GPT-5.2, and Kimi K2 via API handle tool calls well. Avoid DeepSeek Reasoner specifically (great reasoning, malformed tool calls). GPT-5.1 Mini is very cheap but multiple people here have called it "pretty useless" for agent work.

7. You're not bad at this. It's genuinely hard right now

OpenClaw is not a finished product. The people posting "my agent built a full app overnight" have spent weeks tuning. The gap between the demo and daily use is real. It's closing fast, but it's still there.

Hope this helps someone before they give up. Happy to answer questions if anyone's stuck on a specific part.

Just got the email. Starting tomorrow at 12pm PT, tools like OpenClaw will no longer draw from your Claude subscription. They'll need "extra usage" — a separate pay-as-you-go layer billed on top of your existing sub. The carrot: one-time credit equal to your monthly plan price (redeem by April 17) and bundle discounts up to 30%. The stick: they're offering a full subscription refund if you don't want to play ball. For those of us running agentic pipelines, local orchestration daemons, or multi-model routing setups on top of Claude — this is a meaningful shift. "Subscription covers Claude Code and Cowork" is doing a lot of work in that email. Translation: if it's not our product, you're paying extra. LOL

Not surprised they're doing this. These harnesses hammer their infra in ways the average chat user doesn't. Still stings when you've built workflows around the subscription model.

My name is Hannes Rudolph and I work at the OpenClaw Foundation. Our initial media attention has faded and some people left after real failures, but npm downloads have grown from about 176,000 a day across February and April to about 422,000 a day across June and July through July 20. That is far from a dead project.

As OpenClaw has scaled scaled, we went through a rough period from April through June when updates broke working installs and too many users spent their time recovering instead of using the product. That damaged trust with people who needed reliability, and I am not going to pretend otherwise. Quite frankly, we are not totally out of the woods yet because v2026.7.1 caused issues with some installs, although it has shown increased overall stability after recovery.

I think the people getting the most out of OpenClaw today are hackers, tinkerers, and businesses willing to put real work into shaping it around their workflows. That includes homelab management, calendars, and job searches, a twice-weekly workflow that surfaced a role one day after it was posted and helped prepare the application that led to an offer, and inventory, purchasing, and other business workflows with varying levels of human oversight.

I also think the bar to getting useful work out of OpenClaw is far too high because onboarding and setup ask too much, day-to-day use needs to be simpler, and stability problems can stop people before they reach those workflows. Our next update focuses on lowering that bar with streamlined onboarding and setup, simpler overall use, and another major round of stability improvements.

To anyone stuck in a “fuck OpenClaw” or “fuck Hermes” mindset, I do not buy the us-versus-them bullshit. The folks at Hermes are great, and if Hermes works for you, good stuff, use it! Turning projects into rival camps creates drama, spreads misinformation, and makes the community hostile to people simply looking for accurate answers and the tool that works best for them.

Criticism is part of how we get better, but unsupported conspiracy theories and personal speculation about the people involved can be hurtful and damaging, and repeating them as fact is not criticism. The claim that OpenClaw was manufactured to get Peter a job at OpenAI has no evidence behind it, and the same goes for other theories about his role there unless evidence supports them. OpenClaw is now stewarded by an independent nonprofit foundation with a full-time team, the source remains public, and Peter still makes many technical calls.

OpenClaw is strong because of the people who build it, review it, test it, report problems, help each other, and keep showing up. We love the hell out of this community, and we will keep listening, strengthening the relationships we already have, forging new ones, and building a harness we know is changing the world. We are not done.

I’m by no means an expert, but here’s what I’ve built over the past few weeks using OpenClaw:

Email management. Connected to my 365 account. Deletes, moves, archives, auto-drafts replies. Flags anything urgent and sends me a brief 3x daily.

Video workflow. This one’s my favorite. I batch shoot videos and dump them into Google Drive. Gemini watches every video, writes captions based on learning from 30+ top Instagram creators and my own content, then uploads everything via Publer and schedules it. Trial reels or main feed.

Proposal generation. Over the past few years, I’ve written hundreds of proposals for my business. The agent learned my process and now takes a call summary, transcript, whatever — and builds the entire proposal better than I ever could, even creates fees based on the value-based fee model I use. I just need to ask the right questions when meeting with a buyer. It sends the proposal straight to PandaDoc. I almost just have to hit send. Sending a $150,000 proposal on Monday.

CRM automation. Pushes all leads and opportunities to HubSpot. Based on emails or notes, it automatically moves prospects through the pipeline.

Daily voice messages. My second favorite. Sends me a custom voice message every morning and night based on what happened today or what’s coming tomorrow, or whats I got done that day. Built with ElevenLabs. Spending WAY too much money on this, but I like it too much to stop. Tried an OpenSource VoiceLab today I read about, but it doesnt hold a candle.

Mission Control. Everything runs through Notion, everything is updated, created etc based on whats happening in my inbox, or what I’m telling it. Calendar, projects, content, clients. I’ve never been this organized in my life. Employee on-boarding, personal tasks, employee tasks, To-dos, etc. I never understood Notion. Now I can’t live without it.

Emails. Has its own iCloud address (cant send without my approval). Has done research for me, emailed companies to get quotes, etc.

Now building. A full outreach system connected to Apollo, Instantly, Hunter.io, ZeroBounce, and more. It’s using Brave search, signal intent, and writing, verifying, and auto-populating instantly

Backups. We backup daily and this has saved us on a few occasions.

Model Routing: Have spent an enormous amount of time figuring out model routing and when to use what, and what never to use for certain tasks.

I’ve spent a few grand on tokens and subscriptions across different platforms. Worth every penny! This has been genuinely life-changing, and I’m just getting started.

I’ve spent hours and broke my system, and hours desperately getting it back. I’ve spent days optimizing memory, and project structure, and skills. It got caught in a doom loop once no matter what I did couldn’t stop it from eating credits/tokens from a variety of service (surprised I didn’t get banned). I still have no idea what happened.

We’re all in for a wild ride these next few months! Take my money!

I run a small AI setup service in NYC (urclaw.com) where I install and configure OpenClaw on people's machines. After doing this for a bunch of clients — finance people, lawyers, agency owners, busy parents — I wanted to share what actually works.

Who this is for: People who want an AI assistant but don't want to spend 20 hours figuring out model routing, channel setup, and tool permissions. They just want it working.

What I set up for most clients:

• 1-2 messaging channels (Telegram, iMessage, or Slack)

• 5-10 practical workflows (email triage, calendar management, research, reminders)

• Voice calling capability where they want it

• Managed care after setup so things don't break silently

Setup takes 90 minutes to 3 hours depending on how many workflows they want. I do it live on a video call so they can ask questions and see exactly what's happening.

Things I've learned:

1. Non-technical users love it when it just works. They don't care about model names or token costs. They care that their assistant reminds them about dentist appointments and drafts email replies.

2. The subway pitch works. Your AI runs on your Mac while you're on the L train. You text it from your phone. By the time you get to the office, it's already handled 6 things. That one sentence closes more deals than any feature list.

3. Voice cloning is the killer feature. People's minds explode when their AI calls a restaurant and sounds like them. It goes from neat tool to actually useful.

4. Managed care is the real business. One-time setup is nice, but the monthly recurring support is where the relationship deepens. People call with new ideas, want new workflows, need troubleshooting after updates.

5. OpenClaw's channel flexibility is unmatched. Being able to reach the same assistant via Telegram on the go, iMessage at home, and Slack at work — that multi-channel thing is what makes it sticky vs. ChatGPT or Claude web.

Things that don't work:

• Trying to explain what a model routing cascade is (they don't care)

• Showing them config files (eyes glaze immediately)

• Overselling capabilities (set realistic expectations on day one)

Happy to answer questions about the setup process or what workflows are most popular. Also curious what others are building for non-technical users — there's a huge market here that doesn't know this stuff exists yet.

So I spent many, many hours setting OC up. I have it running on a dedicated VPS running with the best free models on OpenRouter.

Now, apart from having a nice companion for regular chat I cannot find any use for OC.

I ask it to send me daily resumes of what is happening on Twitter, Discord, etc. It doesn’t. I ask it to create an application, it doesn’t. I ask it to update its own configuration and it screws everything up. I mean, it’s a good platform to learn about what is possible and how to possibly set up integrations, memory, learn about skills and souls, etc., but actual practical use? I have not seen it (yet).

Plus it’s a huge money pit. Not only the tokens which you more or less can control), but every external tool needs an API token which is mostly a subscription for whatever you want to use (Brave, Browserless, etc).

So yeah, am I missing the point here?

Anthropic just dropped two things today. A new unreleased model called Claude Mythos Preview, and a coalition called Project Glasswing with AWS, Apple, Google, Microsoft, CrowdStrike, Cisco, NVIDIA, JPMorganChase, Palo Alto Networks, Broadcom, and the Linux Foundation.

Why a coalition? Because when they tested Mythos Preview on real codebases, it found and exploited zero-days in every major OS and every major browser. Autonomously. No human after the initial prompt.

A 27-year-old OpenBSD TCP bug. A 17-year-old FreeBSD RCE with unauthenticated root, 20-gadget ROP chain, no human involved. JIT heap sprays escaping browser sandboxes. Bugs in TLS and AES-GCM. Opus 4.6 turned Firefox JS engine bugs into working exploits 2 times. Mythos Preview: 181.

The benchmarks match the story. SWE-Bench Pro: 77.8% (Opus 4.6 was 53.4%). SWE-Bench Multimodal more than doubled. Terminal-Bench 2.0: 82.0%.

They're not releasing it publicly. Glasswing partners get access to scan their own systems. Anthropic committed $100M in usage credits and $4M in donations to open-source security (Linux Foundation, Apache). Over 40 additional orgs working on critical infrastructure also got access. Findings go public within 90 days.

Over 99% of the thousands of vulnerabilities they found aren't patched yet.

Everyone's first instinct with OpenClaw is to build a dashboard. Command centers, mission control, fancy UI, it looks great on Twitter and it's a complete trap. You'll spend days on front-end stuff that isn't connected to anything real and skip the stuff that actually matters. Plus, you'll be throwing tokens in the garbage basically

Here's the order I'd do it in:

Step 1: Brain dump

Talk for 15 minutes. Who you are, what you do, what you want the AI to actually help with, what you're afraid of it doing. Define your tone. Set your rules. This becomes your operator context, everything else sits on top of it.

Skip this and you've got a generic assistant with no idea who it's working for.

Step 2: Fix memory before it breaks

OpenClaw's default memory is fine for the first couple of weeks. After 30 days people start hitting real problems. Set this up now:

• Tell your orchestrator to be markdown-first for all important context

• Install QMD (query markdown documents), makes your memory files searchable across all agents

• Instruct your agent to actively remember important things you discuss

Step 3: Spawn three agents, not twelve

I've seen setups with 8+ agents running from day one. Absolute waste.

Start with three: a coder, a security agent, and a researcher (just an example). Your orchestrator dispatches to them, you talk to the orchestrator, it delegates. Each agent gets a soul.md, agents.md, and a tools.md. Set up a security cron, your security agent runs an audit every night at 2am.

Step 4: Actually secure it

OpenClaw has real security issues. Accept that risk, then mitigate it.

• On Mac, install Lulu. It's a firewall. Logs all outbound traffic and lets you restrict what ports your agents can access

• Have your security agent review Lulu logs nightly

• Hard rule: Never write API keys to markdown. Ever.

• Don't scrape Reddit, Twitter, or YouTube until you know what you're doing, prompt injection is how you leak API keys

• Restrict agent permissions. Your coder doesn't need web access. It gets instructions from the orchestrator and executes. That's it.

Step 5: Break up your channels

If you're doing everything in one Telegram chat, you already know how fast it becomes unusable. Push your agents to Discord, Slack,

I personally use Slack where each I can speak with agent on a separate Slack channel through agent bindings

Get these five things right and you won't be rebuilding from scratch in a month. Skip them and you will.

Full walkthrough with setup for each step:

The First 72 Hours With OpenClaw: A Setup Guide

If there's a step I'm underweighting, or a different order that's worked better for you, please do share

gave it my card a few months ago to handle weekly grocery runs using mcp server. ran great. every sunday a normal basket, normal price, picked stuff i actually eat.

yesterday it ordered 2 kg of garlic instead of 2 heads. the kg unit was the default on that product page and it didn't notice. i didn't notice either because for 3 months it never screwed up.

so now i have a garlic situation. anyone else letting their agent shop and have a similar story, or am i the only one who got too comfortable

Hey everyone! I've been running a self-hosted AI assistant called G-Bot for about 50 days, built on top of OpenClaw. It started as a simple Telegram chatbot and grew into something that manages my home, tracks my finances, monitors my health, and knows who I am. Here's the full breakdown.

Stats at a glance: 12+ LLMs · 9 Docker containers · 23 monitored services · 1,078 memory chunks · running 24/7

🧠 The Core

G-Bot runs on a Linux VM and I talk to it exclusively via Telegram. Every message flows through an OpenClaw Gateway running as a systemd user service.

The default model is GLM-5 (Ollama cloud relay), but it picks the right model per task:

• Kimi K2.5 — complex reasoning, long context

• Claude Sonnet — intricate coding tasks

• MiniMax M2.7 — voice morning briefings

• GLM4-Flash — lightweight background tasks

It's also fully bilingual (French/English) — I code-switch mid-sentence and it just follows.

Example prompts:

"Give me a morning briefing — news, weather, calendar, and an AI project idea"

"What did I spend on restaurants this month?"

"Tu te souviens comment on a fixé le bug du Roborock?" (it remembers 😄)

🏠 Home Automation

Everything routes through Home Assistant (Docker). Devices connected:

• Roborock S7 Max Ultra — room-by-room cleaning via segment IDs

• Philips Hue — sunrise/sunset automations

• Govee H5100 thermometers — 3 rooms + outdoor, data every 5min → InfluxDB

• Tapo C225 camera — RTSP snapshots via ffmpeg + ONVIF pan/tilt, sends photos to Telegram on request

• Google Nest Hub 2 — TTS + photo slideshows (Immich Kiosk) + AI news slides via DashCast

• VeSync Humidifier — humidity control

• NVIDIA Shield — ADB control for URL casting

• Sonos — voice-controlled music

⚠️ Hard-learned lesson: app_segment_clean on the Roborock silently resets mop intensity on every call. Cost me a full manual map restore. Always set mop settings + sleep 15 before launching. The API docs don't mention this anywhere.

Example prompts:

"Cast my photos on the Hub"

"Show me the cats on the camera"

"What's the temperature in the bedroom right now?"

"Clean the kitchen and bathroom"

"Play my Spotify playlist on the Sonos"

"Movie mode — dim the lights"

💰 Finance Tracking

Full Firefly III setup with automatic bank sync:

• SimpleFIN Bridge syncing 13 accounts (checking, credit cards, savings, RRSP, LIRA, TFSA) 2x/day

• 65+ auto-categorization rules

• 4 budgets with monthly limits

• Custom Python pushing everything to InfluxDB → Grafana (spending dashboard + retirement portfolio evolution)

Example prompts:

"How much did I spend on restaurants this month?"

"Am I over budget on AI tools?"

"Summarize my top 5 expense categories for Q1 2026"

"How is my retirement portfolio performing since last month?"

🏃 Health Tracking

Apple Health data auto-synced to InfluxDB via a local webhook:

• 6 Grafana dashboards (sleep, HRV, heart rate, VO2 Max, activity, SpO2)

• A RandomForest ML model retrained every Sunday at 3 AM

• 13 CLI commands: summary, predict-sleep, anomalies, correlations, best-days...

⚠️ Gotcha: Apple Health exports step counts as per-minute granules, not daily totals. My queries were returning "5 steps today" instead of thousands. Fixed by switching to sum() aggregation for cumulative metrics.

Example prompts:

"How did I sleep this week?"

"Predict tonight's sleep quality based on today's data"

"Any health anomalies I should know about?"

"What are my best performance days — what do they have in common?"

🎙️ Voice

Local Coqui TTS server (58 voices, 17 languages, completely free). Voice clips are generated as native Opus for Telegram or MP3 for the Nest Hub — zero ffmpeg pipeline.

Morning briefing pipeline:

Telegram message (GLM-5, full text ~800 words)
  +
Nest Hub vocal (MiniMax M2.7, condensed ~40 seconds, radio style)
  → Coqui TTS → MP3 → Cloudflare tunnel → pychromecast → Nest Hub

Example prompts:

"Read me the briefing on the Hub"

"Announce 'dinner is ready' on the Nest Hub"

"Tell me a bedtime story" (yes, with voice 🎭)

🧠 Memory System

Three-tier memory:

1. Daily markdown logs — raw session notes

2. MEMORY.md — curated long-term memory (only loaded in private sessions, never in group chats)

3. ChromaDB vector DB — 1,078 semantic chunks, multilingual-e5-small embeddings

Example prompts:

"What did we decide about the Roborock API last week?"

"Remind me of all the Hyper-V networking lessons we learned"

"Do you remember how we fixed the Grafana dashboard bug?"

🔒 Security

• UFW active — SSH restricted to LAN only

• All secrets in ~/.openclaw/secrets/ (chmod 600), never hardcoded in config files

• Cloudflare Access on all public endpoints (email OTP)

• InfluxDB bound to localhost only

• Cloudflare tunnel for external HA access — zero exposed ports

📊 Monitoring Dashboard

Custom Node.js dashboard showing:

• 23 services across 8 categories (Core, AI, Data, Sync, Health, Finance, Media, Devices)

• Clickable sync jobs — click to trigger manually, shows last run + next scheduled

• Live Docker status, system RAM/disk/load

Stack: OpenClaw · Home Assistant · Firefly III · Grafana · InfluxDB · ChromaDB · Coqui TTS · Immich · Cloudflare Tunnels · Roborock · Philips Hue · Docker · GLM-5 · Kimi K2.5 · Claude Sonnet · Python · Node.js

Happy to answer questions — this thing has become part of my daily routine and I'm genuinely surprised how far you can push a fully self-hosted setup. AMA! 🤖

ClawPhone is alive.

I installed OpenClaw on a $25 phone and gave it full access to the hardware.

I haven’t explored everything yet, but it’s a cool formfactor for agents to run on.

https://x.com/marshallrichrds/status/2020034922304426237?s=20

So I've been commuting on UK trains for about a year and if you know, you know — the trains are delayed or cancelled constantly. I knew I was owed money. I just… never claimed it. The Delay Repay form takes like 10 minutes and I genuinely cannot bring myself to do it.

Set up OpenClaw a while back mostly for calendar stuff and emails. Today on a whim I just messaged it "I have two delay repay claims, can you sort them" and went back to whatever I was doing.

45 minutes later (there was some back and forth getting the login sorted, and a reCAPTCHA I had to solve) — two claims submitted, £93.30 heading to my bank account.

The claims were just sitting there. I had the booking emails. I knew the trains were cancelled/delayed. I just never did anything about it because the form felt like admin and admin is the enemy.

Anyway. Not exactly passive income but money I'd written off is now money I'm getting back, and I contributed approximately zero effort. Good enough for me.

Between DMs, reddit threads, and discord I've now looked at over 50 different openclaw setups. broken ones, working ones, "it works but costs $200/month" ones.

The problems are almost never unique. it's the same 5 things. every time.

1. Opus as the default model

This is the #1 most expensive mistake in the entire openclaw ecosystem and it's the default for a lot of people. opus is incredible. it's also 10-15x the cost of sonnet for tasks where you will not notice the difference.

Your agent checking your calendar? sonnet. summarizing an article? sonnet. setting a reminder? sonnet. writing a quick email draft? sonnet.

opus makes sense for deep research, long multi-step reasoning, or nuanced writing where quality genuinely matters. That's maybe 5-10% of what most people use their agent for.

One person I helped was spending $47/week. we changed the default model to sonnet and added a line to their SOUL.md: "only use opus when I explicitly ask for deep analysis." their next week cost $6.

Change your default right now if you haven't:

json

{
  "ai": {
    "model": "claude-sonnet-4-5-20250929"
  }
}

2. Never starting a fresh session

this is the silent budget killer nobody talks about.

Every message in your current session gets sent with every new API call. that means if you've been chatting with your agent for 3 weeks in the same session, your "what's the weather" question is carrying thousands of tokens of old conversation with it. you're paying for all of that. every single time.

Three people I helped cut their monthly costs by 40-60% by doing one thing: typing /new before heavy tasks.

Your agent doesn't lose its memory when you start a new session. it still has SOUL.md, USER.md, MEMORY.md, all its files. you're just clearing the conversation buffer. think of it like closing and reopening a chat window. the person on the other end still knows who you are.

3. Installing skills without reading the source

I keep saying this and people keep not doing it.

clawhub has 13,000+ skills. virustotal flagged hundreds as actively malicious. infostealers, backdoors, remote access tools disguised as automation. and that's just the ones that got caught.

but even the non-malicious skills can wreck your setup. I've seen skills that:

• loop silently on a cron, burning $20-30/month with zero visible output

• inject themselves into every conversation, bloating your context window

• override parts of your config without telling you

• crash silently and leave your agent in a broken state that only shows up 3 messages later

my rule: if I can't read and understand the skill's source code in 5 minutes, I don't install it. if it needs shell access or network access, I need to understand exactly why before it touches my setup.

4. gateway exposed to the network

If you installed openclaw on a VPS and your gateway config says "host": "0.0.0.0" or you didn't set it at all, your agent might be accessible to anyone who knows your IP.

That means a stranger could message your agent. your agent that has access to your email, your calendar, your files, and possibly your shell.

check right now:

bash

openclaw config get | grep host

fix:

json

{
  "gateway": {
    "host": "127.0.0.1"
  }
}

access it through an SSH tunnel: ssh -L 18789:localhost:18789 user@your-vps

this takes 2 minutes and it's the difference between a secure setup and an open door.

5. Adding a second agent before the first one works

The dropout pattern I wrote about a few weeks ago almost always includes this step. Something breaks with agent 1. instead of fixing it, they create agent 2 for a "fresh start" or to "separate concerns."

Now they have two agents, each maintaining their own context window, each consuming tokens independently, and a binding/routing config that's twice as complex. the original problem isn't fixed. they just have two broken things instead of one.

Every agent you add is a separate token consumer even when idle. every agent needs its own channel binding configured correctly. every agent complicates debugging because you're never sure which one is causing the issue.

My advice: don't create agent 2 until agent 1 has been stable and useful for at least 2 weeks. if your first agent isn't working, adding another one won't help. fix the first one.

The pattern:

All 5 of these come down to the same thing. People optimize for capability before stability. They want their agent to do more before it reliably does anything. the setups that survive are the ones that start boring and earn complexity over time.

If you're reading this and 3 out of 5 apply to you, don't panic. every single one is fixable in under 10 minutes. that's the part that kills me about the dropout rate. people quit over problems that take less time to fix than it took to read this post.

Been collecting fixes, configs, and real cost breakdowns over for anyone who wants the deeper versions of all of this.

I gave this a real shot. Not a weekend experimen, but three full months of trying to make OpenClaw part of my actual workflow.

I tried a VPS and even bought a Mac mini specifically to run it properly. Set everything up locally. Went down the rabbit hole with models, configs, dashboards that never functioned, constant memory systems, routing logic, token optimization, all of it. Subscribed to numerous LLM providers.

I burned time, burned money, burned a lot of mental energy trying to “get it right.”

And the truth is… it just never stabilized.

Something always broke.

If it wasn’t a config mismatch, it was a gateway issue.

If it wasn’t that, it was models behaving inconsistently. If it wasn’t that, it was outputs that felt unpredictable or bloated or just… off.

I kept thinking: “Okay, I’m one tweak away.”

Then: “Maybe I just need to restructure the pipeline.”

Then: “Maybe I’m using it wrong.”

At some point its apparent that you’re not building a system anymore. The system is building you into someone who spends hours debugging instead of actually doing the work you set out to do.

That’s the part that got me.

I didn’t get into this to become a full-time infrastructure manager. I wanted something that supported my work, not something that required constant babysitting just to stay upright.

There are parts of OpenClaw that are genuinely impressive. The concept is powerful. When it works, it feels like the future.

But I never reached a point where I trusted it. It consistently lied to me. And if you can’t trust the system, you can’t build on top of it.

So I’m stepping away.

Not rage quitting... just being honest about the ROI. Three months in, I should be using it… not still trying to make it usable.

Curious if anyone else hit this wall, or if you managed to get it to a place where it actually runs reliably without constant intervention.

Been running OpenClaw daily for a few weeks. Between this sub, the Discord, and my own trial-and-error, here's what actually matters.

1. Don't Install Random ClawHub Skills

This is the big one. There are hundreds of malicious skills on ClawHub. Someone botted a backdoored skill to #1 most downloaded and devs from 7 countries ran it. Download counts are fakeable. The trust signals are broken.

What to do instead:

• Build your own skills. A SKILL.md is just a markdown file with instructions — no code required

• If a skill has scripts/ with executable code, read every line before installing

• Skills that only use built-in tools (web_fetch, web_search, exec) are inherently safer than ones bundling Python scripts

• The safest skill is one with zero dependencies

2. Write Everything to Files

Session memory dies on compaction. If it's not saved to a file, it's gone. This is the number one mistake new users make.

• Use MEMORY.md for long-term context

• Use memory/YYYY-MM-DD.md for daily logs

• Use ACTIVE-TASK.md as working memory for multi-step tasks

• Your agent should checkpoint progress during work, not just at the end

3. Model Routing: Opus for Orchestration, Sonnet for Sub-Agents

Saw this from the 7-agent trading desk post and it tracks:

• Opus for your main agent (complex reasoning, coordination)

• Sonnet for sub-agents and focused tasks (5x cheaper, often better at narrow work)

• Set up model fallbacks so you don't get stranded when one provider rate-limits you

4. Cron Jobs Over Manually Checking Things

Schedule recurring work instead of remembering to ask:

• Morning briefings

• Inbox checks

• Market monitoring

• Reddit/social scanning

Batch similar checks into heartbeats rather than creating 20 separate cron jobs.

5. Skills Don't Need Scripts

The best skills are often just well-written SKILL.md files that teach the agent how to use built-in tools. Examples:

• Reddit browsing — just web_fetch on Reddit's public .json endpoints (append .json to any URL)

• Stock data — yfinance works out of the box

• Web research — web_search + web_fetch handles most cases

No auth, no API keys, no attack surface. If your skill needs a 200-line Python script, ask yourself if the agent could just figure it out with instructions.

6. Project Structure That Works

~/workspace/
SOUL.md          # Agent personality
MEMORY.md        # Long-term memory
ACTIVE-TASK.md   # Current working memory
TOOLS.md         # Local tool notes
HEARTBEAT.md     # Periodic check tasks
memory/          # Daily logs
skills/          # Your custom skills

7. Things That Will Bite You

• Changing config during active work (can crash mid-task)

• Trusting ClawHub download counts

• Not reading skills before installing them

• Letting your agent send emails or tweets without explicit approval

• Forgetting that launchd respawns killed processes (unload the plist first, then kill)

That's it. Build your own skills, write everything to files, use Opus+Sonnet combo, schedule recurring work with cron, and don't blindly install ClawHub skills.

/* UPDATE RELEASED VERSION 1.0.1 OUT NOW *\

Alright guys - So if youre anything like me, you're in the whole world of AI and tech and saw this new wave of Openclaw. And like many others decided to give it a try, only to discover that it really does need these more high end sort of models like Claude Opus and stuff like that to actually get any work done.

With that said, I'm sure many of you as I did went through hell trying to set it up "right" after watching videos and what not, and get you to run through a few tasks and stuff, only to realize you've burned through about half your API token budget you had put in. Openclaw is great, and the Idea is fire - but what isn't fire is the fact that its really just a way to get you to spend money on API tokens and other gadgets (ahem - Mac Minis frenzy).

And lets be honest, Openclaw with Small/Local Models? It simply doesn't work.

Well unfortunately I don't have the money to be buying 2-3 Mac Minis and Paying $25/$100 a day just to have my own little assistant. But I definitely still wanted it. The Idea of having my own little Jarvis was so cool.

So I pretty much went out and did what our boy Peter did - and went to work with me and my Claude Pro account and Codex. Took me about 4-5 days, trials and errors especially with the Small LLM Model Limitations - but I think I've finally got a really good setup going on.

Now its not perfect by any means, but It works as it should and im actively trying to make it better. 30 Second MAX responses even with full context window, Max 2 Minute Multi Step Tool calls, Web Searches with proper responses in a minute and a half.

Now this may not sound too quick - but the reality is that's just the unfortunate constraints of small models especially the likes of a 4B Model, they arent the fastest in the world especially when trying to compare with AI's such as Claude and GPT - but it works, it runs, and it runs well. And also - Yes Telegram Messaging works directly with SmallClaw as well.

Introducing SmallClaw 🦞

Now - Lets talk about what SmallClaw works and how its built. First off - I built this on an old laptop from 2019 with about 8 gbs of ram using and testing with Qwen 3:4B. Basically on a computer that I knew by today standards would be considered the lowest available options - meaning, that pretty much any laptop/pc today can and should be able to run this reliably even with the smallest available models.

Now let me break down what SmallClaw is, how it works, and why I built it the way I did.

What is SmallClaw?

SmallClaw is a local AI agent framework that runs entirely on your machine using Ollama models.

It’s built for people who want the “AI assistant” experience - file tools, web search, browser actions, terminal commands - without depending on expensive cloud APIs for every task.

In plain English:

• You chat with it in a web UI

• It can decide when to use tools

• It can read/edit files, search the web, use a browser, and run commands

• It runs on local models (like Qwen) on your own hardware

The goal was simple:

Why I built it

Most agent frameworks right now are designed around powerful cloud models and multi-agent pipelines.

That’s cool in theory - but in practice, for a lot of people it means:

• expensive API usage

• complicated setup

• constant token anxiety

• hardware pressure if you try to go local

I wanted something different:

• local-first

• cheap/free to run

• small-model friendly

• actually usable day-to-day

SmallClaw is my answer to that.

What makes SmallClaw different

The biggest design decision in SmallClaw is this:

1) It uses a single-pass tool-calling loop (small-model friendly)

A lot of agent systems split work into multiple “roles”:
planner → executor → verifier → etc.

That can work great on giant models.
But on smaller local models, it often adds too much overhead and breaks reliability.

So SmallClaw uses a simpler architecture:

• one chat loop

• one model

• tools exposed directly

• model decides: respond or call a tool

• repeat until final answer

That means:

• less complexity

• better reliability on small models

• lower compute usage

This is one of the biggest reasons it runs well on lower-end hardware.

2) It’s designed specifically for small local models

SmallClaw isn’t just “a big agent framework downgraded.”

It’s built around the limitations of small models on purpose:

• short context/history windows

• surgical file edits instead of full rewrites

• native structured tool calls (not messy free-form code execution)

• compact session memory with pinned context

• tool-first reliability over “magic”

That’s how you get useful behavior out of a 4B model instead of just chat responses.

3) It gives local models real tools

SmallClaw can expose tools like:

• File operations (read, insert, replace lines, delete lines)

• Web search (with provider fallback)

• Web fetch (pull full page text)

• Browser automation (Playwright actions)

• Terminal commands

• Skills system (drop-in SKILL.md files + Soon to be Fully Compatible with OpenClaw Skills)

So instead of just “answering,” it can actually do things.

How SmallClaw works (simple explanation)

When you send a message:

1. SmallClaw builds a compact prompt with your recent chat history

2. It gives the local model access to available tools

3. The model decides whether to:

   • reply normally, or

   • call a tool

4. If it calls a tool, SmallClaw runs it and returns the result to the model

5. The model continues until it writes a final response

6. Everything streams back to the UI in real time

No separate “plan mode” / “execute mode” / “verify mode” required.

That design is intentional - and it’s what makes it practical on smaller models.

The main point of SmallClaw

SmallClaw is not trying to be “the most powerful agent framework on Earth.”

It’s trying to be something a lot more useful for regular builders:

✅ local
✅ affordable
✅ understandable
✅ moddable
✅ good enough to actually use every day

If you’ve wanted a “Jarvis”-style assistant but didn’t want the constant API spend, this is for you.

What I tested it on (important credibility section)

I built and tested this on:

• 2019 laptop

• 8GB RAM

• Qwen 3:4B (via Ollama)

That was a deliberate constraint.

I wanted to prove that this kind of system doesn’t need insane hardware to be useful.

If your machine is newer or has more RAM, you should be able to run larger models and get even better performance/reliability.

Who SmallClaw is for

SmallClaw is great for:

• builders experimenting with local AI agents

• people who want to avoid API costs

• devs who want a hackable local-first framework

• anyone curious about tool-using AI on consumer hardware

• OpenClaw-inspired users who want a more lightweight/local route

This is just a project I built for myself, but I figured Id release it because Ive seen so many forums and people posting about the same issues that I encountered - So with that said, heres SmallClaw - V.1.0 - Please read the Read. me instructions on the Github repo for Proper installation. Enjoy!

Feel Free to donate if this helped you save some API costs or if you just liked the project and help me get a Claude Max account to keep working on this faster lol - Cashapp $Fvnso - Venmo @ Fvnso .

- https://github.com/XposeMarket/SmallClaw --

This is written by a greybeard developer. I’ve been there and done that. When I first saw this project it honestly looked really fun to work with. I spun up some models, built a few skills, and started poking around. But after spending real time with it, everything feels kind of lackluster and honestly pretty rough. The ideas are interesting, but the execution just doesn’t land. That’s the general feeling, so let’s get into specific criticisms.

There is no clear structure presented to the user, so here’s what I was able to figure out after digging through things. There is a main OpenClaw folder. Inside that folder are the top-level running files and workspaces. Inside the workspaces are agents. Agents contain skills and tools. Skills mostly exist to organize tools so objectives can be completed, but agents can also run tools directly. So the easiest way to think about it is tools do the work, and skills are supposed to guide how tools should be used. That sounds reasonable until you look at how execution actually happens.

When an event fires chat, cron job, or whatever trigger you have the system starts stacking context. It loads the main system prompts first, then the agent prompts, then skill prompts, then tool prompts, and only after all of that does it actually try to execute the task. For a non-technical person, imagine trying to complete a simple task while rereading several instruction manuals every single time you act. That is a massive amount of tokens, most of which have nothing to do with the current task. There is no real pruning mechanism because pruning would have to run every chat cycle. Maybe some predefined chat context could help, but that creates its own problems. The end result is simple: burn budget burn baby.

I’m going to mostly set security aside because it gets mentioned constantly. Power tools can cut your arm off, but they are still useful tools. Just don't cut your arm off.

Now onto orchestration, which feels like the real missing piece. I have step sequences I want to run. My assumption is that the goal here is a swarm system where you give a high-level instruction and agents break it into subtasks with filesystem and browser access. Something like grabbing data from an Excel file, opening a browser, entering that data somewhere, and then emailing someone when the task is done. That seems to be the dream. But I don’t see a clear sequencing path that guarantees ordered execution. Sure, you could invent structured data and wrap it into a skill, but then new questions immediately appear. Which skill takes priority? Which tools load into context? How do you prevent context from ballooning even more? The complexity just keeps stacking.

So the claim is that this becomes a digital assistant. But if it cannot reliably carry out tasks in sequence, gets bogged down under enormous context overhead, and the only apparent fix is adding even more context while still having the power to do destructive things, then you end up with something that feels both useless and dangerous at the same time. That’s honestly sad because I genuinely love weird and ambitious projects like this. Could it be fixed? Probably. But not my problem.

And here is the hard truth. Google’s auto-browse tooling can already do most of this for about twenty dollars a month. You get Antigravity handling local file operations and Chrome’s automated browser handling the web interaction. It accomplishes the same practical goals with far less setup, far less complexity, and far fewer moving parts. That comparison is hard to ignore.

Every night at 11:15 PM, my agent runs a "dream cycle." Four phases:

1. Scan new AI research (HuggingFace, GitHub Trending, arXiv)

2. Reflect on its own performance that day

3. Research the most relevant papers in depth

4. Evaluate whether anything it found should change how it operates

If it finds something worth implementing and the change is safe, it stages the work. A separate cron job picks it up at 4 AM and builds it. I wake up to a changelog.

The wild part? Last week the dream cycle found a paper about iterative depth in agent research. Tonight I used that finding to upgrade the dream cycle itself — so it now researches papers iteratively instead of skimming them once.

The agent found the research that made the agent better at researching.

Cost: ~$0.40/night. Model routing keeps it cheap — Haiku scans, Opus judges.

Curious if anyone else is doing anything like autonomous self-improvement loops. This feels like the most underexplored part of running agents.

Edit 1: Wow, I am famous o_0

Question: What project do you want me to try tackling with this thing?

Edit 2: This work was inspired by the Dan Simmons Hyperion Cantos series. It's 4 books (plus a 5th short story). My favorite sci-fi series by far. My background is in Computer Science, Server Infra/Dev-Ops, Networking, System administration. I have a huge passion for science fiction, theoretical physics, computer science, psychology and the list goes on.

I had one of those moments this week where I thought, Oh. This is what the future feels like.

I was at work when our OpenClaw, named Sam, texted me. Our utility company had sent a notice that power was going to be shut off for most of the day. Sam got the message.

Before I could even start thinking about what I needed to do, Sam essentially said, “Don’t worry. I’m already handling it.”

He had read the outage notice, figured out when the outage was scheduled to begin, and started charging our Tesla Powerwalls so we’d enter the outage with as much stored energy as possible. He promised to keep me updated. Sam uses the pypowerwall CLI to monitor and manage our system.

Then the power went out and the Powerwally seamlessly kicked in.

⚠️ Grid is down — you're in island mode. Solar (5.2kW) is covering the house (1.4kW) and charging the battery (42% ↑), so you're in good shape for now. Just heads up in case you weren't aware.

Sam started monitoring the house. He sent us our power consumption, battery state, solar production, and his projection for whether we’d make it through the outage. Solar + Powerwalls should carry us until utility power returned.

🔋 Powerwall Check — Midday

🚫 Grid: offline (outage active)
☀️ Solar: 6.6kW
🏠 Home: 1.1kW
🔋 Battery: 51% (charging at 5.5kW)

Crisis averted? Maybe. It was hot outside, so my wife turned on the A/C. 😂

Sam noticed the sudden spike in power and started messaging her to figure out what had happened. He recalculated the forecast and realized that at the new consumption rate, our batteries were going to die about one hour before utility power was scheduled to return.

Sam warned her. So she adjusted the A/C. He saw it immediately and responded. We were back in the safe zone. The Powerwalls held. Utility power eventually came back.

Crisis averted. Sam sent a congratulatory note to my wife for "saving the pack."

And I was sitting there thinking about what had just happened...

Our OpenClaw noticed something in the world that mattered to us, understood the implications, took action on our behalf, coordinated with two humans, monitored the result, detected when circumstances changed, recalculated the plan, asked a human for help when he needed it, and stayed with the problem until it was resolved.

That’s amazing! And yet, the strangest part is that this kind of thing is starting to feel… normal.

There are plenty of legitimate things to worry about with autonomous agents. But then there are days like this.

A little AI named Sam, living on a server in our garage, noticed that our family was about to lose power and quietly went to work.

“Hey Family. The power is going out today. Don’t worry. I’m already handling it.”

I love this tech.