OpenClaw Tools, Skills, and Plugins Overview

This page helps you select the appropriate Capabilities surface. Tools are functions an agent can invoke, skills show agents how to perform tasks, and plugins extend runtime functionality with tools, providers, channels, hooks, and bundled skills.

This page serves as an overview and routing guide. For complete details on tool policy, default settings, group membership, provider restrictions, and configuration fields, refer to Tools and custom providers.

Start here

For most agents, begin with the default tool categories and only modify policy when the agent should access fewer tools or requires explicit host access.

If you need to...	Use this first	Then read
Let an agent act with existing capabilities	Built-in tools	Tool categories
Control what an agent can call	Tool policy	Tools and custom providers
Teach an agent a workflow	Skills	Skills, Creating skills, Skill Workshop, and Self-learning
Add a new integration or runtime surface	Plugins	Plugins and Build plugins
Run work later or in the background	Automation	Automation overview
Coordinate multiple agents or harnesses	Sub-agents	ACP agents and Agent send
Orchestrate concurrent agents from code	Swarm	Code Mode and Sub-agents
Search a large OpenClaw tool catalog	Tool Search	Tool Search
Combine several tools in one compact program	Code Mode	Code Mode

Choose tools, skills, or plugins

Use a tool when the agent needs to act

A tool is a typed function that the agent can call, for example exec, browser, web_search, message, or image_generate. Use tools when the agent must read data, modify files, send messages, invoke a provider, or interact with another system. Visible tools are provided to the model as structured function definitions.

The model only sees tools that pass through the active profile, allow/deny policy, provider restrictions, sandbox state, channel permissions, and plugin availability.

Use a skill when the agent needs instructions

A skill is a SKILL.md instruction set injected into the agent prompt. Use a skill when the agent already has the necessary tools but needs a repeatable workflow, review checklist, command sequence, or operational constraint.

Skills can reside in a workspace, shared skill directory, managed OpenClaw skill root, or plugin package.

Skills | Skill Workshop | Self-learning | Creating skills | Skills config

Use a plugin when OpenClaw needs a new capability

A plugin can introduce tools, skills, channels, model providers, speech, realtime voice, media generation, web search, web fetch, hooks, and other runtime features. Use a plugin when the capability involves code, credentials, lifecycle hooks, manifest metadata, or installable packaging. Existing plugins can be obtained from ClawHub, npm, git, local directories, or archives.

Install and configure plugins | Build plugins | Plugin SDK

Built-in tool categories

The table shows representative tools to help you identify the surface. It is not the complete policy reference. For exact groups, defaults, and allow/deny semantics, see Tools and custom providers.

Category	Use when the agent needs to...	Representative tools	Read next
Runtime	Execute commands, handle processes, or perform Python analysis backed by a provider	`exec`, `process`, `terminal`, `code_execution`	Exec, Control UI terminal, Code execution
Files	Access and modify files inside the workspace	`read`, `write`, `edit`, `apply_patch`	Apply patch
Human input	Halt execution until the user makes a structured choice	`ask_user`	Ask user
Web	Look up information on the internet, browse X posts, or retrieve readable page content	`web_search`, `x_search`, `web_fetch`	Web tools, Web fetch
Browser	Control an active browser instance	`browser`	Browser
Operator UI	Lay out linked Control UI panes, panels, and navigation elements	`screen`	Screen
Messaging and channels	Dispatch replies or take actions in a channel	`message`	Agent send
Sessions and agents	Review sessions, assign tasks, coordinate collectors, redirect a run, or report status	`sessions_*`, `agents_wait`, `subagents`, `agents_list`, `session_status`, `get_goal`, `create_goal`, `update_goal`	Goal, Swarm, Sub-agents, Session tool
Automation	Schedule tasks or react to events happening in the background	`cron`, `heartbeat_respond`	Automation
Gateway and nodes	Check Gateway status or connected target devices	`gateway`, `nodes`	Gateway configuration, Nodes
Media	Examine, produce, or vocalize media content	`image`, `image_generate`, `music_generate`, `video_generate`, `tts`	Media overview
Large OpenClaw catalogs	Find, invoke, and combine many available tools without transmitting each schema to the model	`exec`, `wait`, `tool_search_code`, `tool_search`, `tool_describe`	Code Mode, Tool Search

Note

Code Mode and Tool Search are experimental OpenClaw agent surfaces. Codex harness runs use Codex-native code mode, native tool search, deferred dynamic tools, and nested tool calls instead of tools.codeMode or tools.toolSearch.

Plugin-provided tools

Plugins can register extra tools. Plugin developers connect tools using api.registerTool(...) together with the manifest's contracts.tools; refer to the Plugin SDK and Plugin manifest for contract specifics.

Frequently encountered plugin tools are:

Diffs to display file and markdown differences
Show widget for self-contained inline SVG and HTML inside supported chat interfaces
Screen to lay out a connected Control UI
LLM Task for JSON-only workflow steps
Lobster for typed workflows that support resumable approvals
Tokenjuice to compress noisy exec and bash tool output
Tool Search for locating and invoking large tool collections without embedding every schema in the prompt
Canvas for node Canvas control and A2UI rendering

Configure access and approvals

Tool policy applies before the model is called. When policy removes a tool, the model does not see that tool's schema during that turn. A run may lose tools due to global configuration, per-agent configuration, channel policy, provider restrictions, sandbox rules, channel or runtime policy, or plugin availability.

Tools and custom providers covers tool profiles, allow and deny lists, provider-specific limitations, loop detection, and provider-backed tool settings.
Exec approvals describes host command approval policy.
Elevated exec covers controlled execution beyond the sandbox.
Sandbox vs tool policy vs elevated explains which layer governs file and process access.
Per-agent sandbox and tool restrictions describes agent-specific restrictions for delegated runs.

Extend capabilities

Pick the extension path based on what you need OpenClaw to accomplish:

Install or manage an existing plugin through Plugins.
Create a new integration, provider, channel, tool, or hook with Build plugins.
Add or customize reusable agent instructions using Skills and Creating skills.
Use Plugin SDK and Plugin manifest when implementation contracts are required.

Troubleshoot missing tools

If the model cannot see or invoke a tool, begin with the effective policy for that turn:

Review the active profile, tools.allow, and tools.deny in Tools and custom providers.
Examine provider-specific limitations in Tools and custom providers and verify the chosen model provider supports the tool format.
Inspect channel permissions, sandbox status, and elevated access with Sandbox vs tool policy vs elevated and Elevated exec.
Confirm the owning plugin is installed and enabled in Plugins.
For delegated runs, check agent-specific restrictions in Per-agent sandbox and tool restrictions.
For large OpenClaw catalogs, determine whether the run uses direct tool exposure, Code Mode, or Tool Search.

Automation for cron, tasks, heartbeat, hooks, standing orders, and Task Flow
Agents for the agent model, sessions, memory, and multi-agent coordination
Tools and custom providers as the authoritative tool policy reference
Plugins for plugin installation and management
Plugin SDK for plugin author reference
Skills for skill load order, gating, and configuration
Skill Workshop for generated and reviewed skill creation
Tool Search for compact OpenClaw tool catalog discovery
Code Mode for compact JavaScript or TypeScript workflows over a hidden OpenClaw tool catalog
Swarm for structured fan-out and collection from Code Mode