Extend your agent's capabilities with web search, browser automation, memory, and more
Turn what you learned into a concrete stack decision.
01AI Agent ToolboxBuild autonomous AI agents that can read, write, and actWant the shortlist in your inbox?
Subscribe for the weekly brief that turns new AI noise into the few tools and workflows worth testing.
Curated bundles that help you move from this guide into a working stack.
Guide
OpenClaw + Claude Code: Commands Cheat Sheet
Every command, shortcut, and workflow tip for both tools in one place
Guide
The .md Files That Define Your Agent
IDENTITY, SOUL, MEMORY, and the other files that make OpenClaw agents unique
Guide
OpenClaw Infrastructure: Dedicated Machine vs. Cloud VPS (Advanced)
LaunchAgents, PM2, systemd, SSH tunnels — build a production-grade OpenClaw deployment that survives reboots and network drops
OpenClaw has two extension mechanisms. They sound similar but serve different purposes:
Skills are capabilities your agent can use during conversations. Think of them as "apps" for your agent — web search, code execution, file management, email sending.
Plugins are extensions to the OpenClaw gateway itself. They add infrastructure-level features that work across all conversations — like persistent memory, analytics, or new communication channels.
| | Skills | Plugins |
|---|--------|---------|
| Scope | Per-conversation | System-wide |
| What they add | Tools the agent can use | Gateway features |
| Example | Web search, browser, calculator | Memory system, observation feed |
| Configuration | In skill files | In openclaw.json |
| Installed at | Varies | ~/.openclaw/extensions/ |
Skills can come bundled with OpenClaw, installed from packages, or created custom.
# List available skills
openclaw skills list
# Install a skill
openclaw skills install <skill-name>
# Enable/disable a skill
openclaw skills enable <skill-name>
openclaw skills disable <skill-name>
Skills follow a standard structure:
skills/
├── web-search/
│ ├── skill.json # Skill manifest (name, description, tools)
│ ├── index.ts # Implementation
│ └── README.md # Documentation
The skill.json defines what tools the skill exposes:
{
"name": "web-search",
"description": "Search the web using Brave Search API",
"tools": [
{
"name": "search_web",
"description": "Search the web for a given query",
"inputSchema": {
"type": "object",
"properties": {
"query": { "type": "string", "description": "Search query" }
},
"required": ["query"]
}
}
]
}
Lets your agent search the internet for current information.
Why you need it: Without web search, your agent only knows what's in its training data (which has a knowledge cutoff). With it, the agent can look up current prices, news, documentation, and answers.
Providers:
Lets your agent visit websites, fill forms, click buttons, and extract content.
Why you need it: Some information isn't available via APIs. Browser automation lets the agent interact with websites like a human would.
Implementation: Typically uses Playwright or Puppeteer under the hood.
Lets your agent write and run code to solve problems.
Why you need it: Math, data processing, file manipulation — some tasks are better solved by writing and executing code than by the LLM reasoning about them.
Lets your agent read, write, and organize files on your machine.
Why you need it: Your agent can manage notes, generate reports, organize downloads, and maintain its own workspace files.
The most important plugin for most users. claude-mem gives your agent persistent semantic memory that works across sessions.
During conversations, the agent creates "observations" — small records of important facts:
Observation: "Jet decided to use Next.js 16 for AI Bazaar because of
RSC support and Turbo mode."
These get indexed and stored. In future sessions, when the agent encounters a related topic, it can search its memory:
search(query="tech stack decision for AI Bazaar")
→ Returns the observation about Next.js 16
openclaw plugins install claude-mem
{
"plugins": {
"slots": {
"memory": "claude-mem"
},
"entries": {
"claude-mem": {
"enabled": true,
"config": {
"syncMemoryFile": true,
"workerPort": 37777,
"project": "openclaw"
}
}
}
}
}
syncMemoryFile: true — auto-syncs MEMORY.md at session startworkerPort: 37777 — the memory search service portproject — namespace for memories (keeps different projects separate)Your agent uses memory automatically, but you can also interact with it:
# List installed plugins
openclaw plugins list
# Install a plugin
openclaw plugins install <plugin-name>
# Enable/disable
openclaw plugins enable <plugin-name>
openclaw plugins disable <plugin-name>
Plugins live in ~/.openclaw/extensions/:
~/.openclaw/extensions/
└── claude-mem/
├── openclaw.plugin.json # Plugin manifest
├── package.json # Dependencies
└── plugin/
├── skills/ # Skills provided by this plugin
├── modes/ # Language/style configurations
├── commands/ # Custom slash commands
└── hooks/ # Event handlers
{
"id": "claude-mem",
"name": "Claude Memory",
"description": "Persistent semantic memory with observation indexing",
"version": "10.0.4",
"type": "memory",
"configSchema": {
"syncMemoryFile": { "type": "boolean", "default": true },
"workerPort": { "type": "number", "default": 37777 }
}
}
If you need a capability that doesn't exist as a pre-built skill, you can create your own.
Create a directory with a manifest and implementation:
my-skill/
├── skill.json # What tools this skill provides
└── index.ts # Implementation
skill.json:
{
"name": "random-quote",
"description": "Get a random inspirational quote",
"tools": [
{
"name": "get_quote",
"description": "Returns a random inspirational quote",
"inputSchema": {
"type": "object",
"properties": {}
}
}
]
}
index.ts:
const quotes = [
"The best way to predict the future is to create it.",
"Done is better than perfect.",
"Move fast and fix things.",
];
export function get_quote() {
const quote = quotes[Math.floor(Math.random() * quotes.length)];
return { quote };
}
Register it in your agent's config and test through a conversation:
Start with this minimal setup and add more as you need them:
Add these when you're ready: 4. Browser automation — for interacting with websites 5. Code execution — for data processing tasks 6. Custom skills — when you have specific needs
Don't install everything at once. Each skill adds to the agent's context (making it slower and more expensive). Add skills when you actually need them.
Model Context Protocol (MCP) is an open standard for connecting AI tools to external data sources and services. If you use Claude Code, you're already using MCP — tools like Playwright browser automation, Slack, and GitHub integrations all run as MCP servers.
MCP servers work alongside OpenClaw skills and give your agent access to a growing ecosystem of integrations:
@modelcontextprotocol/sdkMCP servers are configured in your .mcp.json file (project root or ~/.claude/.mcp.json for global):
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["@anthropic/mcp-playwright"]
}
}
}
Once configured, the tools provided by the MCP server are available to Claude Code sessions automatically. OpenClaw can also leverage MCP servers when configured in its gateway.
| | OpenClaw Skills | MCP Servers | |---|---|---| | Ecosystem | OpenClaw-specific | Cross-platform standard | | Best for | Agent-native tasks (heartbeat, cron, memory) | Tool integrations (browser, APIs, databases) | | Configuration | skill.json + code | .mcp.json | | Shared with Claude Code | No | Yes |
Use OpenClaw skills for agent-specific behavior. Use MCP servers for tool integrations you want to share across Claude Code and OpenClaw.
Next: Get the complete command reference in OpenClaw + Claude Code: Commands Cheat Sheet.