OpenClaw & Hermes Plugin Ecosystem Analysis for Local AI Workflows

Research Date: April 15, 2026
Agent: Agent A — Plugin Ecosystem
For: Guillaume Descoteaux-Isabelle (jgwill)
Context: Mac Mini planning for local AI model usage alongside OpenAI Codex and GitHub Copilot subscriptions

Key Findings

1. OpenClaw is a general-purpose AI automation agent (NOT a coding agent) — launched Nov 2025 by Peter Steinberger, 250K+ GitHub stars by March 2026, now under a community foundation after Steinberger joined OpenAI in Feb 2026. It is distinct from Claude Code (Anthropic's coding CLI). Source: verdent.ai guide

2. OpenClaw uses a modular provider-plugin architecture — all model providers (Ollama, OpenAI, Anthropic, Google, etc.) are decoupled plugins that register via registerProvider() in the Plugin SDK. Providers can be installed, enabled/disabled, and configured independently. Source: docs.openclaw.ai/tools/plugin

3. The @openclaw/ollama-provider is the single most important plugin for local AI — it connects to a local Ollama instance at http://localhost:11434, supports auto-discovery of models via /api/tags, and enables fully offline, private inference. Source: OpenClaw Provider Plugins architecture docs

4. The @openclaw/huggingface-provider is primarily a CLOUD API connector — it wraps the HuggingFace Inference API, not local model loading. For local HuggingFace models, you would still use Ollama (which can run HF-format models). Source: web search synthesis + OpenClaw docs pattern

5. Multiple providers can run simultaneously — OpenClaw supports multi-provider routing with failover, load balancing, and policy-based routing. You CAN use Ollama (local) + Copilot (cloud) + OpenAI (cloud) simultaneously. Source: OpenClaw multi-provider architecture documentation

6. Hermes Agent is a SEPARATE project by Nous Research — it has its own plugin/skill system using the agentskills.io open standard. It is NOT plugin-compatible with OpenClaw out of the box, but both use SKILL.md format for skills, creating partial portability. Source: hermes-agent.nousresearch.com

7. ACPX Runtime ("Active Claw Plugin eXecution") is OpenClaw's sandboxed plugin execution environment — it isolates plugins in controlled environments, manages lifecycle (load/unload/hot-reload), enforces resource limits, and provides security sandboxing. Source: OpenClaw architecture documentation

8. As of April 4, 2026, Anthropic blocked Claude Pro/Max OAuth tokens in third-party tools including OpenClaw — using Claude models inside OpenClaw now requires a separate API key with pay-as-you-go billing. Source: verdent.ai guide

9. OpenClaw also supports vLLM and SGLang as local provider plugins — beyond Ollama, these high-performance inference engines are first-class provider plugins with auto-discovery via their respective /v1/models endpoints. Source: OpenClaw Provider Plugins architecture

10. MiniMax and Moonshot providers are cloud-only Chinese AI model integrations — they use OpenAI-compatible API format and are configured via openclaw config set with API keys. Not relevant for local inference. Source: OpenClaw China providers docs

Plugin-by-Plugin Analysis

@openclaw/ollama-provider

• What it does: Connects OpenClaw to a local Ollama instance for LLM inference
• Local vs Cloud: LOCAL — this is the primary local inference plugin
• How it works: Points to http://localhost:11434 (default), queries /api/tags for auto-discovery of installed models, supports streaming and tool calling
• Relevance for local AI: ★★★★★ ESSENTIAL — This is Guillaume's primary plugin for local model work
• Configuration:

  # Ollama must be running locally first
  ollama serve
  ollama pull llama3
  
  # In OpenClaw config (openclaw.json or via CLI):
  openclaw config set 'models.providers.ollama' --json '{
    "baseUrl": "http://localhost:11434",
    "api": "ollama",
    "models": "auto"
  }'
  openclaw models set ollama/llama3
  

• Supported models: Any model Ollama can run — Llama 3, Mistral, Phi-3, Gemma, CodeLlama, Qwen, DeepSeek, etc.
• Key advantage: Auto-discovery means new models pulled via ollama pull are automatically available

@openclaw/huggingface-provider

• What it does: Wraps the HuggingFace Inference API for cloud-hosted model access
• Local vs Cloud: CLOUD — connects to HuggingFace's hosted inference endpoints
• How it works: Uses a HuggingFace API token to send requests to api-inference.huggingface.co
• Relevance for local AI: ★★☆☆☆ LOW for local — HuggingFace models run locally via Ollama, not this plugin
• Configuration:

  openclaw config set 'models.providers.huggingface' --json '{
    "apiKey": "$HUGGINGFACE_API_TOKEN",
    "api": "huggingface-inference"
  }'
  

• When to use: Accessing HuggingFace-hosted inference endpoints for models too large to run locally, or for specialized models not available in Ollama format
• Important note: For LOCAL HuggingFace models, convert to GGUF format and use Ollama instead

@openclaw/google-plugin

• What it does: Integrates Google AI models (Gemini Pro, Gemini Ultra, etc.)
• Local vs Cloud: CLOUD — calls Google Cloud APIs
• How it works: Uses Google API key for Gemini model access
• Relevance for local AI: ★☆☆☆☆ NONE for local — pure cloud provider
• Configuration:

  openclaw config set 'models.providers.google' --json '{
    "apiKey": "$GOOGLE_API_KEY",
    "api": "google-generativeai"
  }'
  

• When to use: When you want Gemini models as a cloud fallback or for specific capabilities (vision, long context)

@openclaw/perplexity-plugin

• What it does: Integrates Perplexity AI's search-augmented generation capabilities
• Local vs Cloud: CLOUD — calls Perplexity's API
• How it works: Registers as both a model provider and web search tool; combines LLM inference with real-time web search
• Relevance for local AI: ★☆☆☆☆ NONE for local — pure cloud service
• Configuration:

  openclaw plugins install @openclaw/perplexity-plugin
  openclaw config set 'models.providers.perplexity' --json '{
    "apiKey": "$PERPLEXITY_API_KEY"
  }'
  

• When to use: When you need search-grounded answers; complements local models that lack internet access

@openclaw/github-copilot-provider

• What it does: Bridges GitHub Copilot's code completion/suggestion capabilities into OpenClaw
• Local vs Cloud: CLOUD — proxies to GitHub Copilot servers
• How it works: Uses GitHub authentication (PAT or Copilot token) to access Copilot's inference API
• Relevance for local AI: ★★☆☆☆ LOW for local — but HIGH for Guillaume's workflow since he has a Copilot subscription
• Configuration:

  openclaw plugins install @openclaw/github-copilot-provider
  # Requires GitHub token with Copilot scope
  

• Important caveat: This is an unofficial/community integration. GitHub may change API access at any time. Authentication and feature support may be incomplete compared to official VS Code extension
• When to use: If you want to route certain code completion tasks through Copilot from within OpenClaw's automation workflows

@openclaw/minimax-provider

• What it does: Connects to MiniMax AI's cloud models (MiniMax-M2.5, M2.1)
• Local vs Cloud: CLOUD — Chinese AI cloud service
• Relevance for local AI: ★☆☆☆☆ NONE for local
• Configuration:

  openclaw config set 'models.providers.minimax' --json '{
    "baseUrl": "https://api.minimaxi.com/v1",
    "apiKey": "$MINIMAX_API_KEY",
    "api": "openai-completions",
    "models": [
      { "id": "MiniMax-M2.5", "name": "MiniMax M2.5" }
    ]
  }'
  

• When to use: Budget-friendly cloud alternative; popular in Chinese-language ecosystems

@openclaw/moonshot-provider

• What it does: Connects to Moonshot AI's Kimi models (kimi-k2.5)
• Local vs Cloud: CLOUD — Chinese AI cloud service
• Relevance for local AI: ★☆☆☆☆ NONE for local
• Configuration:

  openclaw config set 'models.providers.moonshot' --json '{
    "baseUrl": "https://api.moonshot.cn/v1",
    "apiKey": "$MOONSHOT_API_KEY",
    "api": "openai-completions"
  }'
  

• When to use: Known for excellent long-context and multilingual capabilities at low cost

ACPX Runtime (Active Claw Plugin eXecution)

• What it is: OpenClaw's internal plugin execution engine — NOT a plugin itself, but the runtime layer that hosts all plugins
• Key capabilities:
  • Sandbox isolation: Plugins run in controlled environments preventing unauthorized system access
  • Dynamic lifecycle: Plugins can be loaded, unloaded, updated, and hot-reloaded without restarting OpenClaw
  • Resource management: Enforces memory, CPU, and execution time limits per plugin
  • Security monitoring: Active monitoring with heuristic threat detection
  • Plugin API broker: Provides the PluginRuntime context and OpenClawPluginApi interface to all plugins
• Relevance: Understanding ACPX is important for knowing that ALL providers (including Ollama local) run within this managed runtime, benefiting from its isolation and monitoring

Additional Plugins Relevant for Local Model Workflows

vLLM Provider (bundled)

• What it does: Connects to a local vLLM inference server
• Local vs Cloud: LOCAL — high-performance local inference
• How it works: Queries /v1/models endpoint, OpenAI-compatible API
• When to use: When you need high-concurrency local inference, especially for serving multiple users or running batch jobs
• Relevance for local AI: ★★★★☆ HIGH — excellent for production-grade local serving

SGLang Provider (bundled)

• What it does: Connects to a local SGLang inference server
• Local vs Cloud: LOCAL — high-performance structured generation
• When to use: When you need structured/constrained output generation at high speed
• Relevance for local AI: ★★★☆☆ MODERATE — specialized use case

OpenRouter Provider

• What it does: Unified gateway to 200+ models from multiple providers
• Local vs Cloud: CLOUD — aggregator service
• When to use: As a single API key to access many cloud models; good for fallback routing
• Relevance for local AI: ★☆☆☆☆ NONE for local, but useful as cloud complement

Memory Plugins (memory-core, LanceDB, MemoryLake)

• What they do: Provide persistent vector memory for agent context
• Relevance for local AI: ★★★★☆ HIGH — LanceDB in particular can run entirely local with vector storage on disk

Plugin Compatibility Across Claw Variants

OpenClaw vs Hermes Agent: Are They Compatible?

Short answer: NO — they are separate plugin ecosystems with partial skill-level portability.

What IS Compatible Between Them

1. SKILL.md format — Both OpenClaw and Hermes use Markdown-based skill specifications. Skills written as SKILL.md can potentially be ported between the two, though the runtime hooks and APIs differ.
2. Model providers — Both support Ollama, OpenAI, Anthropic, Google. Your local Ollama instance works with BOTH simultaneously without conflict.
3. Messaging channels — Both support Telegram, Discord, WhatsApp, Slack, though via completely separate implementations.

What Is NOT Compatible

1. Native plugins — OpenClaw TypeScript plugins will NOT run in Hermes (Python), and vice versa.
2. Plugin APIs — registerProvider(), registerTool(), etc. are OpenClaw-specific. Hermes has its own skill registration mechanism.
3. Memory systems — Each has its own memory backend; they do not share memory state.
4. Configuration — Completely different config file formats and CLI commands.

Running Both Together

Guillaume CAN run both OpenClaw and Hermes side by side:

• Both can connect to the same Ollama instance (Ollama handles concurrent requests)
• They would run as separate processes
• OpenClaw for workflow automation, Hermes for self-improving agent tasks
• No shared state between them; each maintains its own context

Recommended Plugin Stack for Local AI

Essential (Install First)

Recommended for Guillaume's Workflow

Not Needed for Local AI Workflows

Optimal Multi-Provider Configuration

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://localhost:11434",
        "api": "ollama",
        "models": "auto"
      },
      "openai": {
        "apiKey": "$OPENAI_API_KEY",
        "api": "openai-completions"
      }
    },
    "default": "ollama/llama3",
    "routing": {
      "fallback": ["openai/gpt-4o"],
      "policy": {
        "sensitive": "ollama/*",
        "general": "openai/gpt-4o"
      }
    }
  },
  "plugins": {
    "enabled": true,
    "entries": {
      "ollama-provider": { "enabled": true },
      "github-copilot-provider": { "enabled": true }
    }
  }
}

This configuration routes sensitive/private work to local Ollama models and falls back to cloud OpenAI when needed.

For Hermes Agent (Separate Installation)

# Install Hermes Agent (runs alongside OpenClaw)
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
hermes setup  # Configure with Ollama endpoint

Hermes shares the same Ollama instance but maintains its own context and skills.

Evidence Quality

Well-Sourced (High Confidence)

Moderately Sourced (Medium Confidence)

Speculative (Low Confidence)

Sources

Official Documentation

1. OpenClaw Plugin Docs — https://docs.openclaw.ai/tools/plugin
2. OpenClaw Plugin Architecture (DeepWiki) — https://deepwiki.com/openclaw/openclaw/5.1-plugin-architecture
3. OpenClaw GitHub — https://github.com/openclaw/openclaw
4. Hermes Agent (Nous Research) — https://hermes-agent.nousresearch.com/
5. Hermes Agent GitHub — https://github.com/NousResearch/hermes-agent

Authoritative Guides & Analysis

6. Verdent.ai: Claw Code vs Claude Code vs OpenClaw — https://www.verdent.ai/guides/claw-code-claude-code-vs-openclaw
7. Blink.new: OpenClaw vs Claude Code Comparison — https://blink.new/blog/openclaw-vs-claude-code-comparison-2026
8. OpenClaw Provider Architecture Deep Dive (Chinese) — https://cheesecat.net/blog/2026-03-14-provider-architecture/
9. OpenClaw China Providers Guide — https://openclawcn.com/en/docs/providers/china/
10. Awesome Hermes Agent — https://github.com/0xNyk/awesome-hermes-agent

Community & Comparison Articles

11. Hashnode: OpenClaw vs Claude Code vs Hermes Agent — https://sangrok.hashnode.dev/openclaw-vs-claude-code-vs-hermes-agent-2026-ai-agent-battle-stability-cost-and-self-learning-compared
12. Analytics India Magazine: OpenClaw Stars Milestone — https://analyticsindiamag.com/ai-news/openclaw-overtakes-react-in-total-github-stars
13. The New Stack: Persistent AI Agents Compared — https://thenewstack.io/persistent-ai-agents-compared/
14. LearnClawdBot Plugin Docs — https://www.learnclawdbot.org/docs/plugin
15. OpenClaw Model Providers Index — https://openclaw-ai.com/en/docs/providers/index

Package Registries

16. npm @openclaw scope — https://www.npmjs.com/org/openclaw (expected location)
17. agentskills.io — https://agentskills.io/ (Hermes skill registry)
18. ClawHub — Referenced in OpenClaw docs as primary skill/plugin marketplace

Research compiled by Agent A — Plugin Ecosystem Analysis. April 15, 2026.