15 Real OpenClaw Use Cases (With Config Examples)

It’s 11:00 PM on a Thursday. Your phone buzzes — a Telegram message from an agent you set up last weekend. Your competitor just shipped a feature. Price of a stock you hold dropped 3.2%. And your morning briefing is already queued for 7:30 AM. You didn’t open a single dashboard. OpenClaw is an open-source AI agent framework that connects any LLM to messaging apps, tools, memory systems, and automation pipelines. It runs on your hardware. These 15 OpenClaw use cases all have real config snippets — not vague theory.

What can you actually do with OpenClaw?

OpenClaw connects an LLM to the tools you already use — Telegram, WhatsApp, Discord, your file system, APIs, smart home systems. The agent runs on a heartbeat (a cron schedule), responds to your messages, and can coordinate with other agents. These 15 use cases go from easiest-to-deploy to most complex. Start from the top if you’re new. Skip ahead if you’ve already got an agent running.

Beginner tier — no coding required

These five use cases work with a heartbeat and a task prompt. No MCP servers, no custom skills, no multi-agent setup.

Use case 1 — How do you set up a daily briefing with OpenClaw?

The Scenario: It’s 7:45 AM. You haven’t unlocked your phone yet. Telegram buzzes. Weather: 29°C, no rain. Calendar: two meetings, links included. GitHub: no fires overnight. Tasks: one overdue. That’s your entire morning briefing in one message. Your agent compiled it while you slept.

A daily briefing is the easiest OpenClaw use case to deploy. One heartbeat, a handful of API calls, one Telegram message. Zero decision-making required from you until it arrives.

How does the briefing heartbeat work?

A heartbeat is a scheduled task — think cron, but written in plain language. You tell the agent what to pull, when, and how to format it.

# Agent: briefing
heartbeat:
  enabled: true
  schedule: "30 7 * * *"   # fires at 7:30 AM every day
  task: |
    1. Get today's weather for Mumbai using the OpenWeatherMap API.
    2. List all calendar events for today from Google Calendar.
    3. Check open GitHub issues assigned to me.
    4. Read my task list from memory/tasks.md. Flag any overdue items.
    5. Send a single Telegram message with all of the above. Use bullet points. Keep it under 150 words.

What data sources can the briefing pull?

| Data source | Skill / MCP | What it pulls | |---|---|---| | Weather | http_request → OpenWeatherMap | Temp, rain chance, UV index | | Calendar | google-calendar ClawHub skill | Events, meeting links | | GitHub | GitHub MCP server | PRs, issues, CI status | | Tasks | file_read on memory/tasks.md | Your own Markdown task list | | News | rss-reader ClawHub skill | Top headlines by topic |

Start with weather and tasks. Add more sources once the basic briefing is working.

Use case 2 — Can OpenClaw track your personal health and habits?

The Scenario: It’s 9:00 PM. Your agent messages you: “Did you hit 8,000 steps today? Log your water intake.” You reply “7,200 steps, 2L water, slept 7 hours last night.” The agent says “Logged. You’re 3 for 5 on step goals this week.” No app. No subscription. Just a Telegram conversation with your own agent.

Most habit trackers require you to open an app, tap through menus, and remember to log. OpenClaw turns the log into a conversation — the agent asks, you reply, it stores and trends.

How does the habit logging work?

The agent sends an evening check-in via heartbeat. You reply in plain text. It writes your log to a Markdown file and computes weekly trends on Sundays.

# Agent: health-tracker
heartbeat:
  enabled: true
  schedule: "0 21 * * *"   # 9 PM daily check-in
  task: |
    Send a short check-in message asking the user to log:
    - Steps today
    - Water intake (litres)
    - Sleep last night (hours)
    - Optional: mood (1-5)
    Wait for their reply. Parse the numbers. Store them in memory/health-log.md
    with today's date. If it's Sunday, compute a 7-day average for each metric
    and send a weekly summary.

What’s worth tracking?

Keep it to three metrics max when starting. More than that and you’ll stop replying within a week.

• Steps (pull from Google Fit MCP if you want it automatic)
• Water intake (manual reply — takes 5 seconds)
• Sleep hours (or use an Apple Health / Fitbit integration)

Use case 3 — Can OpenClaw work as a personal memory or second-brain system?

The Scenario: Six months ago you read a paper on transformer attention mechanisms and took notes. You can’t find the file. You can’t remember what you named it. You message your agent: “What do I know about attention scaling?” It searches your memory folder, finds the note, quotes the relevant section, and replies in ten seconds. No search app. No tagging system.

This is where OpenClaw stops feeling like a chatbot and starts feeling like a second brain. The difference from Notion or Obsidian is that the agent pre-loads your memory files at startup and can answer questions from them in conversation — no search UI needed.

How is memory structured in OpenClaw?

Memory lives in a plain folder of Markdown files. You write them directly, or let the agent write them for you.

~/.openclaw/agents/secondbrain/memory/
  ├── preferences.md        — your stated preferences and working style
  ├── projects/
  │   ├── client-a.md
  │   └── side-project-x.md
  ├── reading-notes/
  │   ├── 2026-01-transformer-paper.md
  │   └── 2026-03-attention-scaling.md
  └── contacts.md           — people, roles, context

How does OpenClaw compare to dedicated tools?

| Feature | Notion | Obsidian | OpenClaw memory | |---|---|---|---| | Natural language query | AI add-on ($) | Plugins required | Native via LLM | | Data location | Notion servers | Local | Local | | Integrates with agent | No | No | Yes, by design | | Cost | $8–16/month | Free (sync costs extra) | Free | | Pre-loads context automatically | No | No | Yes |

The internal link to the full memory system breakdown: see how OpenClaw memory works and stays private.

Use case 4 — How do you monitor social media mentions with OpenClaw?

The Scenario: Someone posts a thread on Reddit trashing your product at 3 AM. By 9 AM it has 200 upvotes. You find out two days later when a journalist emails you for comment. With an OpenClaw monitoring agent, you’d have gotten the Telegram alert at 3:12 AM. Not ideal timing — but you’d have had two days to respond instead of zero.

Social media monitoring usually costs $99/month and up. OpenClaw does it with a heartbeat and a search API key, and the results go straight to Telegram.

What does the monitor agent look like?

# Agent: social-monitor
heartbeat:
  enabled: true
  schedule: "0 */4 * * *"   # every 4 hours
  task: |
    Search for the following keywords across Reddit, Twitter/X, and Hacker News:
    - "YourBrandName"
    - "YourCompetitorName"
    - "your-product-slug"
    For any result published in the last 4 hours with more than 10 upvotes or likes,
    send a Telegram alert with the post title, link, platform, and engagement count.
    Ignore results already seen (check memory/seen-posts.md before alerting).

skills:
  permissions:
    social-monitor:
      - http_request
      - memory_read
      - memory_store

What keywords are worth monitoring?

| Type | Examples | |---|---| | Brand name | “YourCompany”, “YourProduct” | | Competitor names | Direct competitors + their product slugs | | Industry terms | Problem your product solves (“slow CI builds”) | | Personal brand | Your name, your handle |

Use case 5 — How do you automate home and IoT control with OpenClaw?

The Scenario: It’s 11 PM. You’re already in bed. You forgot to lock the front door and turn off the kitchen light. You message your Telegram agent: “Lock front door and turn off kitchen light.” Two seconds later: “Done.” You don’t move.

This isn’t sci-fi — it’s a Home Assistant MCP server connected to OpenClaw. The agent translates natural language into REST API calls.

How does the Home Assistant MCP connection work?

mcp:
  servers:
    - name: home-assistant
      command: "npx"
      args: ["-y", "@voiceflow/mcp-server-home-assistant"]
      env:
        HA_URL: "http://homeassistant.local:8123"
        HA_TOKEN: "${HA_TOKEN}"

Once connected, you can send commands in plain English. The agent maps them to the right entity IDs automatically.

What devices work with this setup?

| Integration | How it connects | What you can control | |---|---|---| | Home Assistant | MCP server (above) | Lights, locks, thermostats, sensors | | IFTTT | http_request webhook | Any IFTTT-connected device | | Tuya smart plugs | HTTP API via http_request | On/off, scheduling | | Generic HTTP devices | http_request skill | Anything with a REST API |

Intermediate tier — some config needed, high payoff

These five require MCP servers or more involved task prompts, but the payoff is significantly higher.

Use case 6 — How do you build a research pipeline with OpenClaw?

The Scenario: You’re writing a comparison of AI agent frameworks. Normally: two hours of tabs, lost bookmarks, half-read docs. Instead, you message the agent: “Research the top 5 open-source agent frameworks. Compare memory handling and tool integration. Save to my research folder.” You go for a walk. You come back to five structured Markdown files with summaries, comparisons, and source URLs.

Research pipelines are where OpenClaw saves the most time. The bottleneck in research isn’t thinking — it’s the mechanical work of reading, extracting, and organizing.

How do you wire search, summarization, and filing together?

mcp:
  servers:
    - name: brave-search
      command: "npx"
      args: ["-y", "@anthropic/mcp-server-brave-search"]
      env:
        BRAVE_API_KEY: "${BRAVE_API_KEY}"
    - name: filesystem
      command: "npx"
      args: ["-y", "@anthropic/mcp-server-filesystem", "/home/user/research"]

skills:
  permissions:
    research-filer:
      - file_write
      - http_request
      - memory_store

For the full MCP server setup, see the OpenClaw skills and MCP guide.

How does the pipeline run, step by step?

1. You send the research question via Telegram
2. Brave Search MCP fetches the top 10 results
3. Agent reads each URL and summarizes in ~200 words
4. Summaries are compared and structured into a table
5. Final Markdown file saved to ~/research/[topic]-[date].md
6. Agent sends a Telegram message with the file path and a 3-bullet executive summary

Use case 7 — How do developers use OpenClaw in their coding workflow?

The Scenario: It’s 9:00 AM. You’re commuting. You open Telegram. Your agent already pulled the overnight CI results, summarized the three failing tests, and drafted the likely fix for each one. By the time you sit down at your laptop, triage is done. You didn’t touch GitHub Notifications, you didn’t open Slack, you didn’t context-switch once.

Most dev tools push notifications. OpenClaw digests them. There’s a real difference — a notification is noise, a digest is signal.

What does a dev workflow agent look like?

# Agent: dev-triage
heartbeat:
  enabled: true
  schedule: "0 8 * * 1-5"   # weekdays at 8 AM
  task: |
    Check CI status on the main branch of [repo-name].
    Summarize any failing tests. For each failure, identify the likely cause
    and suggest a fix in under 50 words. Also list any PRs waiting for my review.
    Send the full report to Telegram.

mcp:
  servers:
    - name: github
      command: "npx"
      args: ["-y", "@anthropic/mcp-server-github"]
      env:
        GITHUB_TOKEN: "${GITHUB_TOKEN}"

What can the dev agent handle?

• Morning CI summary with suggested fixes per failing test
• PR diff summaries before code review sessions
• npm audit alerts when new vulnerabilities appear
• Deploy confirmation via Telegram — reply “ship it” to trigger

Use case 8 — Can OpenClaw run a finance or trading bot?

The Scenario: You hold a position in three ETFs. You’re cooking dinner when the alert arrives: “NIFTY50 down 3.4% from yesterday’s close. Current: 21,840.” You didn’t check a dashboard. You didn’t have Bloomberg open. Your agent checked every 15 minutes and messaged you the second it crossed your threshold.

Finance bots are one of the most-requested OpenClaw use cases. The setup is simpler than it sounds — a heartbeat, a free market data API, and a Telegram integration you probably already have.

How do you configure a price alert?

# Agent: market-watcher
heartbeat:
  enabled: true
  schedule: "*/15 * * * *"   # every 15 minutes during market hours
  task: |
    Check current prices for: NIFTY50, BTC-USD, GOLD.
    Compare each to yesterday's closing price.
    If any are down more than 3% or up more than 5%, send a Telegram alert
    with the ticker, current price, percentage change, and a one-sentence summary
    of why it might be moving (check recent news if needed).

skills:
  permissions:
    market-watcher:
      - http_request
      - memory_store

How does OpenClaw compare to other alert tools?

| Approach | Setup time | Monthly cost | Alert latency | |---|---|---|---| | Bloomberg Terminal | Days | ~$2,200/mo | Real-time | | Custom Python script | Hours | Hosting fees | Depends on cron | | TradingView alerts | Minutes | $15–60/mo | 15 min (free tier) | | OpenClaw finance bot | 30 minutes | API key only | Configurable |

Use case 9 — How do you build a team knowledge base with OpenClaw?

The Scenario: Your new teammate asks “What’s our deploy process?” It’s in a doc somewhere. Maybe Notion. Maybe Confluence. Maybe a pinned Slack message from eight months ago. With a team OpenClaw agent, they message the bot and get the answer in ten seconds — pulled from your shared memory/team/ folder.

A shared memory folder plus a multi-user agent is the simplest team knowledge base you can build. No new SaaS, no migration, no training time.

How do you set up a shared memory layer?

# Agent: team-kb
gateway:
  allowedUsers:
    - telegram_id_teammate_1
    - telegram_id_teammate_2
    - telegram_id_you

memory:
  path: "/shared/team-kb/memory"
  readOnly: true   # teammates can query, only you can write

The shared memory folder holds your real documentation — deploy runbooks, onboarding docs, architecture decisions, FAQ answers. The agent reads it at startup and answers questions from it.

How does a team KB compare to existing tools?

| Feature | Confluence | Notion | OpenClaw team KB | |---|---|---|---| | Natural language query | No | AI add-on ($) | Yes, native | | Cost per seat | $5–10/mo | $8–16/mo | Free | | Setup time | Days | Hours | 30 minutes | | Works in Telegram | No | No | Yes | | Auto-updates from docs | No | No | On agent restart |

Use case 10 — Can OpenClaw automate business operations?

The Scenario: A lead fills out your contact form at 2:00 AM. Your OpenClaw agent reads the submission, looks up the company via search, scores the lead by company size and role, and sends a personalized intro email referencing their specific industry. By the time your sales rep wakes up, the lead is already pre-qualified and replied. The rep walks in warm.

This is where OpenClaw earns its place in a real business. Not because it’s clever — because it removes the parts of the job that drain time without adding judgment.

What business workflows fit OpenClaw?

| Business task | OpenClaw approach | Skills needed | |---|---|---| | Lead qualification | Read form → score → personalized reply | http_request, memory_store | | Invoice follow-up | Heartbeat checks unpaid → sends reminder | schedule, email ClawHub skill | | Competitor monitoring | Daily scan of competitor changelog/blog | web_search, file_write | | Weekly report | Pull sales data → format → send | http_request, file_write | | Onboarding emails | New user trigger → 5-day drip sequence | schedule, memory_store |

How does the lead pipeline run?

1. Webhook fires when form is submitted
2. Agent extracts name, company, role from the JSON payload
3. Brave Search looks up the company’s website and LinkedIn
4. Agent scores the lead: enterprise = high, solo developer = low
5. High-value leads get a personalized email drafted and sent
6. Low-value leads saved to memory/leads-cold.md for weekly review
7. All leads logged to memory/leads-log.md with timestamp and score

Advanced tier — multi-agent, pipelines, production setups

These five use cases require multi-agent coordination or production-level configuration. They’re powerful — and they need more care to set up safely.

Use case 11 — How do you run multi-agent systems with OpenClaw?

The Scenario: You run a content operation. Your researcher agent scans Hacker News at midnight and drops a briefing file. Your writer agent picks it up at 1 AM and drafts three articles from it. Your editor agent runs at 3 AM, checks each draft against a rules file, and flags any section under 200 words. By 7 AM you have three polished drafts waiting. You slept through all of it.

One agent is a tool. Multiple agents that hand work to each other is a system. That shift is where OpenClaw becomes a real productivity lever.

How do agents coordinate in OpenClaw?

Two main patterns: shared folders and ACP (Agent Communication Protocol).

# Manager agent — coordinates the pipeline
heartbeat:
  enabled: true
  schedule: "0 6 * * *"   # 6 AM daily check
  task: |
    Check ~/shared/pipeline/drafts/ for new files from the writer agent.
    For each draft, send an ACP message to editor_agent asking for a review.
    Wait for the response. If approved, move the file to ~/shared/pipeline/ready/.
    If rejected, move to ~/shared/pipeline/revisions/ with the editor's notes.

- action: acp_send
  target: editor_agent
  message: "Review this draft: ${draft_path}"
  await_response: true
  timeout: 300

Which coordination mode should you use?

| Mode | Mechanism | Best for | |---|---|---| | Shared folder | File read/write in ~/.openclaw/shared/ | Async, scheduled pipelines | | ACP direct message | acp_send with await_response: true | Real-time agent-to-agent tasks | | Fleet dashboard | openclaw fleet start | Monitoring all agents at once |

For a full walkthrough, see the OpenClaw multi-agent guide.

Use case 12 — How do you use OpenClaw for remote coding and dev workflows?

The Scenario: You’re on a train. A critical test suite is failing on a branch you pushed this morning. You message your agent: “Run the failing tests on feature/auth-refactor and tail the last 50 lines of the log.” Two minutes later the output is in Telegram. You diagnose the issue. You message: “Apply the fix in auth.ts line 84.” The agent does it. You commit without opening a laptop.

This is phone-as-a-control-layer. Not a gimmick — a real shift in how much of your dev work requires you to be physically at a desk.

What’s safe to delegate remotely?

mcp:
  servers:
    - name: shell
      command: "npx"
      args: ["-y", "@anthropic/mcp-server-shell"]
      env:
        ALLOWED_COMMANDS: "npm test, git status, git log, tail, cat, ls, jest"

| Safe to delegate | Dangerous — don’t | |---|---| | Run test suite | rm -rf anything | | Tail application logs | Production database writes | | Check git status/log | Force push to main | | Restart a dev server | Deploy to production | | Read a file | Modify environment variables |

Use case 13 — How do you build a content operations pipeline with OpenClaw?

The Scenario: It’s Monday morning. You have five article drafts in a folder. Your editor agent ran overnight and left an audit file next to each one: forbidden words found, sections under 200 words flagged, missing CTAs marked. You open your laptop and go straight to fixing, not reading.

If you publish content regularly — blog posts, newsletters, docs — an editorial agent saves hours per week. It applies the same rules every time, doesn’t miss things when it’s tired, and works overnight.

How do you wire the editorial pipeline?

# Agent: content-editor
heartbeat:
  enabled: true
  schedule: "0 3 * * 1"   # 3 AM every Monday
  task: |
    Read all .md and .mdx files in ~/drafts/ that were modified in the last 7 days.
    For each file, apply these rules from memory/style-rules.md:
    - Flag any forbidden words found in memory/forbidden-words.json
    - Flag any H2 section under 200 words
    - Flag any article without a FAQ section
    - Flag any article without a "What to read next" section
    Write an audit file next to each draft: [filename]-audit.md
    Send a Telegram summary: X drafts reviewed, Y issues found.

mcp:
  servers:
    - name: filesystem
      command: "npx"
      args: ["-y", "@anthropic/mcp-server-filesystem", "/home/user/drafts"]

Step-by-step pipeline flow

1. Agent reads all recently modified drafts at 3 AM Monday
2. Loads memory/style-rules.md and memory/forbidden-words.json
3. Checks each draft against every rule
4. Writes [filename]-audit.md with flagged issues and line references
5. Sends Telegram summary: drafts reviewed, issue count, files to fix

Use case 14 — How do you set up OpenClaw for customer support automation?

The Scenario: You wake up to 47 support emails. Normally that’s two hours of your morning. Your OpenClaw agent has already drafted replies for 38 of them — pulled from your FAQ knowledge base, matched to the question, and formatted in your voice. The other 9 are flagged for human review with a one-line reason. You spend 25 minutes instead of two hours.

Customer support automation with OpenClaw works best in draft mode — the agent writes the replies, you review and send. This is different from fully automated responses, which require much more guardrailing.

How does the support agent work?

# Agent: support-drafter
gateway:
  webhooks:
    - event: new_email
      source: gmail
      trigger: "New email in support@yourcompany.com inbox"

task: |
  Read the new support email. Check memory/faq.md for a matching answer.
  If a clear match exists (confidence > 0.8), draft a reply using the FAQ answer.
  Format it in a friendly, professional tone. Save to drafts/support-reply-[id].md.
  If no match or low confidence, flag for human review with a one-line reason.
  Send a Telegram notification either way.

mcp:
  servers:
    - name: gmail
      command: "npx"
      args: ["-y", "@anthropic/mcp-server-gmail"]

How do you triage ticket categories?

| Ticket type | Agent action | Why | |---|---|---| | FAQ match (high confidence) | Draft reply | Fastest path to resolution | | FAQ match (low confidence) | Draft + flag for review | Reduces hallucination risk | | Billing/refund | Flag for human | Too high-stakes for automation | | Bug report | Log to memory/bugs.md + flag | Needs developer triage | | Feature request | Log to memory/feature-requests.md | Capture the signal, no reply needed |

Use case 15 — How do you build a self-improving agent with OpenClaw?

The Scenario: You ask your agent something. It gets it wrong. You reply: “That’s incorrect — here’s the right answer.” The agent says “Got it, I’ve saved a correction.” Next time you ask the same thing, it answers correctly. Not because it was retrained. Because it wrote the correction to its own memory file and reads it at startup.

This is the most advanced OpenClaw use case — and the most misunderstood. The agent isn’t actually “learning” in the ML sense. It’s writing corrections to a Markdown file that it reads at startup. That’s it. But the effect is the same: it gets better at your specific questions over time.

How does the feedback loop work?

# Agent: adaptive-assistant
task: |
  When the user gives feedback like "that's wrong", "incorrect", or "actually":
  1. Ask them to confirm the correct answer.
  2. Write a correction entry to memory/corrections.md in this format:
     - Date: [today]
     - Question type: [category]
     - Wrong answer: [what you said]
     - Correct answer: [what the user provided]
  3. Confirm: "Saved. I'll use this going forward."
  At startup, always read memory/corrections.md before answering any question.

The correction feedback loop, step by step

1. You rate the agent’s response as wrong (explicit feedback or “that’s incorrect”)
2. Agent asks you to confirm the right answer
3. Correction written to memory/corrections.md with date, category, and both answers
4. Agent confirms it saved the correction
5. Next session, agent reads corrections.md at startup
6. Same question → correct answer this time

Frequently asked questions about OpenClaw use cases

What’s the easiest OpenClaw use case to start with?

Daily briefings. One agent, one heartbeat, three API calls. No MCP servers, no multi-agent coordination, no custom skills. Set it up in under 30 minutes using the heartbeat config in use case 1 and the Google Calendar ClawHub skill. You’ll get a working result the same morning.

Does OpenClaw work without a paid LLM API?

Yes. Point the llm.provider config to ollama and specify a local model like llama3 or mistral. Local models are slower and less capable for complex reasoning (research pipelines, multi-agent coordination), but free and fully offline. For simple use cases like daily briefings and habit tracking, a local model works fine. See the Gemma 4 + OpenClaw local setup guide for a step-by-step walkthrough.

Can OpenClaw replace tools like Zapier or Make?

For tasks that involve LLM reasoning as part of the automation — yes, often. Zapier and Make are better at deterministic, structured data routing (if X then Y). OpenClaw is better when the agent needs to read, understand, and generate content as part of the workflow. The two aren’t mutually exclusive — you can trigger an OpenClaw agent via a Zapier webhook and have it handle the reasoning-heavy part.

How many use cases can one OpenClaw agent handle?

5–8 distinct use cases before skill instruction bloat starts degrading response quality. If you need more, split into specialized agents and coordinate them. A briefing agent, a research agent, and a business ops agent — each doing 3–4 things well — outperforms a single agent trying to do everything. The fleet dashboard (openclaw fleet start) lets you run and monitor all of them at once.

Is it safe to give OpenClaw access to my email or file system?

With the right configuration, yes. The key controls: set allowedUsers to only your own account, use readOnly: true for memory folders teammates can access, and use explicit ALLOWED_COMMANDS allowlists for shell access. Never grant shell_exec: unrestricted or broad file system write access without thinking through the blast radius. Start with the minimum permissions needed and expand only when you have a specific reason.

What to read next

• Build your first OpenClaw agent in 15 minutes — the right starting point if any of these use cases inspired you and you don’t have an agent running yet
• OpenClaw multi-agent setup: make your agents talk to each other — goes deep on the ACP coordination patterns from use case 11
• How OpenClaw memory works and stays local — full breakdown of the memory system referenced in use cases 3, 9, and 15

Related Articles

Deepen your understanding with these curated continuations.

View All Articles

OpenClaw 5 min read

How to Set Up OpenClaw with WhatsApp

Connect OpenClaw to WhatsApp using a linked web session. Full walkthrough: QR code pairing, group chat filtering, media handling, and session recovery.

Darsh Jariwala Apr 07, 2026

OpenClaw 5 min read

How to Add and Build Skills in OpenClaw

Install community skills from ClawHub, connect MCP tools, and write custom skills from scratch. The complete guide to extending what your OpenClaw agent can do.

Darsh Jariwala Apr 06, 2026

OpenClaw 5 min read

Run Gemma 4 Locally with OpenClaw

Use OpenClaw with Gemma 4 26B as a local backend via Ollama — no API keys, no cloud, full privacy. Works on macOS, Linux, and Windows.

Darsh Jariwala Apr 10, 2026