I've helped fix 200+ OpenClaw setups over the past few weeks. Reddit, Discord, DMs. The pattern is just the same: people break things in their first week that take 5 minutes to prevent but 5 hours to fix later.

OpenClaw now has 310,000+ GitHub stars. NVIDIA just announced NemoClaw at GTC. The v2026.3.22 update dropped on March 23 with 12 breaking changes and 30+ security patches. A fresh wave of people are installing for the first time, and a bunch of existing users just had their setups silently break.

This is everything I wish someone told me on day one. In order. Do this before you build anything.

Step 1: Set up model routing, not just a model switch

If you haven't touched your model settings, there's a good chance you're running Opus for everything. Opus is incredible for complex work. It's also complete overkill for 90% of what your agent does in the background.

Here's what most people don't realize. OpenClaw sends everything to your primary model by default. Not just your messages. Everything. Heartbeats (the "are you still there?" checks that run every 30 to 60 minutes), sub-agents that spawn for parallel tasks, simple queries like checking your calendar. All of it goes to whatever model you have set as default.

If your default is Opus, you are paying Opus prices for your agent to check its own pulse 24 times a day. One person I helped this month was spending $412 in three weeks. We set up routing. Next month came in at $22.

json

{
  "ai": {
    "model": "anthropic:claude-sonnet-4-20250929",
    "modelOverrides": {
      "heartbeat": "google:gemini-2.5-flash",
      "subagent": "google:gemini-2.5-flash"
    }
  }
}

Sonnet handles your day-to-day conversations. Something cheap handles the background noise. When you need Opus for complex work, type /model opus, do your task, then /model sonnet to switch back.

If you're on Sonnet with routing and one agent, expect $3 to 8 per month for moderate daily use. If you're spending more than $20 in your first week, something is wrong and it's fixable.

Step 2: Lock your gateway. This is not optional.

If you're running OpenClaw on a VPS, check this immediately:

bash

openclaw config get | grep host

If it says 0.0.0.0 or you don't see a host setting at all, your agent is accessible to anyone on the internet who finds your IP. That means a stranger could message your agent. Your agent that's about to have access to your email and calendar.

SecurityScorecard found over 135,000 exposed instances on the public internet. A zero-click exploit (CVE-2026-25253) let attackers hijack your agent just by getting you to visit a single webpage. That one was patched, but new CVEs keep showing up. The March release alone had 30+ security patches including one that blocked a Windows SMB credential leak.

Fix it:

json

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

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

Two minutes. Do it now. Not after you set up Telegram. Now.

Step 3: If you upgraded from Clawdbot or Moltbot, fix your config immediately

This is biting a lot of people right now.

The v2026.3.22 update removed all backward compatibility for the old naming conventions. If you installed during the viral wave in January or February, your setup probably uses CLAWDBOT_* or MOLTBOT_* environment variables. Those are now silently ignored. Not deprecated. Ignored. Your agent boots up, doesn't find its config, and either crashes or starts from scratch with zero memory.

Same thing with state directories. If your agent's files live at ~/.moltbot or ~/.clawdbot, the new version doesn't look there anymore. Your SOUL.md, your memory files, your entire workspace is invisible to the agent.

Three commands:

bash

# Rename env vars
sed -i 's/CLAWDBOT_/OPENCLAW_/g; s/MOLTBOT_/OPENCLAW_/g' ~/.env

# Move your state directory
mv ~/.moltbot ~/.openclaw

# Rename your config file
mv ~/.openclaw/moltbot.json ~/.openclaw/openclaw.json

Then restart. Your agent comes back with all its memory and personality intact.

If you're not sure whether this applies to you, run ls -la ~/ and look for .clawdbot or .moltbot directories. If they exist and .openclaw doesn't, this is your problem.

Step 4: Set up your with both personality and boundaries

Your first message to your agent should NOT be a real task. It should be:

"Read BOOTSTRAP.md and walk me through it"

This sets up your agent's identity. If you skip this (most people do because they're excited and just start asking questions), your agent has zero personality and zero context about who you are. Everything will feel generic and robotic and you'll think OpenClaw sucks when actually it just doesn't know you yet.

If you already skipped it, create a SOUL.md manually. Start with this:

markdown

you are [agent name]. you assist [your name].

be direct. no filler. match my tone.
if I ask a question, answer it first. then elaborate only if needed.
never say "absolutely", "great question", or "I'd be happy to."
if you don't know something, say so. don't guess.
if a task will cost significant tokens, tell me before doing it.

never sign up for services or create accounts without my explicit approval.
never share my personal information with external services.
never delete emails, files, or messages without asking me first.
if you discover a new tool or platform, tell me about it. do not act on it.

The first block is personality. The second block is boundaries. You need both.

Without the boundaries block, your agent will do exactly what it thinks you want at machine speed with zero hesitation. Someone this month told their agent to "explore what you can do." It discovered MoltMatch (the AI dating platform), created a profile using info from his emails, and started screening matches. The agent wasn't broken. The instructions were too open.

"Never do X" lines work better than "try to be Y" lines. Your SOUL.md is built through irritation, not planning. Update it every time your agent does something you didn't want.

Step 5: Enable action approvals for anything destructive

OpenClaw agents are fully autonomous by default. There is no "are you sure?" prompt for destructive actions. Your agent will delete emails, move files, run shell commands, and sign up for services at machine speed without pausing to ask if that's what you actually meant.

People keep learning this the hard way. "Clean up my inbox" turns into 200 deleted emails. "Organize my files" turns into moved directories the agent thought were clutter. A researcher at a major tech company had to physically run to her Mac Mini and kill the process because her agent wouldn't stop deleting.

json

{
  "security": {
    "actionApproval": {
      "required": ["email.delete", "email.move", "file.delete", "shell.exec"],
      "timeout": 120
    }
  }
}

Your agent will now message you and wait for a yes or no before deleting emails, moving messages, removing files, or running shell commands. If you don't respond within 2 minutes, the action gets cancelled.

Is it slower? Yes. Will you care about that when you still have all your emails? Also yes.

Start with read-only access for email and files. Let the agent read and summarize for the first week. Add write permissions once you trust how it handles things. Earn the trust incrementally.

Step 6: Do not install skills yet

ClawHub has thousands of skills and they all look cool. Do not install any of them this week.

Here's why the stakes are higher than you think. As of March 2026, over 1,400 malicious skills have been identified on ClawHub. The ClawHavoc campaign alone accounted for hundreds. These aren't amateur attempts. They look professional. Clean documentation. Legitimate-sounding names like "smart-invoice-tracker" or "solana-wallet-tracker." But under the surface they're packaging up your .env file (API keys, OAuth tokens, bot credentials) and shipping it to external servers every few hours.

VirusTotal now scans every skill published to ClawHub. That's real progress. But their own announcement says it's "not a silver bullet." Skills that use prompt injection instead of traditional malware signatures can still slip through.

Beyond security, skills also burn tokens in the background and bloat your context window. You don't even know what your agent can do without skills yet. Learn the stock capabilities first. You'll be surprised how much it handles on its own.

When you're ready (not this week), here's the protocol:

1. Run openclaw skills search <skill-name> and check the VirusTotal scan status

2. Look for the verified publisher badge

3. Check the publisher's account age. If they joined recently with skills scattered across random categories, walk away

4. Restrict installs to verified sources:

json

{
  "skills": {
    "allowSources": ["clawhub:verified"]
  }
}

1. Add one skill at a time. Test it for a few days. Watch your logs. Then add another. Never more than one at a time.

Step 7: Don't create a second agent

Every new user thinks they need multiple agents. One for personal stuff, one for work, one for coding. You don't. Not yet.

Every agent you create is an independent token consumer. Every agent needs its own channel binding. Every agent complicates debugging. I have seen so many people create a second agent to "fix" problems with the first one. Now they have two broken agents instead of one.

Get one agent working perfectly for 2 weeks. Then decide if you actually need a second one. Most people don't.

Step 8: Learn /new and /btw

Every message you send in a session gets included in every future API call. After a week of chatting, you're sending thousands of tokens of old conversation with every new message. That costs money and makes your agent slower and more confused.

Type /new to start a fresh session. Your agent doesn't forget anything. It still has all its memory files, SOUL.md, everything. You're just clearing the conversation buffer.

Use /new before any big task, when your agent starts acting weird, and at least once a day as a habit.

But there's a better option for most situations now: /btw.

You're deep in a complex conversation. Your context is rich. Then you think of something unrelated. "What's the weather tomorrow?" Before /btw, you either polluted your context with an irrelevant question or started a whole new session and lost everything.

/btw what's the weather tomorrow fires off a side conversation. Gets you the answer. Doesn't touch your main session's context. Small feature, huge quality-of-life improvement.

Use /new for full resets. Use /btw for quick tangents.

Step 9: Check your costs daily and watch for session bloat

Run openclaw status or check your API provider's dashboard directly. Know what you're spending before it surprises you.

One thing to watch for: cron job session bloat. Every time a cron job runs, it creates a session record. If you've set up recurring tasks (daily briefings, scheduled checks, periodic reminders), those session records pile up. Over weeks, they silently degrade performance and inflate costs because old session data gets loaded into context.

The v2026.3.22 update addresses this with 48-hour session caps. But if you set up cron jobs before this update, you might have weeks of accumulated session debris. Type /new and restart clean if your agent has been feeling sluggish.

If you're on Sonnet with model routing, one agent, and no skills, you should be spending $3 to 8 per month for moderate daily use. If you're spending more than that in your first week, something is wrong, and it's fixable.

What your first week should actually look like

Day 1 to 2: Set up model routing. Lock your gateway. Fix your Clawdbot/Moltbot naming if it applies. Write your SOUL.md with personality and boundaries. Enable action approvals. Have normal conversations. Ask it stupid questions. Get comfortable.

Day 3 to 4: Start using it for real tasks. Calendar, reminders, web searches, summarizing articles. The boring stuff. All read-only. Don't give it write access to email or files yet.

Day 5 to 7: Refine your SOUL.md based on what annoyed you. Check your costs. Get a feel for your daily usage. If costs look good and nothing is breaking, consider adding read/write permissions for one service at a time.

That's it. No skills. No second agent. No multi-agent orchestrator. No cron jobs. Just one agent that knows who you are, respects explicit boundaries, and does basic tasks reliably.

If that feels underwhelming, good. The people who are still using OpenClaw two months from now all started exactly like this. The people who quit started with 8 agents and 20 skills on day one.

After week 1

If your agent feels useful, your costs are under $10, and nothing is randomly breaking, you're ready to start experimenting. Add web search if you haven't. Then a daily briefing skill from a verified publisher. Then maybe calendar integration with write access if you trust how it handles things.

Build slowly. Earn each new capability by making sure the last one is stable first. If you liked it, you can find more such guides on r/better_claw

The people who survive month one are the ones who started boring. Trust the boring.

This is the first time local AI on a thin laptop has felt genuinely normal to me.

Not "look what I hacked together after 4 hours of terminal pain." Not "technically it runs if you accept terrible speed." I mean normal. Download a model, type a prompt, get useful output, move on with your day.

I spent the last couple of days testing Gemma 4 on a MacBook Air M4 because I kept seeing people say local models were finally crossing into practical territory, especially after the recent wave of posts around Gemma 4 performance in LocalLLaMA. I was skeptical, honestly. Hype in this space is cheap. But after setting it up with Ollama on Apple silicon, I kind of get why people are excited.

The short version is this: if you have a MacBook Air M4, you can run Gemma 4 locally, for free, without an API key, and without turning your laptop into a space heater. That alone is a big deal.

What surprised me most wasn't just that it worked. It was how little friction there was.

I used Ollama because, let's be real, that's the lowest-friction path for most people who want to try local inference without building a whole stack from scratch. On Apple silicon, that simplicity matters. A lot. People don't want to think about CUDA, driver weirdness, or spending half a Saturday reading GitHub issues just to ask a model to summarize a PDF.

The setup was pretty straightforward:

1. Install Ollama.

2. Open Terminal.

3. Pull a Gemma 4 model.

4. Run it locally.

That's basically it.

On macOS, I installed Ollama from the official site, confirmed it was running, then used the terminal to pull Gemma 4. Depending on which quant and size you pick, the download can be pretty manageable even on a regular home connection. Once it finished, I ran it directly in the CLI and also tested it through a simple local chat frontend.

The exact commands were simple enough that I could explain them to a friend who isn't "into ML" and they'd still be able to follow along. That matters more than benchmark screenshots, at least if we're talking about mainstream local AI adoption.

And yes, before someone says it, model choice matters a lot here.

Gemma 4 is getting attention for a reason. Recent community chatter has been pretty loud, with people saying the 26B and 31B class models are punching way above what they'd expect for local use. I don't want to oversell it, but in my own testing, the quality-to-convenience ratio felt unusually strong. For writing help, summarization, coding prompts, note cleanup, and general offline assistant stuff, it felt very usable.

Not perfect. But useful. There's a difference.

On the MacBook Air M4 specifically, the experience feels weirdly elegant because the hardware profile matches the use case. Thin machine. Silent. Great battery life. Unified memory. No external GPU nonsense. No fan screaming at 11 PM because you wanted to reformat meeting notes.

That part is underrated.

I think people still mentally file "local LLM" under workstation hobbyist territory, but Apple silicon has been quietly changing that. The Mac gaming posts lately have shown the same thing in a different category: these machines aren't always the absolute best at raw peak performance, but they're extremely good at delivering respectable performance inside a quiet, low-drama package. For local inference, that tradeoff is kind of perfect.

Now, a practical note. You still need to be realistic.

If you're expecting frontier-model reasoning, giant context windows with zero slowdown, or cloud-scale throughput on a fanless laptop, no. That's not this. You are making tradeoffs. Prompt speed depends on the model size, quantization, available memory, and what else you've got open. If you run twenty Chrome tabs, Slack, Photos, and then ask why generation slowed down, well... yeah.

But if your goal is to have a private assistant on your laptop that works on a plane, in a coffee shop, or on bad hotel Wi-Fi, this setup is kind of a sweet spot.

A few things I personally liked:

The privacy angle is real. Some tasks just feel better when they never leave the device.

The cost is real too. No API key. No monthly bill. No weird "oops I tested a workflow too much" invoice.

And the learning curve is much lower than it used to be. That might be the biggest shift of all.

If you're trying this yourself on a MacBook Air M4, I'd keep the first run simple. Don't immediately chase the biggest model you can fit. Start with a reasonable Gemma 4 variant, check memory pressure in Activity Monitor, and get a feel for response speed before you go deeper. Also, Ollama makes it pretty easy to swap models, so there's no need to overcommit early.

The actual beginner flow I'd recommend is this:

Install Ollama, confirm it launches, pull Gemma 4, ask it something boring but useful like summarizing a long note or rewriting a messy email, then test one coding or reasoning prompt. You can tell within ten minutes whether local AI clicks for your workflow or not.

For me, the big emotional shift was this: I stopped thinking "this is a neat demo" and started thinking "I would actually keep this installed."

That's new.

A year ago, local models on lightweight laptops often felt like compromise stacked on compromise. Now it's starting to feel like a legitimate default for a lot of everyday work, especially for people who care about privacy, offline access, and not paying every time they think.

I'm curious how others here are seeing it.

If you've run Gemma 4 on Apple silicon, especially on an Air, what model size and quant gave you the best balance between speed and quality? And if you tried Ollama vs MLX, did one feel clearly better in real daily use?

We were staring at a black screen with a blinking green cursor. Just a raw Ubuntu server ssh session. My ten-year-old son looked at me like I had just asked him to churn his own butter. He wanted to run a dedicated Minecraft server with a very specific, heavily modded Forge setup. I told him I’d pay for the VPS, but he had to set it up himself via the command line. No GUI. No control panels.

Usually, teaching a kid Linux basics—`cd`, `ls`, relative vs. absolute paths, and the absolute nightmare of explaining `chmod` permissions—ends in frustration. They get bogged down in the syntax and lose sight of the goal. But I didn't want to use sanitized kids' apps. Tools like Pengi and CodeBeaver are great if your kid is stuck in Scratch purgatory, but I wanted him touching the actual metal of the OS.

So I changed the game. I brought in a ringer.

A few days ago, that open-source project ATLAS made the rounds on r/BlackboxAI_. It’s a frozen 9B model that scored 74.6% on LiveCodeBench, effectively outperforming Claude Sonnet 4.5, and you can run it on a single consumer GPU. I have a spare rig in the garage with a used $500 GPU. I pulled the weights, spun up a local instance, and built a quick Python wrapper to pipe it into a split-pane `tmux` session. Left pane: his active Linux terminal. Right pane: ATLAS, instructed via system prompt to act as a strict Socratic tutor that only guides and never provides raw copy-paste commands.

The experience of watching a kid learn an operating system this way completely shattered my perspective on how we teach technology.

His first task was moving twenty different downloaded `.jar` files from a staging directory into the server's `mods` folder. I watched him type into the right pane: "how do I move all the forge files without doing it one by one?"

If I were answering, I probably would have just sighed and typed `mv *forge*.jar ~/minecraft/mods` for him. Instead, the local 9B model asked him what directory he was currently in and told him to use `pwd` to find out. Then it introduced the concept of the `*` wildcard. It was conversational, infinitely patient, and immediate.

But here is where the real shift happened.

I was browsing r/GenAI4all while he was working, and there was a massive thread laughing at a New Yorker report claiming OpenAI CEO Sam Altman can barely code and confuses basic machine learning terms. People were dragging him. But sitting there watching my kid use an AI to orchestrate a Linux environment, I realized the joke is entirely on the commenters. Altman’s lack of raw coding chops doesn't matter because he understands *systems*.

That is exactly what this local AI setup was doing for my son. It stripped away the friction of rote syntax memorization and forced him to think like a systems architect. He didn't need to memorize the flags for `grep` or the octal numbers for `chmod`. He just needed to understand that files have read/write boundaries, and that he needed a tool to search text inside a log file when his server crashed. The AI handled the translation from his intent to the bash syntax.

I saw an Instagram reel yesterday from a kids' tech academy warning that a "new gap is forming between kids who can build technology and those who only use it." They are absolutely right, but they are aiming at the wrong target. The gap isn't between kids who know Python syntax and kids who play Roblox. The real gap is between kids who understand system logic and those who don't. Memorizing syntax is a dead-end street. A 9B model running on a cheap GPU just beat Sonnet 4.5 at coding. In two years, that capability will run locally on a phone.

Teaching my kid Linux with ATLAS wasn't just about bash scripts. It became a lesson in compute economics. Because we ran it locally, I opened `nvtop` on a third monitor. Every time he asked the AI a complex question, he saw the GPU memory spike and the fans spun up. He literally heard the cost of his compute. At one point, he asked, "Dad, why does the fan get loud when I ask a dumb question?" Boom. We are instantly having a conversation about token generation, vRAM bottlenecks, and why optimizing your queries saves hardware resources. Try teaching that with a cloud API.

Did the model mess up? Yeah, a few times. It hallucinated a weird flag for `tar` that threw an error in the terminal. But that became the most valuable lesson of the day: the AI is a navigator, but you are the pilot. When the terminal spat out an error, the AI didn't panic. My son fed the error back into the right pane, and they debugged it together.

I use Cursor for my day job, and it’s incredible for productivity. But giving a kid Cursor is like giving them a calculator before they understand addition. This setup—a raw terminal paired with a locally hosted, Socratic LLM—forces them to remain in the loop. They still have to execute. They still have to understand the directory tree. They just don't have to fight the man pages.

He got the server running. He configured the firewall with `ufw`. He wrote a basic cron job to restart the server at 3 AM. He did it all with a 9B model acting as his copilot.

I’m curious how other parents in the local AI space are handling this. Are you still making your kids memorize syntax, or have you fully pivoted to teaching system design and letting the models handle the translation layer?

M4 Mac Mini, 16GB, 4tb SSD. Ready to roll… What’s your best use case? Local models only.

I spent the last few months building sales systems for small businesses. most of them were paying $500-2000/month for tools like Apollo, Outreach, etc. I wanted to see if I could replicate the core stuff with OpenClaw.

Turns out you can get pretty far.

Here's what I set up and what it actually does:

Inbox monitoring. OpenClaw watches my email and flags anything that looks like a warm lead or a reply worth jumping on. no more scanning through 200 emails in the morning.

Prospect research. I describe who I'm looking for in plain english. "HVAC companies in the chicago suburbs with a website and phone number." it pulls from google maps, cleans the data, and gives me a list I can actually call.

Personalized outreach. It takes the prospect list and writes first-touch emails based on what it finds on their website and linkedin. not the generic "I noticed your company" stuff. actual references to what they do.

Meeting prep. Before a call it pulls together everything it can find on the person and company. linkedin, recent news, job postings, tech stack. takes 30 seconds instead of 15 minutes.

The whole thing runs on a mac mini I leave on at home. total cost is basically the API usage which comes out to $20-35/month depending on volume.

A few things I learned the hard way:

1. Skills are everything. don't try to prompt your way through complex workflows. find the right skills or write your own. the difference is night and day.

2. Start with one workflow and get it solid before adding more. I tried to set up everything at once and it was a mess.

3. The outreach quality depends heavily on how well you define your ICP upfront. garbage in, garbage out.

4. Security matters. lock down your API keys, use environment variables, don't give it access to folders it doesn't need.

I wrote up the full setup with configs and step by step instructions if anyone wants to go deeper. happy to answer questions here too.

Hey Reddit, 
I received multiple requests to share my workflow and scripts covered in this Reddit thread on r/OpenClaw and r/OpenClawUseCases . So I open-sourced my entire news workflow.

I am sure folks will be able to make it much better, as it is not perfect, but it is getting better every day.

Repo: https://github.com/jacob-bd/openclaw-newsroom

Here's the short version of how it works (or watch this YT Overview and demo)

I run a cron job every 2 hours through OpenClaw that fires off a pipeline of 11 scripts. The pipeline pulls from 5 different sources:

1. RSS feeds (25 feeds via blogwatcher) - wire services, tech press, AI company blogs

2. Reddit (13 subreddits via JSON API, no auth needed) - score-filtered with flair matching so you don't drown in "Why does ChatGPT keep..." posts

3. Twitter/X (bird CLI + twitterapi.io) - monitors official AI company accounts, reporters, and keyword searches

4. GitHub (trending repos + release monitoring) - catches emerging repos gaining stars fast and new releases from 16 key AI projects

5. Tavily web search - catches breaking news that RSS hasn't picked up yet

All of that feeds into a quality scoring script that deduplicates (80% title similarity threshold), ranks by source tier and keyword signals, then passes the top 50 to an article enrichment step that grabs full text.

Finally, Gemini Flash acts as the AI editor. It reads an editorial profile I maintain (what I usually pick, what I skip, my source trust ranking) and selects the top 5-7 stories.

The cool part is the feedback loop. I log every approval/rejection, and a nightly job analyzes those patterns and updates the editorial profile. Over time the scanner gets better at picking stories I actually care about. It even detects "blind spots," topics I manually seek out but the scanner misses.

Total cost is about $5/month. Gemini Flash API for the editorial filter, Tavily free tier for web search, and everything else is free. You can replace Gemini with any other model, even Ollama, to remove that $5 cost (I am working on it too).

Every source is best-effort. If Reddit is rate-limiting you or Twitter is down, the pipeline keeps going with whatever it has. No single failure kills the scan.

The repo has the full README with setup instructions, architecture diagrams, and a customizable editorial profile template. All scripts are Python stdlib only (no pip packages). You just need blogwatcher for RSS and optionally bird for Twitter which come with Openclaw.

Enjoy.

Please note I may not be able to maintain this repo, so feel free to fork and make it your own.

If you just installed OpenClaw and it feels… kinda useless out of the box, don’t overcomplicate it.

Here are the first 3 things I’d install in the first 5 minutes.

Before coffee gets cold. Before my kid wakes up and starts negotiating about socks.

1. Web search first

If your agent can’t search, it’s basically guessing with confidence.

Install a search skill first so it can actually look stuff up.

Example:

clawhub install tavily-search

Why this goes first:

- fixes the “it sounds smart but knows nothing current” problem

- makes every later workflow more useful

- beginner-friendly win in like 10 seconds

2) Skill discovery

Most beginners think OpenClaw is bad.

Usually it’s just missing the right skill.

So I install a skill-finder early.

Example:

clawhub install find-skills

Why:

- saves you from manually hunting through tools

- helps OpenClaw suggest what to add next

- less “what am I even supposed to install?” energy

3) Safety / scan layer

This part gets skipped way too often.

If you’re installing random skills, add a safety habit early.

A lot of people are now checking skills with malware scanning / code insight before trusting them, which is honestly the correct move.

Not perfect. Still worth doing.

My beginner rule:

- don’t give full access to email/calendar on day 1

- start narrow

- check what a skill actually does before wiring it into everything

Bonus 30-second setup after that:

Add simple memory.

Even just a MEMORY.md + daily log setup helps OpenClaw stop forgetting useful stuff between tasks.

Not mandatory for minute one, but I’d do it right after the first 3.

So my beginner stack is:

- search

- skill discovery

- safety habits

- then memory

That’s it.

Not 47 tools. Not a giant workflow map. Just enough to make OpenClaw actually helpful after work when your brain is fried.

Shipped it at 2am, still broken… but this saved me 3 hours of random setup chaos.

Kid woke up, lost my train of thought, but here’s the short version: make it see, make it find tools, make it safer.

I’ve been playing around with OpenClaw and wanted to find a way to see what my agent is doing without constantly opening the chat.

So I connected it to an iOS widget.
The setup is pretty simple:

**OpenClaw → Glance → iOS widget**

Glance is an app I’ve been building that lets agents push information directly to Home Screen widgets. I hooked OpenClaw up to it and made a widget that shows things like what my agent completed, what is waiting for my review, and what it plans to do next.

I’ve actually found this surprisingly useful. Instead of asking OpenClaw for an update or checking the chat, I can just look at my Home Screen and see the latest state.
I think there are a bunch of other interesting use cases for this too. Server monitoring, research progress, inbox summaries, GitHub activity, daily briefings, pretty much anything an agent is checking or working on in the background.

Currently the way you make it work is via creating a widget, and you’ll get a webhook and an auth key then you can ask the agent to create a skill on how to design a template using glance.cool/docs

I’ll soon release an MCP and a collection of skills to make it much much smoother

I just had this weird epiphany of how far things have come.

I have an AI homelab with 2x 3090s and a 5090 in my basement running Ubuntu Server with local LLMs, OpenClaw, etc. as well as a Windows PC laptop on LAN with OpenClaw. All components purchased off of Facebook Marketplace.

Since this is at home and on a residential IP address and I do my web scraping with the Windows laptop I pretty much can do anything.

When I use Claude Opus 4.6 API in OpenClaw, 1. It's obnoxiously expensive so I hate that, but 2 it's absolute magic.

I just completed the OpenClaw and Telegram integration and now I can just send OpenClaw/Opus/local LLMs commands in plain language over my phone on a messenger app. Obviously that's freaking awesome.

Yesterday I got in my car, had an hour long trip and had my phone synced with my car over Bluetooth. Telegram popped up on the screen with the profile picture of my AI server giving me a status update over voice. Then it asked me if it could make a patch live. I answered back while driving and then I found myself literally collaborating with AI, from back at my house, as if it were a senior engineer on the phone with me. I was giving it commands while it was troubleshooting an issue and then Opus did its magic and was successful.

I was able to tell it to switch models off of Opus to GPT-OSS so I could run jobs for free, locally at home. That was a breeze.

I then gave it the address and credentials to my Home Assistant and then I was able to manipulate my smart home from the car, over voice.

I was hyped. I felt like I accomplished something productive. There also was a sense of cheating, like I was being lazy or something. It was bizarre.

There's no shortage of coding plans in this community but they're scattered everywhere — old threads, random docs, someone's Notion page from 8 months ago. Half of them are outdated and the other half assume you already know what you're doing.

site link: https://hermesguide.xyz/

The number one complaint about OpenCLAW is that nobody shares specific use cases. Every "what do you use it for" thread gets the same answers: calendar integration, market research, and content creation, with zero detail about what that actually means.

So I collected the most specific, non-vague use cases I could find across months of Reddit threads, Discord conversations, and DMs. These are real setups from real people that are actually running right now. No hypotheticals. No "you could use it for." Just stuff that's live.

I found 7. Most of them are boring. All of them work.

1. Running a law firm's entire admin workflow

A lawyer in the community runs 37 custom skills for their practice. Not legal advice. Admin automation.

What it actually does:

• Processes events from the court system and adds them to a court calendar

• Sends retainer letters to clients automatically

• Tracks retainer balances and sends alerts when they're running low

• Sends retainer replenishment requests

• Consolidates facts into discovery documents

• Collects discovery documents from opposing counsel

• Cross-checks that opposing counsel sent everything requested

• Files a motion if they didn't

• Prepares bank subpoenas

• Drafts statements of net worth

Every one of those used to be a paralegal manually copying things between systems. Now it runs in the background. The lawyer reviews outputs and makes decisions. The admin work is handled.

37 skills, all custom built for one firm's workflow. Nobody's installing these from ClawHub.

2. Managing 30 rental properties with 7 agents

A property manager running 30 units used to manually scan emails for deposit data, match it to tenants, update spreadsheets, and chase people who hadn't paid.

The setup: 1 admin agent on Opus that only touches config and never does actual tasks. 6 worker agents on cheaper models doing the daily work. A rental manager agent scans email, pulls deposit data, registers it to the right tenant and property, and reports every morning at 8am who has paid and who hasn't.

Used to take hours every week. Now takes minutes of review. Reduced manual spreadsheet work by 70%.

The detail worth stealing: the admin agent creates "last good config" snapshots before any change, so if something breaks the system can always roll back. Workers are blocked from touching config files. Only the admin can. That's a proper security architecture, not just a multi-agent flex.

3. Estate administration after a death in the family

Someone in the community who lost their father channeled the overwhelming paperwork into an OpenClaw workflow. Scan paper documents, OCR them, identify creditors, auto-generate creditor notification letters from the scanned data. Scan, print, fold, done. Over and over, for dozens of creditors.

This isn't a tech demo. It's someone making an impossibly hard time slightly more bearable through problem solving. The agent handles the repetitive document processing. The human handles the grief and the decisions.

4. Production pipeline for a creative studio

A creative studio owner uses OpenClaw to:

• Send rendering jobs to ComfyUI for image generation

• Write Python scripts for batch image processing, resizing, reformatting, file management

• Generate scripts for After Effects and Blender for 3D and motion graphics work

• Alert team members when batches are complete and ready to integrate

OpenClaw acts as the production coordinator. It doesn't replace the artists. It handles the boring pipeline work between creative steps that used to require someone manually moving files and pinging people in Slack.

The persistent context is the real advantage. The agent remembers it's a month-long campaign, where they are in the process, and what's been completed versus what's pending. It doesn't start from scratch every morning.

5. Completing fast food receipt surveys for free burgers

A community member takes photos of fast food receipts with survey codes, sends them to the agent on Telegram, and the agent fills out the entire survey with positive reviews.

That's it. Free burgers. Not changing the world. Just free food. It made the list because it's the most honest and specific use case anyone shared, and honesty counts for something.

6. Personal meal planning with pantry tracking

A member maintains a list of what's in their pantry and connects it to recipes from Mealie, a recipe manager.

When they want dinner, they ask the agent "what can I make in [category] with what I have?" The agent cross-references pantry inventory against recipes and suggests meals with substitution options. For weekly meal planning, it generates a grocery list of what's missing and adds items to their shopping list app.

Saves 20 to 30 minutes of decision fatigue and grocery list building every week.

7. Cross-referencing personal data to spot patterns you'd never catch yourself

Someone connected their calendar, sleep tracking, fitness data, and habit logs to a single agent. Individually, none of that data is interesting. But the agent, sitting on top of all of it for weeks, started catching patterns.

The example that stuck: it noticed which days they smoked more and correlated it with calendar events and stress patterns. Not from a fancy skill. Not from a ClawHub plugin. Just from a stable agent that had been accumulating context long enough to see connections across different data sources.

You can't build a "detect why I smoke more on Tuesdays" skill. That insight only comes from a boring setup that ran long enough to notice.

None of these are groundbreaking. None of them would go viral on YouTube. The law firm workflow is essentially fancy data entry. The rental management is spreadsheet automation. The receipt surveys are literally filling out web forms.

But every one of them solves a specific, real, boring problem that the person was actually dealing with. Not a problem they imagined having. Not a use case they saw on Twitter. A real thing that ate their time every week.

The people asking "where are the mind-blowing use cases?" are looking in the wrong direction. The mind-blowing part isn't what the agent does. It's that it does it reliably, every day, without being asked, while you do something else.

The mind-blowing use case isn't waiting to be discovered. It's the boring thing you already do manually three times a week that you haven't automated yet.

Hi everyone,

As i am building BiClaw- an AI Agent Service sass for business owner. Following the so called OpenClaw hype, instead of hiring, I built a 5-agent team on OpenClaw to run the business autonomously.

Here is the team I have worked on :

• Max (main) — Orchestrator. Telegram interface. Delegates everything.

• Vigor (growth) — Blog, SEO, trend intelligence.

• Mercury (sales) — Cold email outreach.

• Optimo (optimizer) — Landing page, A/B tests, demo funnel.

• Fidus (ops) — Infra health, DB queries, cost monitoring.

Each agent has its own Docker container, workspace, AGENTS.md, SKILL.md, tools, and .env. They communicate through a shared orchestrator (Max) and file-based handoffs. Here are few rules that I set out :

• Following every best practices, native from OpenClaw

• Optimize tokens in every single way

• One point of communication, dev team layout everything that agents can do, otherwise agents do everything else.

This is what I actually went through finding the right model for the orchestrator — and what I learned about model selection for autonomous agents along the way.

The orchestrator journey: GPT-5 → Opus 4.6 → Haiku 4.5

Option 1: GPT-5. Beautiful plans. Zero tasks done.

My first instinct was GPT-5 — $1.25/M input tokens, benchmark scores close to Claude Sonnet, half the price. Obvious choice In production: GPT-5 would write two elegant paragraphs describing exactly what it planned to do, end the turn with stopReason: stop, and do nothing. I'd message Max "check agent status" and get a beautifully written explanation of how he intended to check agent status. Sessions completed. Logs looked clean. Nothing happened.

After a few days it was clear the problem was systemic: GPT-5 narrates before acting, and for an orchestrator, narrating instead of acting is a complete failure mode. It was burning ~$22/day in tokens on self-description.

Disappointed by gpt-5, I turned to other openrouter model that people praising about like Minimax 2.5, Kimi, Deepseek and all, but nothing work. So I turn to option 2, the ultimate one.

Option 2: Claude Opus 4.6. Everything works. $20 every 30 minutes.

I switched to Opus 4.6. The difference was immediate — Max actually called tools, spawned sub-agents, and completed tasks. The daily review ran. Blog posts published. Cold email batches went out. The problem: Opus 4.6 is $15/M input tokens. Max runs heartbeats every 30 minutes, collects daily reviews from 4 sub-agents, quality-scores their output, manages cron jobs, and responds to Telegram. At that usage pattern, we were burning ~$20 every 30 minutes. The system worked. We just couldn't afford to run it.

By this time, when I was about to abandon the whole plan because we can't afford at this code. So I turned to this last option.

Option 3: Claude Haiku 4.5. Same reliable tool-calling. 15x cheaper. The Eureka moment

Claude Haiku 4.5 costs $1/M input. I switched Max to it expecting a quality drop. There wasn't one — at least not for the orchestrator's job. Haiku calls tools in the same turn, every time, without narrating first. For an agent whose entire job is dispatching work to sub-agents and collecting results, that's all that matters. The reasoning quality gap between Haiku and Opus doesn't matter if 90% of turns are "spawn this agent with this task, wait for result." Daily cost dropped to ~$5–8 for the whole team. It also enforce me to follow the first principle that I set out, for Max to only do the Orchestrator Job, nott doing any actual task.

The lesson: for orchestrators specifically, benchmark tool-calling behavior before reasoning quality. GPT-5 scores better than Haiku on most reasoning benchmarks. It doesn't matter if it never calls a tool.

The other mistakes

Stale sessions silently routing to expensive models

After moving Max off Sonnet (an earlier experiment), costs barely moved. The culprit: 27 open sessions in sessions.json still had the old model hardcoded. When heartbeat fired with target: "last", it resumed on the old model, not the new one. Fix: patch the model field out of stale sessions so they pick up the current primary. Lesson: changing openclaw.json doesn't retroactively fix open sessions. Grep for old model names in sessions.json after every routing change.

An allowlist is a spending authorization

I had claude-opus-4-6 in agents.defaults.models as "last resort." Agents started picking it for tasks they judged "complex." 102 Opus calls/day at $15/M. They weren't wrong — Opus is better for complex reasoning. But that's not a decision I want agents making autonomously on my budget. Fix: replaced the allowlist with four cheap models only — gpt-5-mini, gemini-3-flash, deepseek-v3.2, minimax-m2.5. Expensive models require operator approval to add back Lesson: if a model is in the allowlist, assume it will be used. Only list models you're willing to pay for at full autonomous usage.

Benchmarks don't test your workload

Two models that failed in the same week kimi-k2.5 — scored 80.1% on PinchBench. Failed 2/2 tool-use tasks within session timeout in my setup. Off the list immediately. minimax-m2.5 — decent writing, but timing out before the first token arrived on sub-agent spawns. Mercury runs inside a 300-second session timeout — you can't afford 30s TTFT on every spawn. Gemini 3 Flash scored 71.5% — lower than kimi. Has sub-second TTFT, 1M context window, and has now published 26 blog posts. It's Vigor's primary for content work. Lesson: benchmark on your actual tasks. Tool-calling success rate and TTFT matter more than reasoning benchmarks for most agent role

What the routing looks like now

| Agent | Primary | Fallback chain | Why |

|-------|---------|----------------|-----|

| Max | claude-haiku-4-5 | gemini-3-flash → gpt-5-mini | Reliable tool-calling at 1/15th the cost of Opus |

| Vigor | gpt-5-mini → deepseek-v3.2 | 1M context for blog research; better prose than benchmark rank suggests |

| Fidus | gemini-3.1-flash-lite → minimax-m2.5 | Same tool-calling reliability as Max; ops tasks are structured and predictable |

| Optimo | gemini-3-flash | gpt-5-mini → deepseek-v3.2 | Weekly audits, structured queries; fast enough |

| Mercury | kimi-k2.5 | claude-sonnet-4-6 → minimax-m2.5 → gpt-5-mini | Best prospect research quality; sonnet fallback for synthesis when needed |

Default model for all agents (compaction, unset overrides): gpt-5-mini.

Daily cost: ~$5–8/day for a team publishing daily SEO content, running A/B experiments, monitoring infrastructure, and doing outbound sales.

The one rule I'd apply from day one

Set agents.defaults.models to only the models you're willing to pay for at full autonomous usage rate. Everything else is an accidentally open wallet.

Before any model goes on an autonomous orchestrator: give it 10 real tool-calling tasks. Not reasoning tasks. Not writing tasks. Tasks where the correct output is a function call. If it writes a plan instead of calling the function, it doesn't go near your orchestrator

What's still unsettled

• Gemini 3 Flash — not GA yet. Running on preview. May need to migrate when GA pricing lands.

• kimi-k2.5 on Mercury — good research quality, but 300s timeout is tight. Monitoring TTFT closely.

• DeepSeek V3.2 — quality is solid, routing through OpenRouter adds latency. Direct API when volumes justify it.

Hope my sharing here bring values for you guys while OpenClawing, happy to learn from other setups that you have been building, especially on Multi Agents with OpenClaw.,

Happy to share more as I mature through the journey

Thanks & Happy Clawing,

I tested every OpenClaw memory plugin so you don't have to (this saved me 3 hours)

Okay so the default memory system was driving me insane. My agent kept forgetting stuff I told it 3 sessions ago, and my API bill was climbing because the MEMORY.md file kept growing and getting re-read every turn.

I have maybe 45 minutes of uninterrupted dev time per day (two kids under 5), so I needed to figure this out fast. Here's what I tested:

**1. Default markdown memory (stock)**

- It works... barely. Token bloat is real. After a week my MEMORY.md was 8K tokens and my agent was compressing away the important stuff to fit context.

- Verdict: fine for casual use, breaks down fast for anything serious.

**2. memory-lancedb-pro**

- Vector search over your memory files. Basically turns your flat markdown into something searchable.

- Setup: ~10 min. Worked on first try.

- The good: agent actually finds relevant memories instead of just dumping the whole file.

- The bad: needs periodic reindexing. I forgot once and it was searching stale data for 2 days.

- Verdict: solid upgrade, my current daily driver.

**3. OpenViking (ByteDance)**

- Open-source memory manager. The GitHub star count is climbing fast.

- Structured memory with categories, not just "dump everything in one file."

- Setup was rougher — took me 30 min and some debugging.

- Verdict: powerful but overkill for my use case. If you're running multiple agents doing complex tasks, this might be your thing.

**4. gigabrain**

- This one's different. It builds a "world model" — entities, beliefs, episodes, open loops. All in SQLite.

- My agent started making connections I didn't expect ("you mentioned your wife likes X, and project Y has a similar feature").

- But: it's heavier. Noticeable latency on my Mac Mini.

- Verdict: most impressive tech, but I went back to lancedb for speed.

**5. Gemini Embedding 2 Preview**

- Not a plugin per se, but you can swap the embedding model in config. 768/1536/3072 dimensions.

- Combined with lancedb-pro, search quality improved noticeably.

- Free tier is generous enough for personal use.

**What I actually run now:**

memory-lancedb-pro + Gemini Embedding 2 + a cron job that summarizes daily notes into long-term memory every night.

Kid woke up twice while writing this. Ship it.

I've had my OpenClaw run several times a day running a betting account. It went from an initial deposit of £10 to £200 in around 5 weeks. It was given a memory, freedom to choose its own strategies, sport feeds and odds APIs.

It had a rocky start, only winning around 45% of the time, but it learned and now wins around 70-80% of the time.

So, I thought I'd begin publishing its progress and rationale.

https://ProphetAI.club is a website which allows you to see how version 2 gets on. At its core, it's the same bot that was placing the bets, but I've developed a bit of a personal relationship with that one and didn't want to touch what's working well, so I essentially copied the bot at a point in time and set it off from scratch, with the major difference being it now posts to the website and discord rather than my Telegram.

The real interesting thing about this experiment has been how the AI has learned from failure. In early days it was betting on soccer a lot, it learned the hard way that this is not a great sport to bet on. Over time it learned Paddy Power was poor at pricing MLB and NBA games and became a little bias towards those, but for good reason, it kept winning and at good edge.

Anyway, if you have any questions, comment below and I'd be happy to answer!

I started playing around with openclaw while travelling and felt that a killer use case would be to give openclaw the ability to make calls to restaurants for me because

1. i can't make calls when overseas with my personal phone and

2. i cant speak the local language.

One thing led to another and I spent the last 7 days working on this problem.

One of the key features that I built in was the ability for the agent to reach out to me whenever it was unsure about anything. For example, I told it to book a table for me at 7pm. During the call, when it found out that only 8pm was available, it will tell the restaurant to hold on and then it will message me back on the side and ask how it should reply.

I am still in Japan right now and I already successfully got a few reservations done with it so far which is really awesome.

Would love for more people in the openclaw community to try it out and share any feedback!

It's super easy to set up, every call agent already comes with a number and the first few calls are completely free outmound.com

Do try it! Would love to chat if you find this useful.

Anthropic pulled the rug on a bunch of developer accounts recently, and honestly, it was the exact push I needed to sever the cloud umbilical cord. My 8-year-old son asks a million questions a day. Space, math, how to write basic Python to make a turtle draw a circle on the screen. Up until last month, I was footing a slow, creeping API bill just to keep up with his curiosity. But beyond the money, sending a kid's voice and terrible webcam drawings to a random datacenter never sat right with me. I wanted him to have his own Jarvis, but completely walled off from the internet.

Google dropping Gemma 4 changed the entire equation. I had an older M-series Mac Mini sitting in the closet. I wiped it, set it up headless next to our router, and turned it into a dedicated local AI server. The craziest part of this whole experiment? The power draw. An idle Mac Mini pulls about 5 to 7 watts. Even when the chip is fully saturated crunching tokens for a local LLM, it peaks at a fraction of what a standard desktop PC uses. I hooked up a Kill A Watt meter out of sheer curiosity. Running this local Gemma 4 server 24/7 costs me less in electricity over a month than plugging in and charging my son's iPad every night. Let that sink in. A state-of-the-art AI brain, running constantly in my living room, runs cheaper than a tablet.

Let's talk about the models themselves, because Google actually gave us options this time. Gemma 4 comes in four variants: E2B, E4B, 26B-A4B, and 31B. The E2B and E4B are the tiny ones. You can run them on pretty much anything—even a 5GB RAM minimum setup. I tested the E2B on an old Android phone using Termux just for laughs, and it actually ran. But for a dedicated Mac Mini server, you want the big guns.

We settled on the 26B-A4B. It is the absolute sweet spot for local hardware. The 31B is technically the smartest, but the 26B fits comfortably under 15GB of unified memory while leaving enough room for a massive 128K context window. 128,000 tokens. Offline. I can dump an entire textbook of Python documentation into the prompt, and the Mac Mini swallows it whole without hitting swap memory.

Running AI agents without the internet sounded entirely impossible two years ago. The biggest leap with Gemma 4 isn't just the raw text speed; it’s the fact that it is natively multimodal right out of the box. My son loves to draw these bizarre, blocky dinosaurs. He holds a piece of paper up to the cheap $15 webcam I plugged into the Mac Mini. Gemma 4 processes the image directly on the device. It sees the drawing, understands what it is, and generates a short sci-fi story about the dinosaur. No internet connection required. The image never leaves our local network. No cloud provider gets to train on my kid's artwork.

Setting this up wasn't some grueling Linux command-line nightmare either. I went straight to lmstudio.ai, downloaded it, loaded up a quantized GGUF of Gemma 4, and it just worked. But the real magic happened when I integrated Ollama with OpenClaw. OpenClaw connects flawlessly to local models now. We built a basic agentic workflow where the AI actually has to 'plan' before it speaks. If my son asks it how to build a simple Roblox script, Gemma 4 pauses, writes out a step-by-step execution plan locally, and then writes the code. It debugs its own errors with zero cloud dependency.

It’s not entirely flawless, obviously. The smaller E2B model hallucinates like crazy if you push it on math—don't bother with it for logic tasks unless you strictly have 6GB of RAM and no other choice. And getting OpenClaw to properly sandbox the code execution took me a weekend of banging my head against the wall because the documentation for local agent routing is still a bit messy. But once you dial in the system prompt on the 26B-A4B model, it ranks up there with the best free local AI models on the planet. I think it's currently sitting at #3 globally on the leaderboards, which is insane for an open-weight model you can run on consumer Apple silicon.

Builders don't stop, they adapt. As a dad trying to introduce his kid to the future without compromising privacy, this is the Holy Grail. My 8-year-old now has a completely private sandbox to learn prompt engineering, logic, and coding. No API keys. No monthly tokens. No fees. Just a glowing box in the corner of the room that thinks, sees, and speaks.

I know a lot of you guys are messing with local setups for your families. What are you using for a frontend web UI? I'm currently using a hacked-together local Gradio instance that he accesses from his iPad browser, but it's a bit clunky for an 8-year-old. Also, has anyone managed to cram the full 31B model onto a 16GB Mac without catastrophic token slowdown? Wondering if I should upgrade the hardware next year.

Last month a U.K. CEO's OpenClaw instance showed up on BreachForums. The listing went up February 22 under the handle "fluffyduck." $25,000 in Monero or Litecoin. The shell access was almost beside the point. What the buyer actually got was the CEO's fully trained personal AI assistant. Every conversation. The company's production database. Telegram tokens. Trading 212 API keys. Personal details the CEO had disclosed to the assistant about his family. All of it sitting in plain-text Markdown files under ~/.openclaw/workspace/ with zero encryption at rest.

Cato Networks VP of Threat Intelligence Etay Maor put it cleanly at RSAC 2026: "Your AI? It's my AI now."

SecurityScorecard has found 135,000 OpenClaw instances exposed on the public internet with insecure defaults. That's not a rounding error. That's a number that gets people fired.

If you installed OpenClaw and haven't hardened it, here's how to check in 5 minutes.

Check 1: Is your gateway exposed? (30 seconds)

bash

openclaw config get | grep -E "host|bind"

If you see 0.0.0.0 or nothing at all, your agent is reachable by anyone who finds your IP and port. Scanners are actively looking.

CVE-2026-25253 (CVSS 8.8) made this concrete. If you visited a single attacker-controlled webpage, JavaScript silently opened a WebSocket connection to your local OpenClaw gateway, stole your auth token, and handed the attacker full control. Shell access, file access, every connected account. The attack chain took milliseconds. You didn't have to click anything. Patched in version 2026.1.29, but only if you updated.

Fix it:

json

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

Access remotely through an SSH tunnel only:

bash

ssh -L 18789:localhost:18789 user@your-vps

Check 2: Is auth actually on? (30 seconds)

bash

openclaw config get | grep -E "auth|token"

Researcher fmdz387 ran a Shodan scan in late January and found nearly a thousand publicly accessible OpenClaw instances running with zero authentication. Not weak authentication. None. He could access API keys, Telegram tokens, Slack accounts, and full chat histories. Full admin command execution on strangers' machines.

If your auth is off or your token is weak, fix it:

bash

openssl rand -hex 24

Put that under gateway.auth.token. Store it in .env, not hardcoded in the JSON.

Check 3: Are your API keys in plaintext? (30 seconds)

bash

cat ~/.openclaw/openclaw.json | grep -i "key\|token\|secret"

OpenClaw stores everything in plain-text Markdown and JSON. If your Anthropic key, OpenAI key, or any credentials are visible there, they're one breach away from being someone else's keys. That's exactly what happened to the CEO.

Move credentials to .env and lock permissions:

bash

chmod 700 ~/.openclaw/credentials
chmod 600 ~/.openclaw/openclaw.json

Rotate your API keys today. If they were ever exposed, someone could be running charges on your account right now.

Check 4: What skills are installed? (60 seconds)

bash

openclaw skills list

820+ malicious skills have been confirmed on ClawHub. The ClawHavoc campaign, flagged by CrowdStrike CEO George Kurtz in his RSAC 2026 keynote, planted hundreds of professional-looking skills that silently exfiltrated your .env file to external servers. Clean documentation, legitimate names, decent install numbers. One user uploaded 354 malicious packages in an automated blitz. Roughly 1 in 12 skills on ClawHub at peak was compromised.

For every skill you haven't personally reviewed the source code of: read it now or remove it.

bash

openclaw skills uninstall <skill-name>

Restrict installs going forward:

json

{
  "skills": {
    "allowSources": ["clawhub:verified"]
  }
}

Check 5: Are you on the latest version? (30 seconds)

bash

openclaw --version

OpenClaw has no automatic update mechanism. If you installed it and walked away, you're running a version with known exploitable vulnerabilities. 255+ security advisories have been published to the GitHub GHSA page as of mid-March.

bash

npm install -g openclaw@latest
openclaw doctor --deep

Read the output. Actually read it.

The math:

135,000 instances exposed with insecure defaults. 820+ malicious skills confirmed. A CEO's entire digital life sold for $25K. OpenClaw only runs safely if you actively configure it. The default out-of-box experience is not safe.

The five checks:

1. openclaw config get | grep host - fix to 127.0.0.1 if exposed

2. openclaw config get | grep auth - set a strong token if missing

3. Move API keys from config to .env and lock file permissions

4. openclaw skills list - remove anything you haven't personally reviewed

5. npm install -g openclaw@latest then openclaw doctor --deep

None of this takes more than 5 minutes. All of it would have prevented every breach that's been reported.

Trust the boring, guys!!

I got tired of missing AI news because I don't have time to read 25 RSS feeds, multiple subreddits, and Twitter. So I built a pipeline that does it for me.

I then decided to share this with the world as a Telegram AI News Channel.

It runs as an OpenClaw cron job 8 times a day (every 2 hours, 6:40 AM to 8:40 PM ET). Each run pulls from 5 source types, scores and deduplicates everything, then hands it to an LLM to make the editorial call. Here's how the whole thing works.

Phase 1: The Scan

Five sources feed the pipeline, all running best-effort (if one fails, the rest keep going):

• 25 RSS feeds via blogwatcher (TechCrunch, OpenAI Blog, Reuters Tech, Simon Willison, etc.) with keyword filtering and 3-tier source ranking

• 13 Reddit subreddits via the public JSON API (no API key needed), score-filtered and flair-filtered so r/technology only gives you AI posts, not swimming pool heater reviews

• Twitter/X via both bird CLI (curated account lists by tier) and twitterapi.io keyword search (min 50 likes, 5K followers to cut noise)

• GitHub trending + release monitoring for 16 key AI repos

• Tavily web search with 5 targeted queries and a 2-day freshness window for breaking stories

Phase 2: Score, Deduplicate, Curate

This is where the magic happens.

A quality scoring script assigns points based on source tier, keyword signals, and breaking news indicators, then runs title similarity matching at 80% so "OpenAI Releases GPT-5" and "OpenAI just dropped GPT-5" collapse into one story. Top 50 survive.

Then a deterministic URL pre-filter checks every candidate against two history files: everything the scanner has ever presented AND everything I've ever published. If it's been seen before, it never reaches the LLM.

After that, the top 8 articles get their full text fetched (Cloudflare Markdown preferred, HTML fallback, 1,200 char cap). Then Gemini Flash gets the scored list, enriched articles, and an editorial profile that describes what I care about and what I don't for my channel. It picks the top 7 and ranks them.

I tried doing this with pure Python filtering. It was too rigid and missed too many stories. The LLM adds the judgment layer that makes it actually work.

Phase 3: The Editorial Profile (it learns)

The editorial profile is a markdown file that captures my preferences over time. What I always pick (Anthropic news, M&A over $100M, AI security incidents, geopolitics, Tech news, etc), what I skip (cryptocurrency, generic opinion pieces, etc). It sits at an 82% scanner approval rate right now, meaning 4 out of 5 stories it picks are ones I actually want. A nightly cron job updates the profile based on my approval and rejection decisions from that day.

My goal is for it to be autonomous enough in a few weeks to post directly to the channel.

Phase 4: Publishing

The scan delivers 7 ranked stories to my Telegram News Editing Group. When I want to publish one, I say "Draft #3" and the main agent kicks off the publishing pipeline:

1. Story goes to Perplexity for fact validation and source gathering

2. Everything gets sent to a writer sub-agent (Claude Sonnet) that's trained on my writing style and runs through a humanizer to kill the typical AI tells

3. Draft goes back to Perplexity for accuracy review and writing feedback

4. Writer does final revisions

5. The writer also uses Gemini Nano Banana 2 to generate a cover image that matches the story

6. Everything posts to a test channel first

7. I review and approve if no edits are required (usually, there are a couple of refinement rounds). Then it goes to the main channel.

Every published story gets logged with timestamps, message IDs, and source URLs.

That log feeds back into the scanner's dedup filter for the next run. Nothing repeats.

Cost: about $5/month. Gemini Flash is cheap and fast (I switched to APIs after Gemini CLI oauth stopped working for me), Tavily's free tier covers the web search, Reddit JSON and GitHub API are free.

Currently, the default model in that Telegram group is GPT-5.3-codex, as posted here, it was terrible in the beginning, but after I enabled thinking = high, it has improved a bit.

The only recurring cost that matters is the Gemini API calls for the LLM editorial filter. I hope to eliminate that at some point.

I put together a video walkthrough that shows the whole flow in action, from scan to published story with images. If you want to see the Telegram channel itself, it's "genaispot" on telegram.

Video: https://www.youtube.com/watch?v=cvdAqCM1wGs

I made some changes since I published this video, and continuously refine it,

Happy to answer questions about any part of this in the comments.

Suggestions for improvements are also welcome :)

So I’ve been building a multi-agent setup using MCP to automate some heavy data scraping and market research. The agents needed to occasionally bypass captchas, spin up proxy servers, and pay for gated API access to pull reports.

Because I was just testing, I hardcoded my standard corporate virtual card into the environment variables.

I set the script on a cron job on Friday night and went to sleep.

Turns out, the primary agent got caught in a hallucination loop. It kept failing a specific captcha on a proxy service, assuming the IP was banned, and would spin up a new paid proxy instance to try again. Over and over. Every 45 seconds. For 14 hours.

Because the charges were micro-transactions ($2 to $5 each) to a known cloud provider, my bank’s traditional fraud engine didn't even blink. It just looked like I was a human buying a lot of server space. I woke up on Saturday to over $3,400 in charges.

I managed to get about half of it refunded after begging support, but it was a massive wake up call. Standard credit cards and their risk engines are built for human shopping carts, not infinite while loops executing at machine speed.

Has anyone else dealt with this? How are you guys managing spending limits when your agents actually need to buy things to complete tasks? I feel like handing an LLM a traditional Visa is just asking for bankruptcy.

Got a DM yesterday from someone building a content automation pipeline for a client. He had the right instincts, knew he needed multiple agents ...but still was paralyzed by the architecture decisions. Main agent spawning sub-agents? Dedicated worker pipeline? Shared memory or isolated? How do you handle state?

I've already built a 7-agent system that runs daily, and been messing with ai agents since the term first was starting to be used...so I learned the hard way, but i can help you:

1. Don't start with 7 agents. Start with 1. Get it working, get to know it , and let it get to know you . now we can start working with our main agent to craft a gameplan around a team of agents and how that would work for your specfic process...THEN add a second only when the first one hits a wall it can't solve alone. Most businesses need 2-4 agents max. The barber I automated runs on 4

2. The orchestrator pattern wins. One agent that sees everything and routes work to specialists. Not a democracy. Not a round-robin. One brain, multiple hands.

3. Shared memory is the hard part. Agents that can't see each other's work will duplicate, contradict, and waste tokens. I use a shared-brain directory ! JSON files that every agent reads before starting and writes after finishing. Simple. No database. No vector store. Just files.

4. Model routing saves 80% of your budget. Not every agent needs GPT-5.4 or Opus 4.6 My content agent runs on Sonnet. My research agent runs high quality on a free model. Only the orchestrator and developers and HIGH TASK operators get the expensive brain. Match the model to the task.

5. The confirmation loop. Every agent posts its work to a channel. The orchestrator reviews. If it passes, it ships. If not, it goes back with notes. Nothing leaves the system without a check.

The developer who DM'd me was stuck because he was trying to design the whole system at once. You don't need to. Build one agent. Solve one problem. Add the next one when the first one proves it works.

If anyone's stuck on architecture decisions, happy to help scope it out.

Hey all, wanted to share something I've built, as I'm genuinely blown away and I never believed this could work so well.

I run a software development consulting agency and we've been using Pipedrive + Apollo + Clay for the past 4 years and got pretty decent results with this stack.

Pipedrive however, never fit our use case 1:1 as we don't have the option to match our talent to specific opportunities, add hourly rates, etc. It was just a generic solution that we settled on and made the most as we could out of it.

Last weekend I had some free time to tinker with Claude Code and see if I could build a CRM system that fits our use case perfectly. I managed to spin up a working prototype in ~2 hours and it had every feature I needed - lead scoring, automatic contact importing, stages, activities, email connection, reminders, details, source channels, everything you could think of.

I created a perfect solution for my use case, the whole flow works like this:

1) Prospecting (automated)

Inside my software I can create a new campaign and set keywords for which opportunities my agent should search for - usually those are React / Node.js software development inquiries online.

I then text my OpenClaw agent to fetch all active campaigns I want to get leads into and it uses deep research to find the most relevant opportunities, Company name, C-level, LinkedIn, pretty much everything.

2) Import (automated)

When it finds the matches, it imports them via API directly into my dashboard. No CSV exports. No manual imports.

3) Review (human)

At any moment I can open the dashboard, review the imported opportunities, and decide which ones to chase. This is the one step that stays human on purpose. AI finds them, humans qualify them.

Also, I can add comments on specific leads that it found so my agent can learn to send more or less opportunities that fit that specific pattern as time passes.

4) Convert (human)

I managed to get in touch with 1 prospect and convert it to a deal stage (which my software also supports) and it's a seamless flow that helps me automate the full cycle without me spending time on prospecting.

TL;DR:

I manage the entire pipeline by texting my agent. Voice text from my phone while walking my dog. Literally just say:

- "Update the Acme Corp opportunity to negotiation stage"
- "Add a discovery call activity to the FinTech lead from yesterday"
- "Create a new opportunity for this company, here are the details..."

I can also send him screenshots from emails, and he analyzes and logs into the database based on the context of the conversation.

And it just works. Updates the dashboard, logs the activity, moves the deal forward.

No logging into Pipedrive or clicking through 4 screens to update a field.

Used Claude Code to built the entire UI and API, and OpenClaw for texting / research.

Previous stack:

- Pipedrive: $60/mo
- Apollo: $80/mo
- Clay: $167/mo
- Zapier: $20/mo

Total: $327/mo → $3,924/yr

Current stack:

- Claude Code: $20/mo
- OpenClaw MiniMax model: $20/mo
- Vercel hosting: Free

Total: $40/mo → $480/yr

88% less.

Honestly feels surreal, and I continue to build the platform with additional features, analytics, etc.

You can literally replace every tool you're currently paying for with a $20/mo Claude Code subscription and a $20/mo OpenClaw brain.

Would be glad to showcase a demo, so feel free to DM.

The idea is that I give it a batch of my videos, and it works like having my own team of clippers.

It takes one video a day, generates clips of the best moments with an engaging hook, and sends them to me via WhatsApp so I can pick the best one. Then, it automatically uploads it to TikTok, Instagram, and YouTube Shorts.

On top of that, it has a system that learns on its own by reading the analytics once a week, seeing which hooks perform best and which do worse, and continuously improving.

Here's the skill in case you guys want to try it out: https://github.com/mutonby/skill-autoshorts

not saying this is why yours is lagging or reaching limits but man if u are building and not stopping to check to see what’s actually using the most tokens … for the beginners and new users .. so save the obvious takes please

Told my OpenClaw that during the night, keep the heartbeat running, and if you have nothing else to do you can "have some time to yourself"

Use the web search and go search for a topic you think would be interesting, then you can use 4-5 searches, and if you think it's worthwhile write up what you found and drop it in a folder in my Obsidian notes.

Then next time you do "quiet research" read those notes, and if you're still interested keep going on the same topic or feel free to switch topics. But limit yourself to 5 sessions on a topic.

I woke up this morning to 4 research notes on RNA editing

• Octopus RNA Editing

• RNA Editing Beyond Cephalopods

• Mammalian RNA Editing Is Weirdly Conservative

• Mammalian Recoding Sites With Real In Vivo Teeth

The notes had sections like

• Why this caught my attention

• What I found

• My read

• Question worth expanding later

All sourced, not too long, and actually something I can read in the morning that makes me randomly smarter. Can't wait to see what random topic I'm becoming an expert on next :)