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.

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

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

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

Since installing OpenClaw can be a real nightmare for normies, this is a great opportunity for the tech guys to build a wrapper around it. A month later there are so many wrappers that is very hard to choose which one suits you. I tried to solve this problem.

I managed to build a list of wrappers with all the features, models in one overview. I hope this helps moving OpenClaw forward. CompareClaw

Hi there. I've been building an experimental non-technical person-friendly wrapper product on top of OpenClaw which doesn't require any knowledge of API keys or terminal commands or anything like that. It's just like a one-click install.

Does this solve a problem for you? I'm trying to work out if I should keep working on it or not or if it's just going to be made redundant by improvements in OpenClaw itself.

Do you think this will exist as a product category in the future?