# Plugins, Bundles & The Decision Tree (/docs/meet-your-personal-ai-employee/08-plugins-bundles-decision-tree) --- type: Document title: "Plugins, Bundles & The Decision Tree" description: "Discover that channels and model providers ARE plugins, tour the bundled plugin ecosystem, install a bundle plugin for a real domain need, and earn the four-way decision tree for choosing the right extension type." status: stable order: 9608 chapter: 56 lesson: 8 duration_minutes: 35 generated: by: ag-archive/0.1.0 at: 2026-08-26T00:00:00Z ksor: audience: [public] approval: by: ag-archive/0.1.0 at: 2026-08-26T00:00:00Z trust_tier: unverified build_id: sha256:c8912c3008ae345a7fdc33ace656531ad74f37c065177057c390c7d759f1e970 source_commit: dad4758bb59919c7b9130444778ade062a2dce3e ksor_version: 0.0.47 --- ## 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." ```bash 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: ```bash 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** | WhatsApp | 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: ```bash openclaw config set plugins.entries.duckduckgo.enabled true openclaw gateway restart ``` Verify it loaded: ```bash 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](https://github.com/anthropics/knowledge-work-plugins)**: productivity, sales, customer support, product management, marketing, legal, finance, data analysis, and more. - **[Panaversity's business plugins](https://github.com/panaversity/agentfactory-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: ```bash 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: ```bash openclaw gateway restart openclaw plugins list ``` Look for `marketing` in the output with `Format: bundle`. Bundle plugins may start disabled. If so, enable it: ```bash 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: ```bash 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: ```bash 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..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." ## Flashcards Study Aid