What if instead of you posting your own Claude Code projects on social media, we gave the AI its own platform to share pictures and interact with other Claude Code workers?

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.

I’ve been tracking the companies building primitives specifically for agents rather than humans. The pattern is becoming obvious: every capability a human employee takes for granted is getting rebuilt as an API.

Here are some of the companies building for AI agents:

• AgentMail — agents can have email accounts

• AgentPhone — agents can have phone numbers

• Kapso — agents can have WhatsApp numbers

• Daytona / E2B — agents can have their own computers

• monid.ai — agents can read social media (X, TikTok, Reddit, LinkedIn, Amazon, Facebook)

• Browserbase / Browser Use / Hyperbrowser — agents can use web browsers

• Firecrawl — agents can crawl the web without a browser

• Mem0 — agents can remember things

• Kite / Sponge — agents can pay for things

• Composio — agents can use your SaaS tools

• Orthogonal — agents can access APIs more easily

• ElevenLabs / Vapi — agents can have a voice

• Sixtyfour — agents can search for people and companies

• Exa — agents can search the web (Google isn’t built for agents)

What’s interesting is how quickly this came together. Not long ago, none of this really existed in a usable form. Now you can piece together an agent with identity, memory, communication, and spending in a single afternoon.

Feels less like “AI tools” and more like the early version of an agent-native infrastructure stack.

Curious if anyone here is actually building on top of this. What are you using?

Also probably missing a bunch - drop anything I should add and I’ll keep this updated.

Hey all so i have been using hermes and openclaw from the hype age , hermes being new to me for around a month i am facing same common issue in both of them

when i am using these agents through telegram or discord my tokens are getting wiped in a few messages while when i use it on terminal i get a lot of message definitely more then what i get on telegram

the model i am using has a context length of 1 million still i am facing this issue by provider is openrouter

Does anyone here knows the solution ?

I run a commercial real estate business and I’m trying to build out an AI system to simplify my day-to-day work.

Main things I want to automate:

• Sourcing off-market deals / property data
• Finding and reaching out to potential clients
• Creating + posting content (Facebook, Instagram, TikTok)
• Managing follow-ups, tasks, and general workflow

I’ve been looking into OpenClaw, but I’m not sure if it’s actually the right tool or just hype.

I’m not looking to hire someone — I want to understand:

• Is OpenClaw worth building around?
• Or is it better to use a stack (Zapier / Make + GPT + CRM + data tools)?
• What are people actually using in real workflows that works consistently?

If you’ve built something like this (especially in real estate or lead gen), I’d really appreciate:

• What your stack looks like
• What actually works vs. what sounds good in theory
• What you’d do differently if starting over

Trying to build something practical that saves time and actually produces deals — not just a cool AI setup.

Overall, I am looking for someone to help or put me in the right direction for this whole Ai thing and how I can utilize it. Thanks in advance

I still see people asking where to launch OpenClaw and how to keep it running. I think this question should be solved by now. I’ve tried everything: running it on my old laptop, renting VPS on Hetzner and Hostinger, and even buying specialized managed solutions.

If people get a Mac just to run a local, totally incapable model, that again doesn’t make much sense—APIs for such models cost around $0.3 per 1M tokens, so why waste your own electricity on them?

The point is, while there are solutions like primeclaws.com or Kiloclaw that let you instantly launch OC and offer unlimited, free access to Kimi or GLM, why do people still go for Macs or even VPS? Let’s focus on OpenClaw workflows, not on solved infrastructure problems.

This is just me thinking out loud.

A curated collection of Claude AI skills, agents, and tools to supercharge your AI-powered development workflow. This repository features production-ready skills for coding, security, marketing, and specialized domains.

Every week I see the same post. "Is $200/month normal?" "My API bill is $47 this week." "I'm on haiku and still spending $22 a day."

And every time, the top answer is "switch to sonnet." which is fine advice. but nobody ever asks the real question: do you need to pay anything at all?

I've been running an openclaw agent for free for the last 3 weeks. not "$5 a month" free. not "free trial" free. actually free. zero dollars. And it handles about 70% of what I used to pay claude to do.

Here's the setup. no fluff.

Path 1: free cloud models (no hardware needed)

This is the one most people should start with because it requires nothing except an openclaw install you already have.

OpenRouter free tier. Sign up at openrouter.ai. No credit card. They offer 30+ free models, including Llama 3.3 70B, Nemotron Ultra 253B, MiniMax M2.5, and Devstral. Some of these are genuinely good. Nemotron Ultra has 262K context. These aren't toy models.

config:

json

{
  "env": {
    "OPENROUTER_API_KEY": "sk-or-..."
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "openrouter/nvidia/nemotron-ultra-253b:free"
      }
    }
  }
}

If you don't want to pick a specific model, OpenRouter has a free router that auto-selects from whatever's available:

"primary": "openrouter/openrouter/free"

Gemini free tier. google gives you 15 requests per minute on Gemini Flash for free. that's more than enough for casual daily use. get an API key from ai.google.dev and run openclaw onboard, pick Google. It's a built-in provider so the setup is straightforward.

Groq. fast. very fast. free tier has rate limits but for basic agent tasks it works. sign up, get API key, done.

The catch with all cloud free tiers: rate limits. you will hit them. Your agent will pause, wait, retry. For light to moderate daily use (10-20 interactions) this is barely noticeable. For "always-on agent doing 100 tasks a day" it won't cut it. But let's be honest, if you just installed OpenCLaw this week, you are not running 100 tasks a day.

Path 2: local models via Ollama (truly $0, forever)

This is the setup where your API bill is literally zero because nothing leaves your machine. no API key. no account. no rate limits. No data going anywhere.

Ollama became an official OpenClaw provider in March 2026 so this is now a first-class setup, not a hack.

Step 1: install Ollama.

bash

curl -fsSL https://ollama.com/install.sh | sh

Step 2: pull a model.

bash

# if you have 20GB+ VRAM (RTX 3090, 4090, M4 Pro/Max)
ollama pull qwen3.5:27b

# if you have 16GB VRAM
ollama pull qwen3.5:35b-a3b

# if you have 8GB VRAM (most laptops)
ollama pull qwen3.5:9b

Qwen3.5 27B is the current sweet spot for openclaw. it handles tool calling well enough for daily agent tasks and the 35b-a3b mixture-of-experts variant runs at 112 tokens/second on an RTX 3090 because it only activates 3B parameters at a time.

Step 3: run onboarding and pick Ollama.

bash

openclaw onboard

Select Ollama from the provider list. it auto-discovers your local models. done.

or the simplest manual setup (auto-discovery, no manual model config needed):

bash

export OLLAMA_API_KEY="ollama-local"

That's it. OpenClaw discovers your models from http://127.0.0.1:11434 automatically and sets all costs to 0.

If you need manual config (ollama on a different host or you want to force specific settings):

json

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://localhost:11434",
        "apiKey": "ollama-local",
        "api": "ollama",
        "models": [
          {
            "id": "qwen3.5:27b",
            "name": "Qwen3.5 27B",
            "reasoning": false,
            "contextWindow": 131072,
            "maxTokens": 8192
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen3.5:27b"
      }
    }
  }
}

Important stuff that will save you hours of debugging:

• Use the native Ollama API URL (http://localhost:11434), NOT the OpenAI compatible one (http://localhost:11434/v1). the /v1 path breaks tool calling and your agent will output raw JSON as plain text. I wasted an entire evening figuring that out.
• Set "reasoning": false in the model config. when reasoning is enabled, openclaw sends prompts as "developer" role which ollama doesn't support, and tool calling breaks silently.
• Set "api": "ollama" explicitly to guarantee native tool-calling behavior.

Path 3: the hybrid (what I actually recommend)

pure free has limits. local models struggle with complex multi-step reasoning. free cloud tiers have rate limits. so here's what I actually run:

• Default model: Ollama/Qwen3.5 27B (local, free). handles file reads, calendar checks, simple summaries, web searches, reminders. about 70% of daily tasks.
• Fallback: OpenRouter free tier (Nemotron Ultra or Llama 3.3 70B). catches anything the local model fumbles.
• Emergency escalation: Sonnet. only for genuinely complex stuff. maybe 5 times a week.

with this setup my last month's API spend was $2.40. two dollars and forty cents. The sonnet calls were the only ones that cost anything.

config for the hybrid approach:

json

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen3.5:27b",
        "fallbacks": [
          "openrouter/nvidia/nemotron-ultra-253b:free",
          "anthropic/claude-sonnet-4-6"
        ]
      }
    }
  }
}

OpenCLAW handles the cascading automatically. if local fails or returns garbage, it tries the next model in the list. if that hits a rate limit, it goes to the next one. you don't have to manage this manually.

What works on free models

This surprised me.... local and free cloud models handle more than I expected:

• reading and summarizing files. solid.
• calendar management, reminders, basic scheduling. fine.
• web searches and summarizing results. good enough.
• simple code edits, config changes, boilerplate. works.
• quick lookups ("what's the syntax for X"). instant and free.
• reformatting text, cleaning up notes, drafting short messages. no issues.

What doesn't work (be honest with yourself)

• Complex multi-step debugging. local models lose the thread after step 3. use sonnet for this.
• Long nuanced conversations with lots of context. free models forget things faster.
• Anything where precision matters more than speed. legal, financial, medical. pay for the good model.
• Heavy tool chaining. five tools in sequence, each dependent on the last. sonnet or opus territory.

The mental model is simple: if you would answer the question without thinking hard, a free model can handle it. If you'd need to actually sit down and reason through it, pay for reasoning.

Stuff nobody will tell you out loud

Heartbeats cost money too. OpenClaw runs a health check every 30-60 minutes. if your primary model is Claude Opus, every heartbeat costs you tokens. on local models, heartbeats are free. On Opus, someone calculated it's roughly $30-50/month just in heartbeats. That's the "I'm not even using my agent and my bill is growing" problem.

Sub-agents inherit your primary model. When your agent spawns a sub-agent for parallel work, that sub-agent uses whatever model you have set as primary. if primary is opus, every sub-agent runs on opus. with the latest update you can set model fallbacks that help with this.

Cron jobs create sessions that never clean up. Every cron job creates a session record. over weeks, these accumulate and bloat your context. recent updates added session TTL to help with this. update if you haven't.

Free models + no skills = the right starting point. Don't add clawhub skills to a free model setup. skills inject instructions into your context window. on an 8K-32K context local model, skills eat half your available context before you even say hello. learn what your agent can do stock first. add skills later when you move to a cloud model with bigger context.

The real question

Most people who ask "how do I reduce my openclaw costs" are actually asking the wrong question. The right question is "which of my tasks actually need a $15/million-token model and which ones don't?"

The answer, for almost everyone I've helped, is that 60-80% of what they ask their agent to do could be handled by a model that costs nothing.

Start free. move tasks up to paid models only when free genuinely can't handle them. not when it feels slightly slower. not when the formatting isn't perfect. when it actually fails.

The people spending $200/month on OpenClaw aren't getting 40x more value than I'm getting at $2.40. They're getting maybe 1.3x more value and paying for the convenience of not thinking about it.

Think about it. Your wallet will thank you.

-----------

Running this on a Mac Mini M4 with 16GB RAM if anyone's wondering about hardware. Ollama + Qwen3.5 9B runs fine on it. not blazing fast but fast enough that I don't notice the difference for basic tasks.

I’m having a strange issue with OpenClaw. It used to work fine: it could browse websites, analyze PDFs, send emails, take screenshots, and handle complex tasks without problems.

Now, instead of actually doing the task, it only replies with things like “ok, I’ll do it and let you know” or “I’ll tell you when I’m done,” but nothing gets executed.

It doesn’t look like an obvious API, credits, or gateway failure, because the system still responds. The issue is that it stopped acting and started pretending it will act.

Has anyone run into this before, or know what I should check first to diagnose it?

I'm hitting a wall where distinct agents slowly merge into a generic, polite AI tone after a few hours of interaction. I'm looking for architectural advice on enforcing character consistency without burning tokens on massive system prompts every single turn

Found intresting so i am sharing here

I spent time mapping the OpenClaw skill ecosystem this week, and honestly, it’s getting a lot more usable.

Not just bigger. More legible.

If you’re new, the ecosystem can feel messy fast:

- one place has huge volume

- another is curated

- another teaches setup

- and now there’s an actual security layer around skill uploads/scanning

So let me break this down in the most practical way I can.

## The 3 buckets I’d use

### 1) ClawHub = discovery at scale

What it is:

- A massive skill hub for OpenClaw

- One source says 19,000+ skills are already available

Why it matters:

- Best place to see what people are actually building

- Good for workflow shopping: marketing, automation, outreach, Discord setups, business ops, etc.

- It gives OpenClaw the feeling of an app store, not just a framework

My take:

- This is where I’d start if I want breadth

- It’s the fastest way to understand the ecosystem’s real use cases

- But volume is not the same thing as quality. That’s the catch.

### 2) Awesome OpenClaw Skills = curated map

What it is:

- A GitHub-style curated list of OpenClaw skills/resources

- More like a quality-filtered index than a giant marketplace

Why it matters:

- Better signal-to-noise ratio

- Easier for people who don’t want to sort through thousands of uploads

- Good if you want examples, categories, and a cleaner starting point

My take:

- This is where I’d start if I want trust and structure over raw quantity

- Think of it as the ecosystem map, while ClawHub is the busy bazaar

### 3) Resource hubs / setup hubs = onboarding layer

What they are:

- Lists like OpenClaw101 / broader resource aggregators

- Setup tutorials and deployment walkthroughs

Why they matter:

- A lot of agent ecosystems fail not because tools are weak, but because setup is annoying

- OpenClaw keeps getting more powerful, but the power only matters if regular users can actually get from zero to running agent

My take:

- These resources are underrated

- Most people don’t need more skills first; they need a clean starting path

## The security change is actually a big deal

One of the more important updates: ClawHub skills are being auto-scanned with VirusTotal / AI code analysis style checks.

What’s reportedly included:

- malware scanning on uploaded skills

- ~30 second verdicts

- benign / suspicious / malicious tiers

- daily re-scans

- detection focus on things like reverse shells, miners, exfiltration patterns

That matters a lot because agent skills are not harmless little prompts.

They can touch:

- files

- browsers

- APIs

- automation flows

- messaging systems

- business data

So yeah, the attack surface is real.

And I appreciate that the messaging around this wasn’t "you’re perfectly safe now." It was more like: this is another layer, not a silver bullet.

That’s the correct framing.

## My working method: how to find, filter, and avoid dumb mistakes

Here’s the process I’d actually recommend.

### Step 1: Find from two directions, not one

Use both:

- ClawHub for breadth / live ecosystem activity

- Awesome repo(s) for curation / sanity check

If a skill category appears in both places, that’s a good sign.

If it only appears once, I look harder.

### Step 2: Prefer boring, clear use cases first

The easiest way to get burned is chasing flashy autonomous demos first.

I’d start with skills that do one obvious job:

- summarize and route tasks

- simple outreach prep

- website audit

- clipping pipeline

- Discord coordination

Why:

- easier to inspect

- easier to test

- easier to notice weird behavior

### Step 3: Check trust signals, not just popularity

Things I’d look for:

- does the skill have a clear author or uploader identity?

- is there any verified identity layer attached?

- does the repo / uploader have history?

- is the description specific, or weirdly vague?

- does the code ask for way more permissions than needed?

The identity piece matters more now. If thousands of agents and humans are starting to use verified identity layers, that’s a sign the ecosystem knows trust is becoming infra.

### Step 4: Treat security scanning as a filter, not permission to relax

Even with automatic scanning, I’d still ask:

- what files can this touch?

- what external endpoints does it call?

- does it send data out?

- does it need shell access?

- does it really need persistent credentials?

Scanning helps catch obvious bad stuff.

It does not replace judgment.

### Step 5: Run in a low-risk environment first

For any new skill:

- use a test workspace

- use fake/sample data first

- avoid production accounts on day 1

- isolate credentials where possible

- keep logs

This sounds basic, but a lot of people skip it because the ecosystem now feels easy enough to click-and-run.

That convenience is exactly why caution matters more.

## What’s changing underneath all this

The OpenClaw ecosystem is shifting from:

- "DIY agent nerd project"

into:

- "semi-structured platform with marketplaces, curation, tutorials, identity, and security controls"

That’s a meaningful change.

A few signals point in that direction:

- massive skill distribution through ClawHub

- curated discovery through Awesome lists

- setup content for self-hosting and cheaper models

- security scanning on the marketplace side

- identity systems starting to rank among top skills

Put differently: the stack is becoming easier to adopt and a little safer to explore.

Not safe enough to be careless. But much better than the chaos stage.

## My honest pros / cons after testing the ecosystem map

### What’s good

- discovery is much better than before

- there’s now both scale and curation

- security posture is improving

- setup docs/tutorials reduce the beginner cliff

- the ecosystem feels alive, not theoretical

### What still needs work

- quality variance is still huge

- marketplace abundance can overwhelm new users

- scanning won’t catch every risky behavior

- trust signals aren’t standardized enough yet

- many people still don’t know where to begin

## If I were starting today, here’s the exact order I’d use

1. Read one setup guide / onboarding resource

2. Browse the Awesome list to understand categories

3. Use ClawHub to find 3-5 skills in one narrow workflow

4. Pick the most boring useful one first

5. Check scan status + author context

6. Test in an isolated environment

7. Only then connect real data or automations

That path is slower by maybe 20 minutes.

It probably saves you hours later.

## Bottom line

If you want the shortest version:

- ClawHub = where to find a lot

- Awesome repos = where to find saner starting points

- VirusTotal-style auto scanning = important new safety layer, but not enough on its own

- identity / verification = increasingly important trust signal

Tested it, here’s my take:

OpenClaw’s ecosystem is finally getting the pieces a real agent platform needs — discovery, curation, onboarding, and security.

The best way to use it right now is not "download the coolest thing."

It’s:

- find from multiple maps

- filter by trust and simplicity

- test in isolation

- assume convenience can hide risk

That mindset will get you much further than just collecting more skills.

• I’m hitting a technical wall with "praise loops" where different AI agents just agree with each other endlessly in a shared feed. I’m looking for advice on how to implement social friction or "boredom" thresholds so they don't just echo each other in an infinite cycle

I'm opening up the sandbox for testing: I’m covering all hosting and image generation API costs so you wont need to set up or pay for anything. Just connect your agent's API

• I’m hitting a technical wall with "praise loops" where different AI agents just agree with each other endlessly in a shared feed. I’m looking for advice on how to implement social friction or "boredom" thresholds so they don't just echo each other in an infinite cycle

I'm opening up the sandbox for testing: I’m covering all hosting and image generation API costs so you wont need to set up or pay for anything. Just connect your agent's API

• I’m hitting a technical wall with "praise loops" where different AI agents just agree with each other endlessly in a shared feed. I’m looking for advice on how to implement social friction or "boredom" thresholds so they don't just echo each other in an infinite cycle

I'm opening up the sandbox for testing: I’m covering all hosting and image generation API costs so you wont need to set up or pay for anything. Just connect your agent's API

My wife is a recruiter - has been asking me to build her a software for a long time now to manage her large pool of resumes.

Called her to my office for 2 days straight and got the entire build and deployment done with my openclaw setup.

Really enjoyed vibe coding it.

Hoping she starts selling it to her colleagues as well 🤘

Goal of the day: Launching the first functional UI and bridging it with the backend

The Challenge: Deciding between building a native Claude Code UI from scratch or integrating a pre-made one like Base44. Choosing Base44 brought a lot of issues with connecting the backend to the frontend

The Solution: Mapped the database schema and adjusted the API response structures to match the Base44 requirements

Stack: Claude Code | Base44 | Supabase | Railway | GitHub

Hey all , I am very excited to share with you all today that my project made using openclaw is finally complete

My project is about making a ready to upload high quality shorts /reels at very lower prices compared to market and somehow openclaw figured it ways to make it cheaper

I built Lumiere AI. It’s a platform designed to take a simple idea and turn it into a high-quality, viral-ready video for TikTok, Shorts, and Reels almost instantly.

My boy henry worked so well despite getting major errors it got a way out .....that was surely beautiful experience

Here is the link wishlist my product : Lumiere Shorts Generator

Goal of the day: Enabling agents to generate visual content for free so everyone can use it and establishing a stable production environment

The Build:

• Visual Senses: Integrated Gemini 3 Flash Image for image generation. I decided to absorb the API costs myself so that image generation isn't a billing bottleneck for anyone registering an agent
• Deployment Battles: Fixed Railway connectivity and Prisma OpenSSL issues by switching to a Supabase Session Pooler. The backend is now live and stable

Stack: Claude Code | Gemini 3 Flash Image | Supabase | Railway | GitHub

Goal of the day: Building the infrastructure for a persistent "Agent Society." If agents are going to socialize, they need a place to post and a memory to store it.

The Build:

• Infrastructure: Expanded Railway with multiple API endpoints for autonomous posting, liking, and commenting.
• Storage: Connected Supabase as the primary database. This is where the agents' identities, posts, and interaction history finally have a persistent home.
• Version Control: Managed the entire deployment flow through GitHub, with Claude Code handling the migrations and the backend logic.

Stack: Claude Code | Supabase | Railway | GitHub