#4789 OpenClaw
#4789 OpenClaw
#4789 Tell me about OpenClaw
OpenClaw primarily refers to the viral, open-source autonomous personal AI agent platform, though the name also belongs to an older retro gaming engine recreation.
1. OpenClaw (The Autonomous AI Agent Runtime)
Created by developer Peter Steinberger (founder of PSPDFKit) and originally launched in late 2025 as Clawdbot (briefly Moltbot before renaming in early 2026), OpenClaw is one of the fastest-growing open-source AI projects.
Unlike standard chatbots that wait for user prompts inside a browser tab, OpenClaw operates as a persistent, self-hosted agent runtime designed to bridge large language models with native system execution.
Core Architecture & How It Works
Omnichannel Messaging Gateway: Instead of a dedicated UI, OpenClaw runs as a background service (e.g., daemon/systemd/LaunchAgent) that users message via everyday apps—such as WhatsApp, Telegram, Discord, Slack, Signal, and iMessage.
Model Agnostic: Users supply their own API keys or endpoints.
It connects to commercial providers (Anthropic Claude, OpenAI GPT, Google Gemini) as well as local inference engines (via Ollama, LM Studio, or vLLM). Local-First & Transparent State: Long-term memory, session state, and configurations are stored directly on the host machine as human-readable Markdown and YAML files (in
~/.openclaw/) rather than an opaque cloud database, making it easy to audit, version-control with Git, or grep.Tool Execution & Sandboxing: The agent can run arbitrary shell commands, read and write local files, control headless browser automation (Playwright/Puppeteer), and trigger REST APIs.
It supports strict tool policies—such as requiring manual user approval before running destructive commands or sending emails. Proactive "Heartbeat" Loops: Rather than being purely reactive, OpenClaw features scheduled background heartbeats (e.g., every 30–60 minutes) and cron triggers.
It can read a local HEARTBEAT.mdchecklist, check repositories, monitor feeds, and ping the user only when an issue demands attention.Extensible Skills System: Capabilities are modularized into "Skills" containing a
SKILL.mdfile describing schemas, prompts, and CLI bindings.Community extensions have since expanded it from software DevOps and web scrapers to hardware integrations like ROS (Robot Operating System).
2. OpenClaw (Retro Game Engine)
In retro computing and gaming contexts, OpenClaw is an open-source C++ engine reimplementation of Captain Claw, Monolith Productions' cult-classic 1997 side-scrolling platformer.
Is OpenClaw well-suited for RTX 5090 with 32 GB VRAM?
An RTX 5090 with 32 GB of GDDR7 VRAM is arguably the premier single-consumer GPU configuration for running OpenClaw locally.
OpenClaw itself is a lightweight Node.js gateway that uses negligible system resources (roughly 300–500 MB RAM). The compute and memory bottleneck in local setups comes almost entirely from two factors: the LLM runtime and the agent’s expanding context window/tool calling. The RTX 5090 addresses both effectively.
1. Solving the Context Window & KV Cache Bottleneck
In autonomous agent loops, OpenClaw continuously appends system prompts, skill schemas, tool execution outputs, and conversational turns to the context window.
On typical 24 GB cards (RTX 3090/4090), loading a high-capability 30B–35B model at 4-bit/5-bit quantization leaves very little VRAM for the KV cache, often limiting context to 8k–16k tokens before spilling to system RAM and stalling inference.
With 32 GB VRAM, you have ample headroom to hold mid-sized model weights while maintaining deep context windows (32k to 64k+ tokens) entirely in GPU memory.
2. High Memory Bandwidth for Agent Responsiveness
The RTX 5090 delivers approximately 1,792 GB/s of memory bandwidth.
3. Model Recommendations for OpenClaw on 32 GB
| Model Architecture | Quantization | Approximate VRAM Usage | Notes for OpenClaw Loops |
| Gemma 4 31B / Qwen 27B–32B | Q6_K / Q8_0 | ~24 GB – 28 GB | Near-lossless precision for dense models with enough VRAM left over for a large KV cache. |
| MoE Models (e.g., 30B–35B total, ~3B active) | Q6_K / Q8_0 | ~22 GB – 28 GB | High generation speeds (75–110+ tok/sec); suitable for low-latency background heartbeats. |
| Llama 3.3 70B / Mistral 70B-class | Q3_K_M / Q4_K_M | ~20 GB – 26 GB | Fits entirely on a single consumer card. Delivers frontier-level tool reasoning, though generation speed drops to ~15–25 tok/sec. |
Considerations & Practical Limits
JSON / Function-Calling Reliability: Local agents depend entirely on the model returning valid tool syntax. Ensure the local model you pair with Ollama/vLLM supports structured outputs or function calling reliably to prevent OpenClaw parser retries.
System Power & Thermal Management: If you run OpenClaw 24/7 with active background heartbeats, the RTX 5090 carries a 575W TDP rating under full load. When idle, modern cards scale down to low wattage, but continuous autonomous scraping or reasoning runs will generate substantial heat and require a capable power supply (1000W–1200W recommended).
How do I configure OpenClaw to route through a local Ollama or vLLM server on an NVIDIA GPU?
To route OpenClaw through a local GPU-accelerated engine, you can connect directly to Ollama via its native integration or vLLM via its OpenAI-compatible endpoint.
Option 1: Routing via Local Ollama
Ollama is the fastest route to get running locally. OpenClaw natively discovers Ollama models when pointed at the loopback interface.
1. Launch Ollama with Sufficient Context
By default, Ollama initializes with a narrow 2,048-token context window.
# Example: Running Qwen 2.5 Coder 32B or Mistral on your NVIDIA GPU
ollama run qwen2.5-coder:32b --keepalive -1
To permanently ensure high context for agent loops, create a custom Modelfile:
FROM qwen2.5-coder:32b
PARAMETER num_ctx 65536ollama create qwen-agent -f ./Modelfile
2. Configure OpenClaw for Ollama
Set the local discovery variable in your gateway environment (or in ~/.openclaw/.env):
export OLLAMA_API_KEY="ollama-local"
(OpenClaw checks for this flag to initiate discovery on [http://127.0.0.1:11434](http://127.0.0.1:11434)).
Then update ~/.openclaw/openclaw.json (or use the interactive CLI via openclaw configure):
{
agents: {
defaults: {
model: {
primary: "ollama/qwen-agent"
}
}
}
}
Note on Tool Calling: Point OpenClaw to Ollama's native endpoint (
[http://127.0.0.1:11434](http://127.0.0.1:11434)), not Ollama’s/v1compatibility route. Using the/v1path in Ollama can cause structured tool execution outputs to escape as raw JSON text.
Option 2: Routing via Local vLLM (Recommended for Maximum Throughput)
vLLM provides paged attention and continuous batching, making it significantly faster for long-context agent iteration on high-end NVIDIA hardware.
1. Launch the vLLM OpenAI-Compatible Server
Start vLLM with tool-calling parsers enabled. For function-calling models, specify --enable-auto-tool-choice and --tool-call-parser:
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct \
--port 8000 \
--max-model-len 65536 \
--gpu-memory-utilization 0.92 \
--enable-auto-tool-choice \
--tool-call-parser hermes
2. Register vLLM in openclaw.json
Open ~/.openclaw/openclaw.json and declare vLLM under models.providers, then add it to the model allowlist:
{
models: {
mode: "merge",
providers: {
vllm: {
baseUrl: "http://127.0.0.1:8000/v1",
apiKey: "none",
api: "openai-completions",
models: [
{
id: "Qwen/Qwen2.5-Coder-32B-Instruct",
name: "Local vLLM Qwen 32B",
contextWindow: 65536,
maxTokens: 8192
}
]
}
}
},
agents: {
defaults: {
model: {
primary: "vllm/Qwen/Qwen2.5-Coder-32B-Instruct"
},
models: {
"vllm/Qwen/Qwen2.5-Coder-32B-Instruct": {
alias: "local-coder"
}
}
}
}
}
3. Apply Config and Verify Connection
Apply the configuration and restart the gateway:
openclaw gateway config.apply --file ~/.openclaw/openclaw.json
Verify that OpenClaw sees the local model and resolves the route properly:
openclaw models list
openclaw models status
To verify inference is working on your GPU, send a test turn in your linked chat channel (e.g., Telegram, Discord) or run:
openclaw agent --message "Run a bash check: check nvidia-smi memory usage"
Check nvidia-smi in another terminal; you should see active VRAM allocation and compute utilization spike during the run.
List a describe the various type of applications of OpenClaw
OpenClaw’s core strength lies in combining an omnichannel messaging front-end (Telegram, WhatsApp, Discord, Slack) with a native local execution runtime (shell execution, file system access, browser automation, and scheduled cron/heartbeat loops).
The primary types and categories of OpenClaw applications include:
1. Developer Operations & Remote Engineering
Because OpenClaw can run shell commands, interact with Git, and parse local code repositories, developers use it as a remote control layer for their dev machines.
Remote Terminal & Troubleshooting: Developers trigger Git pulls, check build logs, inspect container statuses, or run smoke tests directly from their phone via chat while away from their desks.
CI/CD Failure Triage: Connected via webhooks or polling loops to GitHub Actions or GitLab, OpenClaw captures failed build outputs, analyzes stack traces, correlates recent commits, and drafts a proposed fix.
Dependency & Security Auditing: OpenClaw scans local package manifests, checks for newly disclosed Common Vulnerabilities and Exposures (CVEs), runs linters or vulnerability scanners, and opens branch PRs with dependency upgrades.
2. Autonomous Knowledge Management ("Second Brain")
OpenClaw stores state, session context, and notes in flat Markdown and YAML files, making it a natural companion for local-first knowledge bases (such as Obsidian or Logseq).
Voice-Note to Structured Journaling: Users forward raw audio voice memos or quick thoughts through messaging apps.
OpenClaw transcribes them, extracts action items, tags topics, and writes structured Markdown entries into a local directory. Research Paper & Technical Ingestion: The agent monitors preprint archives or technical feeds, downloads PDF whitepapers, runs OCR/text extraction, and writes concise summaries and cross-references into a local Retrieval-Augmented Generation (RAG) store.
Meeting & Interview Synthesis: Ingests raw meeting transcripts or call recordings, separates discussion topics, maps out decisions, and logs tasks into project trackers.
3. Personal Productivity & Daily Administration
Through scheduled "heartbeat" routines, OpenClaw operates proactively rather than waiting for an incoming prompt.
Morning Executive Briefings: At a scheduled morning hour, OpenClaw checks calendar events, weather forecasts, urgent unread emails, and priority to-do items, sending a consolidated briefing message to Telegram or WhatsApp.
Email & Communication Triage: Monitors incoming inbox streams with read-only IMAP/OAuth access, classifies high-priority messages versus marketing noise, and drafts context-aware replies for review.
Family & Household Coordination: Parses group chats for household needs (e.g., extracting grocery items from texts like "grab more eggs") and updates shared lists or calendars automatically.
Delivery & Receipt Tracking: Scrapes shipping notification numbers or receipts from email, queries carrier APIs, and logs package arrivals or expense lines into a local spreadsheet.
4. Small Business & Solopreneur Operations
Solo operators and lean teams deploy OpenClaw as an automated operations layer without recurring SaaS subscription costs.
24/7 Tier-1 Customer Support: Connects directly to an inbound support mailbox or Discord community, answering repetitive inquiries (such as order status, pricing, or documentation lookups) while escalating edge cases to human staff.
Client Onboarding Pipelines: Triggers upon contract execution or new payment alerts to create project directories, issue intro emails, set up shared folders, and schedule milestone check-ins.
Invoice & Document Ingestion: Extracts line items, vendor names, due dates, and totals from inbound PDF invoices and syncs them with accounting software or local databases.
5. Web Intelligence & Autonomous Scraping
Using headless browser drivers (Playwright, Puppeteer), OpenClaw can navigate dynamic web interfaces and scrape data where traditional APIs do not exist.
Market & Competitor Tracking: Periodically monitors competitor sites, product pricing changes, regulatory postings, or social media channels (e.g., X, Reddit), summarizing notable trends into daily or weekly digests.
Automated Admin Form-Filling: Navigates legacy web portals, enters structured inputs, submits routine data forms, and captures PDF confirmation receipts.
6. Home Lab & Systems Administration
Self-hosters use OpenClaw as an automated sysadmin for local networks and server infrastructure.
Self-Hosted Stack Management: Manages local containers and services (e.g., Docker, Coolify, media servers) via natural language chat commands (e.g., "restart my torrent container" or "check disk usage").
Log Anomaly & Threat Detection: Ingests firewall logs, server metrics, and SSH connection attempts, alerting the administrator only when anomalous spikes or suspicious IPs appear.
How do I build a custom OpenClaw skill using SKILL.md to automate local shell scripts or API queries?
An OpenClaw Skill is a self-contained directory containing an execution script, optional dependencies, and a SKILL.md file. The SKILL.md file serves two roles: it tells OpenClaw’s agent runtime when and how to invoke the skill via system prompt injection, and it defines the schema/permissions for local execution.
1. Skill Directory Structure
Skills live either globally in ~/.openclaw/skills/<skill-name>/ or within an active workspace under ./skills/<skill-name>/.
~/.openclaw/skills/system-monitor/
├── SKILL.md # Skill definition, prompt guidelines, and parameter schemas
├── monitor.sh # The execution script (Bash, Python, Node, etc.)
└── requirements.txt # Optional dependencies (if using Python)
2. Creating the Executable Script
The executable can be written in any language available on your host environment. It should accept arguments (or JSON input via stdin/flags) and return output to stdout.
Create ~/.openclaw/skills/system-monitor/monitor.sh:
#!/usr/bin/env bash
set -euo pipefail
TARGET="${1:-all}"
case "$TARGET" in
gpu)
if command -v nvidia-smi &> /dev/null; then
nvidia-smi --query-gpu=name,temperature.gpu,utilization.gpu,utilization.memory,memory.used,memory.total --format=csv,noheader
else
echo "Error: nvidia-smi not found." >&2
exit 1
fi
;;
disk)
df -h / | awk 'NR==2 {print "Disk Usage: " $3 "/" $2 " (" $5 ")"}'
;;
all)
echo "=== DISK ==="
df -h / | awk 'NR==2 {print $3 "/" $2 " (" $5 ")"}'
echo "=== GPU ==="
if command -v nvidia-smi &> /dev/null; then
nvidia-smi --query-gpu=name,temperature.gpu,utilization.gpu,memory.used,memory.total --format=csv,noheader
else
echo "NVIDIA GPU not detected."
fi
;;
*)
echo "Unknown target: $TARGET. Available options: gpu, disk, all." >&2
exit 1
;;
esac
Make the script executable:
chmod +x ~/.openclaw/skills/system-monitor/monitor.sh
3. Writing the SKILL.md Specification
The SKILL.md file uses YAML frontmatter to define runtime metadata, execution commands, security controls, and JSON input schemas, followed by Markdown instructions that guide the LLM's decision-making.
Create ~/.openclaw/skills/system-monitor/SKILL.md:
---
name: system_monitor
description: Inspects local server and GPU hardware metrics including VRAM utilization, GPU temperatures, and disk capacity.
version: 1.0.0
entrypoint: ./monitor.sh
runtime: bash
permissions:
require_confirmation: false # Set to true if running destructive commands
allowed_environments:
- host
parameters:
type: object
properties:
target:
type: string
enum: ["gpu", "disk", "all"]
description: The specific subsystem to check. Defaults to 'all'.
default: "all"
required: []
---
# System Monitor Skill Guide
Use this skill whenever the user asks about system health, GPU status, VRAM consumption, temperature, or disk storage limits.
### Operational Guidelines
- If the user asks specifically about GPU performance or VRAM overhead during local model runs, invoke this skill with `{"target": "gpu"}`.
- If the user asks general questions like "how is the server doing?", invoke with `{"target": "all"}`.
- Format the raw output returned by this tool into a clean, concise markdown summary. Always highlight if GPU temperatures exceed 80°C or disk utilization is above 85%.
4. Alternative: API Query Example (Python)
If your skill interacts with an external or local HTTP API (such as querying a home automation endpoint, Ollama, or a REST service), Python is often easier.
Create ~/.openclaw/skills/service-health/run.py:
#!/usr/bin/env python3
import sys
import json
import urllib.request
def check_endpoint(url):
try:
req = urllib.request.Request(url, headers={"User-Agent": "OpenClaw-Skill"})
with urllib.request.urlopen(req, timeout=5) as response:
return {"status": response.status, "reachable": True}
except Exception as e:
return {"error": str(e), "reachable": False}
if __name__ == "__main__":
raw_args = sys.argv[1] if len(sys.argv) > 1 else "{}"
data = json.loads(raw_args)
target_url = data.get("url", "http://127.0.0.1:11434")
result = check_endpoint(target_url)
print(json.dumps(result))
Define its SKILL.md:
---
name: check_service_health
description: Queries an HTTP/REST endpoint to determine availability and response status.
version: 1.0.0
entrypoint: python3 run.py
runtime: python
parameters:
type: object
properties:
url:
type: string
format: uri
description: The fully qualified URL to test (e.g., http://127.0.0.1:8000/health).
required: ["url"]
---
# Service Health Checker
Invoke this tool to verify whether local or remote network services are online before running subsequent automation.
5. Register and Test the Skill
Reload your OpenClaw configuration to register the new skill directory:
# Verify OpenClaw discovers and validates the schema
openclaw skills list
You should see system_monitor and check_service_health in the active registry.
Testing Directly via the CLI
Test tool execution without sending an actual chat message:
# Test direct tool dispatch
openclaw skills test system_monitor --args '{"target": "gpu"}'
Testing in Agent Conversation
Test that the agent selects and uses the tool autonomously:
openclaw agent --message "What is my current GPU memory and temperature status?"
The runtime will match the user request against the description in SKILL.md, construct the parameter JSON ({"target": "gpu"}), execute ./monitor.sh gpu, read the stdout, and provide a structured answer.
From <https://gemini.google.com/app/478d4d8783754f63> Google Gemini (3.8 Flash)
Comments
Post a Comment