Plugins, Bundles & The Decision Tree
What You Will Learn
In this lesson, you will discover that the channels and model providers you have been using since Lesson 2 are already plugins, tour the bundled plugin ecosystem, install a bundle plugin to add a no-code domain capability, and earn the full decision tree for choosing the right extension type.
By the end, you should be able to distinguish a native plugin (TypeScript, in-process) from a bundle plugin (files only, Claude-compatible), apply the Activation Dance to enable a bundled plugin that ships disabled, install a bundle plugin from a GitHub repo, and use the four-way decision tree (skill, MCP server, bundle plugin, native plugin) to classify any new capability your agent needs.
James pushed back from the table. He had skills installed from Lesson 6. He had mcp-server-time connected from Lesson 7. The dashboard showed both: skills loaded, MCP tools live.
"I have skills installed," he said. "MCP servers connected. Channels working since Lesson 2." He paused. "Are channels also extensions? They feel like they should be. WhatsApp does not come from the model. Something has to be doing the work."
Emma did not answer directly. She slid the laptop across the table. "Run this," she said. "Then tell me what you see."
openclaw plugins list --verbose
James ran it. The terminal filled with names he recognized: Google, Anthropic, WhatsApp, Discord. A format column on every line. Most said openclaw. A few said bundle.
"These are all plugins," he said slowly. "WhatsApp is a plugin. Google is a plugin."
"Yes," Emma said. "You have been using plugins since Lesson 2. You just did not have the word for them yet."
You are doing exactly what James is doing. Your agent already runs on plugins. Now you name them, install one for a real domain need, and earn the decision tree that ties everything in this chapter together.
Tour Your Bundled Plugins
Run the same command James ran:
openclaw plugins list --verbose
The output shows every plugin shipped with your install. Read the columns:
| Field | What It Tells You |
|---|---|
| loaded / disabled | Whether the plugin is active right now |
| format | openclaw for native plugins, bundle for file-based plugins |
| origin | bundled means it shipped with your install |
| providers | For model plugins, which provider names it registers (e.g., google, google-gemini-cli) |
| error | Why a plugin is disabled (usually "bundled, disabled by default") |
Scroll through and you will see three categories:
| Category | Loaded Examples | Disabled Examples |
|---|---|---|
| Model providers | Google, Anthropic, OpenAI, DeepSeek, Mistral, Ollama, NVIDIA | Groq |
| Channels | Discord, Telegram, Slack, Signal, Matrix, IRC, Line, MS Teams | |
| Utilities | Browser, DuckDuckGo, Memory Core, Talk Voice | ElevenLabs, Brave, Firecrawl, OpenShell Sandbox |
These are the plugins you have been using since Lesson 2. The model that answers your prompts: a plugin. The channel that delivers your messages: a plugin. The web search the agent reaches for: a plugin.
Most model providers load automatically because the gateway probes which ones have valid API keys. Most channels ship disabled because each needs its own credentials. Most utilities ship disabled because most students will not use most of them on day one.
This is the bundled ecosystem. It is the present.
The Activation Dance, Applied to Plugins
A disabled plugin is installed but not active. You met the Activation Dance in Lesson 2: bundled exists, disabled by default, enable, configure if needed, restart. Apply it now to a keyless plugin.
DuckDuckGo is a good first choice if it shows as disabled in your install: it needs no API key. The plugin ID is the short name in parentheses from the verbose list (in this case, duckduckgo). Enable it:
openclaw config set plugins.entries.duckduckgo.enabled true
openclaw gateway restart
Verify it loaded:
openclaw plugins list --verbose | grep duckduckgo
You should see it now shows as loaded. Ask your agent: "Use DuckDuckGo to search for the latest OpenClaw release notes." If DuckDuckGo was already loaded by default in your install, pick another keyless one from the disabled list and try the same flow.
The pattern is universal: find the plugin ID in the list, enable it, restart, verify. If a plugin needs an API key, you will see an authentication error in the log after restart and you will know to configure credentials before the next try.
Two Plugin Formats
Look back at the format column in your plugins list --verbose output. Every bundled plugin shows openclaw. These are native plugins: TypeScript code that runs inside the gateway process. But OpenClaw supports a second format: bundle plugins.
Native (openclaw) | Bundle (.claude-plugin/) | |
|---|---|---|
| Contains | openclaw.plugin.json + TypeScript | Markdown skills + JSON commands + MCP connectors |
| Code required? | Yes | No |
| Runs where | Inside the gateway process | Loaded as file-based extensions |
| Used for | Channels, model providers, voice, gateway hooks | Domain workflows, knowledge packages |
| Example | WhatsApp adapter, Brave search | Marketing plugin, finance plugin |
Native plugins are how OpenClaw extends itself with new in-process capabilities. Writing one means writing TypeScript that binds into the gateway runtime. That is platform developer territory, covered in later chapters.
Bundle plugins are different. They use the .claude-plugin/ directory format that Claude Code and Cowork also use. They package domain workflows (marketing, finance, legal, customer support) as a set of skills, commands, and MCP connectors bundled together in one folder. No TypeScript. No build step. Any Claude-compatible plugin works in OpenClaw as a bundle.
This opens an ecosystem far larger than what ships bundled.
Install a Bundle Plugin
Two open-source plugin collections work with OpenClaw out of the box:
- Anthropic's knowledge-work plugins: productivity, sales, customer support, product management, marketing, legal, finance, data analysis, and more.
- Panaversity's business plugins: Islamic finance, banking, legal operations, and financial modeling. If you completed Part 3 of this book, you already know these domains.
Pick a domain you actually care about. Marketing is a good first choice because the test prompt is concrete and the skill names are readable. Clone the repo and install one bundle from it:
git clone https://github.com/anthropics/knowledge-work-plugins
openclaw plugins install ./knowledge-work-plugins/marketing
If you do not have git installed, open the repo link in your browser, click Code → Download ZIP, extract it, and point the install command at the extracted folder.
After installing, restart the gateway and verify:
openclaw gateway restart
openclaw plugins list
Look for marketing in the output with Format: bundle. Bundle plugins may start disabled. If so, enable it:
openclaw plugins enable marketing
Now ask your agent what the bundle gave it. Point it at the install location:
List all skills from the marketing extension at
~/.openclaw/extensions/marketing/skills/.
You should see skills like campaign-plan, content-creation, brand-review, competitive-brief, draft-content, email-sequence, performance-report, and seo-audit. You can also verify in the OpenClaw dashboard under your agent's Skills tab, where they appear as "Extra Skills."
Now use one. The campaign-plan skill follows the OAMCM framework (Objective, Audience, Message, Channel, Measure) and produces a structured brief:
Generate a full campaign brief with objectives, audience, messaging,
channel strategy, content calendar, and success metrics for
https://agentfactory.panaversity.org/
The goal is brand awareness in the US.
If the bundle is working, the output follows the OAMCM structure: campaign overview, target audience, key messages, channel strategy, a week-by-week content calendar, success metrics, and more. If the output is generic with no structured sections, the bundle may not have loaded correctly. Check openclaw plugins list again.
One clone, one install, one enable, and your AI Employee handles marketing campaigns. No code. A bundle of skills, commands, and connectors, dropped in as files.
Plugins published on ClawHub or npm install even more simply. The openclaw plugins install command checks ClawHub first and falls back to npm:
openclaw plugins install @openclaw/voice-call
No clone needed for published packages. The GitHub repos install from a local clone because they are not published on npm or ClawHub yet.
The Decision Tree
You have now touched all four ways to extend your agent. Skills (Lesson 6) for knowledge. MCP servers (Lesson 7) for external access. Channels and model providers (since Lesson 2, retroactively named) as native plugins. And bundle plugins (this lesson) for no-code domain workflows.
When your agent needs something new, the question is: which one?
| Your agent needs to... | Extension type | What it is | Code required? |
|---|---|---|---|
| Know something new | Skill | SKILL.md (Agent Skills spec) | No |
| Access an external service or API | MCP server | Tool connection via MCP protocol | JSON config |
| Gain a no-code capability bundle | Bundle plugin | .claude-plugin/ directory of files | No |
| Extend the gateway itself | Native plugin | TypeScript code running in-process | Yes (TypeScript) |
The Escalation Path
If you are unsure where to start, start at the bottom of the cost ladder and escalate only when the cheaper option is not enough.
Start here → Skill (SKILL.md, no code, knowledge only)
↓ not enough?
→ MCP server (JSON config, external tool access)
↓ not enough?
→ Bundle plugin (no code, packaged domain workflow)
↓ not enough?
→ Native plugin (TypeScript, gateway-level capability)
Most agent needs are skills. Most of the rest are MCP servers. The few that remain are bundle plugins. Native plugins are for platform developers extending the gateway itself in TypeScript, and you have already met them as your channels, model providers, and voice plugins.
Hooks (a fifth way to extend behavior, by gating tool calls) are not in this tree. They live in Lesson 14, where you learn to gate your agent's tools before it does something irreversible.
Try With AI
Exercise 1: Categorize Your Bundled Ecosystem
Run the verbose plugin list and ask your agent to organize it for you:
openclaw plugins list --verbose
Then in your agent:
Look at the output of openclaw plugins list --verbose and group every
plugin into three categories: model providers, channels, and utilities.
For each plugin, tell me whether it is loaded or disabled and whether
the format is openclaw (native) or bundle.
What you are learning: The bundled ecosystem is real and inspectable. Channels and model providers are not built into the gateway core; they are native plugins. Naming what you have been using is the first step to extending it.
Exercise 2: Use Your Bundle Plugin
If you installed the marketing bundle (or a different one), generate a real artifact with one of its skills. For marketing:
Use the campaign-plan skill from the marketing extension to generate
a brand awareness campaign brief for a Pakistani SaaS startup launching
in the US market. Follow the full OAMCM structure. The product is
an AI agent platform for solo founders.
If you installed a different bundle (finance, legal, sales), pick its most prominent skill and run a similar real-domain prompt.
What you are learning: Bundle plugins are not theoretical. One install, one prompt, and the agent gains a structured workflow it did not have before. The OAMCM structure (or whichever structure your skill follows) appears because the bundle taught the agent what good output looks like.
Exercise 3: Classify Three New Needs
Think of three new capabilities you want your agent to have. For each one, classify:
- Does the agent need to know something new? → Skill
- Does the agent need to access an external service or API? → MCP server
- Does the agent need a no-code domain capability bundle? → Bundle plugin
- Does the agent need a new in-process gateway feature? → Native plugin
Write your classification next to each need. Justify each one in one sentence using the escalation path: why this and not the cheaper option below it.
What you are learning: The decision tree as a real working tool. The correct classification saves you from cloning a TypeScript repo when a SKILL.md file would have worked, or from writing a skill when an MCP server is the only thing that can reach the data you need.
What You Should Remember
Channels and Model Providers Are Native Plugins
You have been using plugins since Lesson 2. WhatsApp, Discord, Google, Anthropic: native plugins, written in TypeScript, running in-process inside the gateway. Run openclaw plugins list --verbose to see them.
Two Plugin Formats
Native (openclaw format) is TypeScript code in-process: channels, model providers, voice, gateway hooks. Bundle (.claude-plugin/ format) is files only, no code: domain workflows packaged as skills, commands, and MCP connectors. Bundle plugins are Claude-compatible.
The Activation Dance Applies to Every Plugin
Bundled plugins ship disabled by default. Find the plugin ID, enable with openclaw config set plugins.entries.<id>.enabled true, restart the gateway, configure credentials if the plugin needs them.
The Decision Tree
Four ways to extend your agent: skill (knowledge), MCP server (external access), bundle plugin (no-code capability bundle), native plugin (in-process gateway feature). Escalate up the tree only when the cheaper option is not enough. Most needs are skills. Native plugins are platform developer territory.
When Emma came back, James had three plugins enabled that had been disabled an hour earlier, the marketing bundle installed, and a campaign brief on his screen.
"I missed something the first time through," he said. "When I set up WhatsApp in Lesson 2, I thought channels were a separate thing. A built-in feature. They are not. WhatsApp is a plugin. The Google connection is a plugin. The whole gateway is a thin core with plugins clipped on."
"And the marketing bundle?" Emma asked.
"Different format," James said. He pulled up the comparison on his notepad. "Native plugins are TypeScript. They run in-process. That is what channels and model providers are. Bundle plugins are files. No code. The marketing bundle is eight skills, a few commands, a directory structure. I cloned a repo, ran one install, restarted the gateway. The agent gained a department." He paused. "At my old company, our warehouse system had a kernel and modules. The kernel ran the conveyor belts. The modules added new categories of work, billing, staff scheduling, returns. Native plugins are kernel modules. Bundle plugins are the staff manuals you give a new department on day one."
Emma was quiet for a moment. "I have not thought about it that way." She glanced at his notepad. "Honestly, the kernel-and-modules framing is cleaner than how I usually explain it." She paused. "There is one thing left, though. Your agent now has knowledge, external access, and a marketing department. But it still only does anything when you message it first. It is reactive."
"And you want it proactive," James said.
"I want it to wake up on its own," Emma said. "Heartbeats. Cron. The agent runs without you starting the conversation. Lesson 9."