5 OpenClaw Plugins That Actually Make It Production-Ready

Introduction

There is a certain point every serious OpenClaw user reaches. The agent is running, the setup works, and then slowly, almost without noticing, the cracks show up. A workflow that should take seconds starts requiring three follow-up prompts. The context window fills up with things the agent should already know. The API bill at the end of the month is higher than expected, and there is no clear answer for why.

Most people at this point start tweaking their skills, adjusting prompts, or switching models, but the problem is usually none of those things.

OpenClaw's default configuration is designed to get you started, not to match how you actually use it. The real power that makes it suitable for daily professional use lies in the plugin layer, yet most OpenClaw users have never explored it.

In this post, we are covering five OpenClaw Plugins, and each solves a different problem, each adding a layer that the default setup simply does not have. But before getting into the plugins themselves, it is worth understanding what separates a plugin from a skill.

What Are OpenClaw Plugins (And Why They're Different from Skills)

If you have spent any time in the OpenClaw community, you have probably seen both terms used interchangeably. They are not the same thing, and the distinction matters more than it seems.

A skill is a markdown file, specifically a SKILL.md that gets injected into the agent's context at inference time. It shapes how the agent thinks, what tone it uses, and what steps it follows. Every time the agent runs, that file loads into the prompt. Skills are useful for behavior, but they come at a cost: they consume tokens on every single request, whether or not they are relevant to what you asked.

A plugin is fundamentally different. It is a standalone executable that runs as a separate process alongside OpenClaw. Instead of loading into context, it exposes a set of tools through a defined interface that the agent can call when it actually needs them. OpenClaw loads plugins once at startup and calls into them only when a task requires it. No tokens consumed just by existing.

How to Install a Plugin

Installing any plugin follows the same pattern:

openclaw plugins install <plugin-name>

That command downloads the plugin, registers it in your OpenClaw configuration at ~/.openclaw/openclaw.json, and makes its tools available the next time the agent starts. You can open that file at any time to see which plugins are currently registered and adjust their individual configurations.

To confirm a plugin is active after installation, run:

openclaw plugins list

This returns all registered plugins and their current status. If something is not showing up, a full restart of the OpenClaw daemon is usually all it takes.

With that covered, here are the five plugins worth adding to your setup.

1. Manifest

When you configure OpenClaw, you pick a default model. Claude Opus, GPT-4, whatever you prefer. From that point on, every request, regardless of its type, goes to that model. Asking the agent to list files in a directory costs the same as asking it to debug a race condition across three services. The model does not know the difference, and OpenClaw does not try to make one.

This is where most API bills quietly spiral. Not from one expensive task, but from hundreds of simple ones hitting a premium model they never needed.

Manifest sits between OpenClaw and your LLM providers. Every request passes through it before reaching a model. It reads the request, classifies the task complexity, and routes it to the cheapest model capable of handling it. Simple lookups go to lighter models. Reasoning-heavy tasks escalate to whatever model can actually handle them. Routing occurs in milliseconds and is invisible to the agent; it only sees a response.

The cost difference compounds fast. Users running OpenClaw through Manifest have reported up to 70% reduction in monthly API spend, not by doing less, but by stopping the habit of paying Opus prices for Haiku-level work. The Manifest dashboard makes this visible: you can see cost broken down per session, per tool call, and per model, so you know exactly where your spend is going and whether the routing decisions are working as expected.

Installing Manifest:

openclaw plugins install manifest

Once installed, Manifest registers itself as the default routing layer. You can configure routing thresholds and model preferences in ~/.openclaw/openclaw.json under the manifest plugin entry.

Manifest makes the biggest difference in setups where the agent runs long sessions, handles multi-step tasks, or operates overnight without supervision. The more requests flow through OpenClaw, the more the routing logic saves, because the inefficiency it fixes is not a one-time cost; it is per-request.

2. Composio

Out of the box, OpenClaw cannot reach your Gmail, Slack, GitHub, or Notion. Not because the agent is incapable, but because every external service requires OAuth authentication, token management, and refresh handling, none of which OpenClaw sets up for you. Most people work around this by manually generating API keys, pasting them into configuration files, and hoping the tokens don't expire mid-session. It works until it does not.

Composio solves this at the authentication layer. It runs as an MCP server that sits between OpenClaw and every external app you want the agent to reach. You connect your accounts once through the Composio dashboard, and from that point on, OpenClaw talks to Composio, and it handles everything else. Token refresh, OAuth flows, rate limits, API versioning. None of that touches your OpenClaw config directly.

Each app connection runs in an isolated MCP session. If one integration fails or a token expires, it does not affect the others. The agent continues operating normally while Composio handles the reconnection in the background.

Installing Composio:

openclaw plugins install composio

After installation, connect your apps through the Composio dashboard and add the plugin entry to ~/.openclaw/openclaw.json:

{
  "plugins": {
    "composio": {
      "apiKey": "your-composio-api-key"
    }
  }
}

In practice, what this unlocks is straightforward. A single prompt like "summarize my unread emails, open a GitHub issue for anything that needs follow-up, and post a summary to the team Slack channel" now executes end to end, no switching tabs, no copying API keys, no manual auth setup. The agent has the required access, and Composio ensures it remains valid.

With 850+ supported apps, Composio covers most of what a professional OpenClaw setup would ever need to reach.

3. Hyperspell

OpenClaw's default memory is a MEMORY.md file. It grows with every session, gets compacted when it reaches a limit, loses information in the process, and reloads entirely on every turn, whether the content is relevant or not. For occasional use, this is fine, but for anyone relying on OpenClaw daily, it becomes a real problem fast.

Hyperspell replaces this layer entirely. It indexes your connected data sources, emails, documents, and past conversations into a knowledge graph, then injects only the relevant slice of that graph before each agent turn. The agent gets what it needs, not everything it has ever seen.

Memory also becomes sharper over time. Every query refines how the knowledge graph is indexed, so context recall improves the more you use it. An agent running Hyperspell can reference a decision you made three weeks ago without you having to bring it up.

Installing Hyperspell:

openclaw plugins install @hyperspell/openclaw-hyperspell

Connect your data sources through the Hyperspell dashboard, then add your API key under the hyperspell entry in ~/.openclaw/openclaw.json. Context injection is automatic from there.

4. OpenClaw Foundry

Most workflows repeat. You run the same sequence of tasks every morning, follow the same steps every time a PR needs review, and ask the agent the same three things before a meeting. OpenClaw handles all of these, but it handles them the same way every time, waiting for you to prompt it from scratch. It does not recognize the pattern. It does not try to make things easier on its own.

Foundry fixes this. It sits in the background during your sessions, watches what you ask for, and, when it detects a recurring pattern, writes a new tool definition into itself. That tool becomes part of the agent's available toolkit the next time you start a session, no manual configuration required.

What makes this different from writing a skill is the output. A skill adds behavioral instructions to the agent's context. Foundry creates an executable tool that the agent can call, with its own inputs and outputs, registered in the tool registry and available on demand.

Installing Foundry:

openclaw plugins install @getfoundry/foundry-openclaw

This downloads the plugin from npm, extracts it to ~/.openclaw/extensions/foundry/, enables it automatically, and restarts the gateway. After that, add the following to ~/.openclaw/openclaw.json:

{
  "plugins": {
    "entries": {
      "foundry": {
        "enabled": true,
        "config": {
          "autoLearn": true,
          "sources": {
            "docs": true,
            "experience": true,
            "arxiv": false,
            "github": false
          },
          "marketplace": {
            "autoPublish": false
          }
        }
      }
    }
  }
}

autoLearn: true is the key setting, it tells Foundry to continuously learn from your sessions without requiring you to trigger it manually. The sources block controls where Foundry pulls additional context when writing new tools: OpenClaw's own documentation, your past session experience, arXiv papers, and public GitHub repos. For most setups, keeping docs and experience enabled is enough to start.

5. Opik

Multi-step agent runs fail in non-obvious ways. A tool call returns incorrect output, a sub-agent silently errors out, and a model call takes 12 seconds on a task that should take 2 seconds. Without structured tracing, you are left reading raw logs and guessing. That gets old fast.

Opik is an open-source LLM and agent observability platform built by Comet ML. The OpenClaw plugin hooks into the gateway process and exports a structured trace for every run, LLM request and response spans, tool call inputs and outputs, sub-agent lifecycle events, latency at each step, and token usage with cost. Every event that matters has a corresponding span in the Opik dashboard.

Image reference: https://github.com/comet-ml/opik-openclaw

This is a different layer from what Manifest covers. Manifest tells you how much a request costs and which model handled it. Opik tells you what the agent actually did inside that request, which tools it called, in what order, what each one returned, and where the run slowed down or failed. Both answer different questions and neither replaces the other.

Installing Opik:

Requirements: OpenClaw >=2026.3.2, Node.js >=22.12.0

openclaw plugins install @opik/opik-openclaw

After installation, restart the gateway, then run the setup wizard:

openclaw opik configure

This validates your endpoint and API key and automatically writes the config. To verify everything is connected:

openclaw opik status

The recommended config in ~/.openclaw/openclaw.json looks like this:

{
  "plugins": {
    "entries": {
      "opik-openclaw": {
        "enabled": true,
        "config": {
          "apiKey": "your-api-key",
          "apiUrl": "https://www.comet.com/opik/api",
          "projectName": "openclaw",
          "workspaceName": "default"
        }
      }
    }
  }
}

For teams that cannot send trace data to a third party, Opik is fully self-hostable. Replace apiUrl with your own instance endpoint, and nothing else changes.

Where to Go From Here

Each plugin owns a distinct layer. Hyperspell handles context before the request starts. Manifest handles model routing during it. Composio handles external reach when the agent needs to act. Foundry watches for patterns across sessions and builds tools from them. Opik traces everything after the fact, so you know exactly what happened and why.

None of them overlap, and none of them are doing the same job twice. You can start with just one, whichever layer is causing the most friction in your current setup, and layer in the rest as your workflow grows.

Each plugin has its own documentation to read before configuring anything: Manifest, Composio, Hyperspell, OpenClaw Foundry, and Opik. The OpenClaw plugin docs cover the installation system in full if you want to go deeper on how plugins interact with the gateway.