OpenClaw Plugins: How to Find, Install, and Build Extensions

OpenClaw plugins add capabilities that the core framework does not ship by default. A plugin can add a new messaging channel (Telegram, Slack, DingTalk), swap in a different model provider (a local LLaMA endpoint instead of OpenAI), attach a persistent memory backend, register custom tools, or replace the speech engine entirely.

The plugin system recognizes two distinct formats.

Native OpenClaw plugins ship with a JSON manifest and an in-process runtime module. They are purpose-built for OpenClaw and have full access to the capability registration system: channels, model providers, agent uses, tools, skills, speech, transcription, voice, media processing, and content generation.

Compatible bundles follow Codex, Claude, or Cursor plugin layouts. OpenClaw maps these into its plugin inventory automatically, so you can reuse extensions built for other agent frameworks without forking them. This is useful when a tool you need already exists as a Claude or Codex extension but hasn't been ported to OpenClaw natively.

The practical difference matters when you are evaluating plugins. Native plugins integrate more tightly with OpenClaw's configuration hierarchy and runtime inspection tooling. Compatible bundles work, but you lose some of the fine-grained control around slot assignment and policy enforcement.

OpenClaw supports five installation sources, each suited to different situations.

ClawHub is the primary discovery surface for community plugins. It provides OpenClaw-native metadata, version history, and install statistics. Browse it at clawhub.ai or search from the CLI. This is where most people start when looking for plugins.

npm gives you direct registry access for standard package workflows. If a plugin author publishes to npm, you can install it like any other Node package.

Git repositories support branch, tag, and commit-level pinning. This is the right choice for installing plugins from a specific fork, testing a pre-release branch, or pulling from a private repo.

Local paths are for development and testing. The --link flag lets you mount a local directory as a plugin, which is essential when building your own extensions. Changes to the source files take effect on the next gateway restart.

Marketplaces support Claude-compatible extensions. If you already use plugins built for other agent frameworks, OpenClaw can pull them in through its marketplace source without requiring you to repackage them.

When you install a plugin by name without specifying a source, OpenClaw resolves the package through a built-in priority order. For deterministic installs, specify the source explicitly so there is no ambiguity about where the plugin comes from.

Persistent storage for your OpenClaw plugin output

50 GB free workspace with auto-indexing, semantic search, and MCP access. No credit card required.

Sign Up Free

The plugin lifecycle follows a predictable pattern: search, install, enable, restart, and verify.

Start by searching ClawHub from the command line:

openclaw plugins search memory

Once you find what you need, install it:

openclaw plugins install <plugin-name>

You can pin a specific version, install from git with a branch reference, or link a local directory for development. After installation, enable the plugin:

openclaw plugins enable <plugin-id>

Then restart the gateway so it loads the new code:

openclaw gateway restart

Verify that the plugin registered its capabilities at runtime:

openclaw plugins inspect <plugin-id> --runtime --json

This command is more useful than it looks. It proves actual gateway integration by showing the registered tools, hooks, services, and gateway methods. The difference between "installed" and "running" trips up a lot of people. A plugin can be installed and enabled in config but fail to register at runtime due to a missing dependency or a config error. The --runtime flag catches that.

Other management commands:

• List all installed plugins: openclaw plugins list
• Disable without removing: openclaw plugins disable <plugin-id>
• Update a plugin: openclaw plugins update <plugin-id>
• Deep-check gateway health: openclaw gateway status --deep --require-rpc

If things get tangled, openclaw doctor --fix cleans up stale configuration and resolves common issues.

OpenClaw uses a hierarchical configuration system for plugin policy. Understanding this hierarchy saves debugging time, especially when a plugin is installed but not behaving as expected.

The top-level switch is plugins.enabled, which acts as a global master toggle. Below that, you have fine-grained controls:

• plugins.allow sets an exclusive allowlist. When populated, only listed plugins can activate. Everything else is blocked regardless of other settings.
• plugins.deny blocks specific plugins. Deny always overrides allow, so you can allowlist a broad category and then exclude individual plugins.
• plugins.entries.<id>.enabled controls individual plugins. Use this for per-plugin toggling without touching the allow/deny lists.
• plugins.slots.<slot> handles exclusive category assignment. Some capabilities like memory and context engines only allow one active provider. Slots enforce that exclusivity.
• plugins.load.paths points to local development directories for plugins under active development.

Two rules catch people off guard. First, workspace-origin plugins (those installed from external sources rather than bundled) require explicit enablement. They do not auto-activate on install. Second, bundled opt-in plugins do auto-activate when their surfaces are referenced, which means you might see a bundled plugin running without having explicitly enabled it.

The preferOver declaration in the manifest lets one plugin intentionally replace another. This handles upgrade scenarios where a new channel plugin supersedes an older one without requiring manual disable/enable steps.

Most third-party guides stop at installation, but building your own plugin is where OpenClaw's extensibility becomes practical. The manifest system is straightforward once you understand the structure.

Every native plugin starts with a JSON manifest file and a runtime module. The manifest declares what capabilities the plugin provides: which channels it adds, which tools it registers, which hooks it responds to. The runtime reads this manifest to wire the plugin into the correct extension points.

A minimal plugin needs just two files: the manifest (containing name, version, description, and capability declarations) and an entry-point module that exports the functions implementing those capabilities. During development, keep both in a dedicated directory and point your config at it.

Development workflow:

1. Create a directory for your plugin with the manifest and entry point
2. Use plugins.load.paths in your config to point to the plugin directory
3. Restart the gateway to load the plugin
4. Test with openclaw plugins inspect <plugin-id> --runtime --json to confirm registration
5. Iterate on the code, restarting the gateway after each change

The --link flag during local installation keeps the plugin pointed at your source directory, so you avoid the copy-install-test loop. Combined with --runtime inspection, you get a tight feedback cycle.

For plugins that need to store persistent data (conversation logs, vector embeddings, configuration state), consider pairing the plugin with external storage. Local SQLite works for single-instance setups. For multi-agent deployments where several OpenClaw instances share state, a cloud workspace gives you persistence without managing infrastructure. Fast.io's free agent plan provides 50 GB of storage with Intelligence Mode for semantic search across stored files, which is useful when plugins generate artifacts that need to be searchable later.

The OpenClaw plugin ecosystem has grown quickly. Here are categories and specific plugins that solve real problems.

Memory and context is one of the most active plugin categories. memU provides a hierarchical knowledge graph that enables proactive agent behavior, going beyond simple key-value recall. Memory LanceDB adds vector-backed storage with auto-recall and auto-capture, turning your agent's conversation history into a searchable knowledge base. MemOS Cloud offers cloud-hosted cross-agent memory with async recall and isolation between agents.

Security plugins address a gap in the default configuration. SecureClaw provides OWASP-aligned runtime hardening and prompt injection prevention. The onecli credential vault uses a Rust HTTP gateway to inject secrets without exposing raw API keys in your agent's context.

Workflow automation plugins like Lobster add typed JSON pipelines with approval gates. This is useful for production deployments where you need human oversight before an agent takes consequential actions.

Communication plugins extend OpenClaw beyond its default channels. Community-maintained integrations exist for WeCom (WeChat Work), Feishu/Lark, DingTalk, and QQ. The Voice Call plugin adds outbound phone calls and multi-turn voice conversations through Twilio and Telnyx.

Infrastructure plugins like Better Gateway improve the developer experience with WebSocket stability enhancements, an embedded IDE, and a terminal interface.

A note on trust: community plugins can execute code, handle credentials, send messages, and access external systems. Treat third-party plugins as untrusted by default. Review the source, check the install count and community feedback on ClawHub, and test in a sandboxed environment before deploying to production.

When your plugins generate files, reports, or other artifacts that need to persist across sessions or get shared with a team, a dedicated workspace helps. Fast.io workspaces auto-index uploaded files for semantic search and AI chat, so plugin output becomes queryable without building a separate retrieval pipeline. The MCP server lets OpenClaw agents read and write files programmatically through Streamable HTTP at /mcp.