OpenClaw Tools, Skills, and Plugins Overview

This page helps you pick the right Capabilities surface. Tools are actions an agent can call, skills show agents how to do work, and plugins supply runtime capabilities, including tools, providers, channels, hooks, and packaged skills.

This is an overview and routing page. For complete tool policy, defaults, group membership, provider restrictions, and configuration fields, see Tools and custom providers.

Start here

For most agents, begin with the built-in tool categories. Adjust policy only when the agent should see 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 an agent can call, for example exec, browser, web_search, message, or image_generate. Reach for tools when the agent must read data, modify files, send messages, call a provider, or drive another system. Tools that are visible get passed to the model as structured function definitions.

Only tools that pass the active profile, allow/deny policy, provider restrictions, sandbox state, channel permissions, and plugin availability are seen by the model.

Use a skill when the agent needs instructions

A skill is a SKILL.md instruction pack that gets loaded into the agent prompt. Choose a skill when the agent already holds the tools it needs but requires a repeatable workflow, review rubric, command sequence, or operating constraint.

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

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

Use a plugin when OpenClaw needs a new capability

Through a plugin you can add tools, skills, channels, model providers, speech, realtime voice, media generation, web search, web fetch, hooks, and other runtime capabilities. Pick a plugin when the capability involves code, credentials, lifecycle hooks, manifest metadata, or installable packaging. Plugins that already exist can be installed 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 so you can recognize 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, control processes, share operator terminals, or run Python supplied by a provider	`exec`, `process`, `terminal`, `code_execution`	Exec, Control UI terminal, Code execution
Files	View workspace files and modify them	`read`, `write`, `edit`, `apply_patch`	Apply patch
Human input	Stop and wait for a structured choice that the user owns, or receive a credential without exposing it	`ask_user`, `secrets`	Ask user, Secrets
Web	Query the web, query X posts, or retrieve page content in readable form	`web_search`, `x_search`, `web_fetch`	Web tools, Web fetch
Browser	Drive a browser session	`browser`	Browser
Operator UI	Lay out Control UI panes and panels, or pick and define appearance themes	`screen`, `theme`	Screen, Theme
Session progress	Refresh the durable progress card of the parent session; sub-agents cannot use it	`progress_card`	Progress card
Messaging and channels	Deliver replies or perform channel actions	`message`	Agent send
Sessions and agents	Examine sessions, hand off work, coordinate collectors, guide a different 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	Set up scheduled work or react to background events	`automations` (`cron` alias)	Automation
Gateway and nodes	Check Gateway state or paired target devices	`gateway`, `nodes`	Gateway configuration, Nodes
Plugin lifecycle	View, install, enable, disable, remove, or reload plugins	`plugins`	Agent plugin management
Media	Examine, produce, or vocalize media	`view_image`, `image_generate`, `music_generate`, `video_generate`, `tts`	Media overview
Large OpenClaw catalogs	Look up, invoke, and chain numerous eligible tools without shipping every schema to the model	`exec`, `wait`, `tool_search`, `tool_describe`, `dispatch_action`	Code Mode, Tool Search

Session tools and sessions_spawn take an optional user (the verified requester_profile.id of an admitted participant) and act under that person's authority. Leave it out and the execution keeps its original requester, even after collaborative steering. Being selected does not mean the person asked for or approved the action. See Session tools and Sub-agent tool reference.

On Gateways serving multiple users, personal_instructions reads and updates the authenticated requester's personal USER.md via the Gateway, even when the chat runs in a project worktree. The coding and messaging profiles include it; it does not broaden general file-tool access. See User model.

Targeted formatting changes are supported by the edit tool, such as stripping trailing spaces or swapping Unicode quotes, dashes, and spaces. Such changes are applied even when fuzzy normalization would make the old and new text compare equal. Requests that replace text with identical text, and edits whose content ends up unchanged, still report no changes.

Note

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

Plugin-provided tools

Additional tools can be registered by plugins. Plugin authors wire tools through api.registerTool(...) and the manifest's contracts.tools; the contract details live in Plugin SDK and Plugin manifest.

Tools that plugins commonly provide include:

Diffs for rendering file and markdown diffs
Show widget for self-contained inline SVG and HTML in supported chat clients
Screen for arranging a connected Control UI
LLM Task for JSON-only workflow steps
Lobster for typed workflows with resumable approvals
Tokenjuice for compacting noisy exec and bash tool output
Tool Search for discovering and calling large tool catalogs without putting every schema in the prompt
Canvas for the macOS widget-panel presenter

Configure access and approvals

Tool policy is applied before the model call. When policy strips a tool, that tool's schema is not sent to the model for the turn. A run may lose tools owing to global config, per-agent config, channel policy, provider restrictions, sandbox rules, channel/runtime policy, or plugin availability.

The action list and parameters of the message tool are also narrowed to the current channel plus the channels in the agent's route bindings. Agents spanning multiple channels keep the union of those channels' declared actions and capabilities. Local sessions with no channel bindings, and scheduled runs, still get configured-channel discovery. No new setting is needed to cut prompt overhead: bindings determine what the schema advertises, while execution remains governed by normal delivery permissions. When bindings and capabilities do not change, the schema bytes stay stable no matter what order plugins register in.

Completion and settle turns holding a source-bound message grant can send text, media, or attachments, including media-only replies, the optional caption, and file metadata (filename, contentType, or mimeType). MEDIA: directives and remote Markdown images follow the normal outbound media policy. Local files passed through media, attachments, or MEDIA: must sit inside the allowed mediaAccess.localRoots; local Markdown image paths remain literal text. The action is still send; channel, account, destination, and thread remain locked to the current conversation. replyTo may name the current message or thread but cannot pick a different reply target. On this restricted grant, inline reply and audio_as_voice directives stay unavailable.

In Control UI/Webchat, publish a local HTML report to the current conversation by calling message(action=send, media=<path>) and leaving out the target. OpenClaw verifies the current file-read and delivery permissions, validates the HTML, and stores an attachment snapshot. A parent agent may publish the final revision of a child agent's report using its own read permission. Keep the HTML self-contained; relative assets are not bundled. This explicit send does not confer generated-file provenance: automatic MEDIA: replies keep their existing HTML restrictions, and the preview retains its existing sandbox and script controls.

One semantic image inspection capability, named view_image, is exposed by OpenClaw. Where the active harness provides its own loader, OpenClaw suppresses its duplicate. In all other cases, the OpenClaw-provided implementation takes path for a single local image path or permitted URL, or paths for multiple; maxImages caps the combined list at a default of 20. Codex's native implementation takes one local filesystem path. Callers must follow the active tool schema.

Policy entries that already exist under the name image have to be migrated to view_image. Run openclaw doctor --fix to bring supported config policy surfaces and persisted automation toolsAllow lists up to date.

Tools and custom providers covers tool profiles, allow/deny lists, restrictions tied to a specific provider, loop detection, and tool settings backed by a provider.
Exec approvals covers the approval policy for host commands.
Elevated exec covers execution outside the sandbox under controlled conditions.
Sandbox vs tool policy vs elevated explains which layer governs access to files and processes.
Per-agent sandbox and tool restrictions covers restrictions specific to an agent for delegated runs.

Extend capabilities

Pick the extension path that matches what you need OpenClaw to do:

To install or manage a plugin you already have, use Plugins.
To build a new integration, provider, channel, tool, or hook, use Build plugins.
To add reusable agent instructions or adjust them, use Skills and Creating skills.
When you need implementation contracts, use Plugin SDK and Plugin manifest.

Troubleshoot missing tools

Tool access is not granted by configured tools.exec and tools.fs sections. Only when other active global, agent, and provider policies allow those tools does the profile migration warning suggest alsoAllow entries.

If a tool is invisible to the model or cannot be called, begin with the effective policy for the current turn:

In Tools and custom providers, check the active profile, tools.allow, and tools.deny.
In Tools and custom providers, check restrictions specific to the provider, and verify that the selected model provider supports the tool shape.
Use Sandbox vs tool policy vs elevated and Elevated exec to check channel permissions, sandbox state, and elevated access.
In Plugins, check whether the plugin that owns the tool is installed and enabled.
For delegated runs, check the per-agent restrictions in Per-agent sandbox and tool restrictions.
For large OpenClaw catalogs, verify whether the run relies on direct tool exposure, Code Mode, or Tool Search.

Automation for cron, tasks, heartbeat, hooks, standing orders, and workflows
Agents for the agent model, sessions, memory, and multi-agent coordination
Tools and custom providers for the tool policy reference
Plugins for installing and managing plugins
Plugin SDK for the plugin author reference
Skills for skill load order, gating, and config
Skill Workshop for creating skills through generation and review
Tool Search for discovering a compact OpenClaw tool catalog
Code Mode for compact JavaScript workflows over a hidden OpenClaw tool catalog
Swarm for structured fan-out and collection from Code Mode
Tools invoke API, call these tools over HTTP