OpenClaw Plugin Analysis: GitHub Copilot Provider, Google Plugin, and Perplexity Plugin

Agent: E — Copilot & Google Plugin Capability Analysis
Date: 2026-04-15
For: Guillaume Descoteaux-Isabelle
Scope: @openclaw/github-copilot-provider, @openclaw/google-plugin, @openclaw/perplexity-plugin capabilities, synergy, and routing

Key Findings

1. The GitHub Copilot provider is a bundled, first-class OpenClaw extension that uses your Copilot subscription to access GPT-4o, GPT-4.1, Claude Sonnet 4.5/4.6, o1/o3-mini, and potentially any new Copilot-supported model — all at $0 marginal cost within your subscription. Authentication uses GitHub device-login flow (no API keys needed). It also provides memory search embeddings for free.

2. The Google plugin is a multi-capability powerhouse — not just "Google Search." It provides: Gemini LLM chat completions, image generation (Gemini 3.1 Flash Image), video generation (Veo 3.1), music generation (Lyria 3), media understanding (image/audio/video), and web search via Gemini Grounding. Auth requires a GEMINI_API_KEY or Google OAuth.

3. The Perplexity plugin is a web-search-only provider (not an LLM provider). It adds structured web search with domain/date filtering (native API) or AI-synthesized answers with citations (OpenRouter/Sonar). Requires its own PERPLEXITY_API_KEY or OPENROUTER_API_KEY.

4. All three can run simultaneously alongside Ollama. OpenClaw uses a primary + fallbacks model array per agent. Each provider occupies a different capability niche (LLM inference vs. web search vs. media generation), so they complement rather than compete.

5. Hermes Agent is a separate, Python-based framework — not a variant of OpenClaw. It has migration tools (hermes claw migrate) to import OpenClaw configs/skills, but plugins are not directly cross-compatible at runtime. Different architecture (Node.js vs Python).

@openclaw/github-copilot-provider

What It Does

The github-copilot provider is a bundled OpenClaw extension (enabled by default) that turns your GitHub Copilot subscription into a full LLM provider for OpenClaw. It handles authentication, model discovery, transport selection, and token exchange — all without requiring a separate API key or VS Code.

Source location: extensions/github-copilot/ in the OpenClaw monorepo
Plugin manifest: extensions/github-copilot/openclaw.plugin.json

Integration Mechanism

The provider uses GitHub's Copilot API directly (not the Language Server):

1. Device-login flow: openclaw models auth login-github-copilot triggers a GitHub device OAuth flow (visit URL → enter code → token stored)
2. Token exchange: At runtime, OpenClaw exchanges the stored GitHub token for a short-lived Copilot API token
3. Transport auto-selection: Claude model IDs route through anthropic-messages transport; GPT/o-series/Gemini use openai-responses transport — selected automatically based on model ID

// From extensions/github-copilot/models.ts
export function resolveCopilotTransportApi(
  modelId: string,
): "anthropic-messages" | "openai-responses" {
  return (normalizeOptionalLowercaseString(modelId) ?? "").includes("claude")
    ? "anthropic-messages"
    : "openai-responses";
}

Models Available via Copilot

From extensions/github-copilot/models-defaults.ts, the default catalog includes:

Critical: The provider has a forward-compat catch-all — any unknown model ID is accepted and synthesized as a dynamic model definition. If Copilot adds gpt-5.4 tomorrow, you just set it in config without waiting for an OpenClaw update. The Copilot API rejects unavailable models at request time.

Model availability depends on your GitHub plan (Free, Pro, Enterprise). If a model is rejected, try another ID.

All model costs are set to $0 — your Copilot subscription covers API usage through this provider.

Configuration Fields (2 fields)

From the plugin manifest configSchema:

The second "field" is the auth profile stored via the device-login flow (not user-editable config — managed by openclaw models auth login-github-copilot).

Environment Variable Resolution

The device-login flow stores its token in the auth profile store and takes precedence over all env vars.

Memory Search Embeddings

The Copilot provider also serves as an embedding provider for OpenClaw's memory search:

• Auto-detected at priority 15 (after local embeddings, before paid OpenAI)
• Discovers embedding models from the Copilot /models endpoint
• Prefers text-embedding-3-small
• No separate API key needed — reuses your Copilot auth

{
  agents: {
    defaults: {
      memorySearch: {
        provider: "github-copilot",
        model: "text-embedding-3-small"  // optional override
      }
    }
  }
}

Can It Run Alongside Ollama?

Yes, absolutely. OpenClaw's architecture supports multiple providers simultaneously. You can set Copilot as primary and Ollama as fallback, or vice versa:

{
  agents: {
    defaults: {
      model: {
        primary: "github-copilot/gpt-4o",
        fallbacks: ["ollama/gemma4", "ollama/llama3.3"]
      }
    }
  }
}

Does the Copilot Subscription Cover Usage?

Yes. All model costs through the Copilot provider are set to $0. The Copilot subscription covers API usage. Model availability depends on plan tier.

@openclaw/google-plugin

What It Does

The Google plugin is a multi-capability extension that provides access to the full Google Gemini ecosystem — far more than just search. It is enabled by default and registers under two provider IDs: google (API key) and google-gemini-cli (OAuth).

Source location: extensions/google/ in the OpenClaw monorepo
Key source files: api.ts, index.ts, gemini-cli-provider.ts, image-generation-provider.ts, media-understanding-provider.ts, web-search-provider.ts

Capabilities Matrix

Configuration Fields (from plugin manifest)

The plugin manifest configSchema has a webSearch object with 2 fields:

Authentication (2 methods)

Method 1: API Key (recommended)

• Set GEMINI_API_KEY or GOOGLE_API_KEY environment variable
• Or run: openclaw onboard --auth-choice gemini-api-key
• Requires a Google AI Studio API key (free tier available)

Method 2: Gemini CLI OAuth (unofficial)

• Uses the google-gemini-cli provider
• Requires gemini-cli installed (brew install gemini-cli or npm install -g @google/gemini-cli)
• Login: openclaw models auth login --provider google-gemini-cli --set-default
• ⚠️ Unofficial integration — some users report Google account restrictions

Does It Require a Separate Google API Key?

Yes. The Google plugin does NOT work through Copilot. It requires its own GEMINI_API_KEY from Google AI Studio, OR OAuth through the Gemini CLI. This is completely independent of your GitHub Copilot subscription.

Plugin Manifest Contracts

From openclaw.plugin.json:

{
  "contracts": {
    "mediaUnderstandingProviders": ["google"],
    "imageGenerationProviders": ["google"],
    "musicGenerationProviders": ["google"],
    "videoGenerationProviders": ["google"],
    "webSearchProviders": ["gemini"]
  }
}

This means the Google plugin registers itself as a provider for five distinct capability contracts — making it the most capability-rich single plugin in OpenClaw.

Example Models

API Key Rotation

Google supports multiple API keys for rotation:

• GEMINI_API_KEYS (comma-separated)
• GEMINI_API_KEY_1, GEMINI_API_KEY_2, etc.
• GOOGLE_API_KEY (fallback)
• OPENCLAW_LIVE_GEMINI_KEY (single override)

@openclaw/perplexity-plugin

What It Does

The Perplexity plugin is a web search provider only — it is NOT a model/LLM provider. It gives OpenClaw agents the ability to search the web using Perplexity's API or via OpenRouter's Sonar model.

Source location: extensions/perplexity/ in the OpenClaw monorepo

Configuration Fields (3 fields)

From the plugin manifest configSchema.webSearch:

Two Search Modes (Auto-Selected by Key Prefix)

Native API Filtering (pplx- keys only)

Comparison with Google Plugin Web Search

Does It Require a Separate Subscription?

Yes. Perplexity requires either:

• A Perplexity API key (pplx- prefix) — requires a Perplexity account/plan
• An OpenRouter API key (sk-or- prefix) — uses your OpenRouter balance

Neither is included in a GitHub Copilot subscription.

Plugin Synergy and Multi-Provider Routing

How OpenClaw Routes Between Providers

OpenClaw uses a primary + fallbacks model configuration per agent. This is NOT round-robin — it's an ordered failover chain:

{
  agents: {
    defaults: {
      model: {
        primary: "github-copilot/gpt-4o",
        fallbacks: ["ollama/gemma4", "google/gemini-3-flash-preview"]
      }
    }
  }
}

Routing rules:

1. OpenClaw always tries the primary model first
2. On failure (rate limit, timeout, context overflow, overload), it falls to the next model in fallbacks
3. Each provider plugin can classify its own error types via classifyFailoverReason
4. Cooldown probes prevent hammering a failed provider
5. Session-override persistence lets a specific conversation stick to a provider mid-session

Can You Use Multiple Providers Simultaneously?

Yes, but with nuance:

• LLM inference: One model handles each request, but fallback chains span providers. You can set primary: "github-copilot/claude-sonnet-4.6" with fallbacks: ["ollama/gemma4"] — Copilot handles requests when available, Ollama takes over when it can't.
• Web search: Perplexity and Google (Gemini Grounding) are independent web search providers. You configure which one is active via tools.web.search.provider.
• Image generation: Google and OpenAI both register as image providers. You set imageGenerationModel.primary to choose which handles image requests.
• Embeddings: Copilot, Ollama, and OpenAI all register as embedding providers. Auto-detection tries them in priority order.

Recommended Synergy Configuration for Guillaume

Given a Copilot subscription + local Ollama + Google API key:

{
  agents: {
    defaults: {
      // LLM: Copilot primary, Ollama fallback (free local backup)
      model: {
        primary: "github-copilot/gpt-4o",
        fallbacks: ["ollama/gemma4"]
      },
      // Image gen: Google Gemini
      imageGenerationModel: {
        primary: "google/gemini-3.1-flash-image-preview"
      },
      // Memory embeddings: Copilot (free with subscription)
      memorySearch: {
        provider: "github-copilot"
      }
    }
  },
  tools: {
    web: {
      search: {
        // Choose one: "perplexity", "gemini", or "ollama"
        provider: "gemini"
      }
    }
  }
}

How Cloud Plugins Complement Local Ollama

Optimal pattern: Use Copilot/Google for quality-critical tasks and capabilities only available in the cloud (image gen, video gen, web search). Use Ollama as offline fallback and for privacy-sensitive work.

Hermes and Cross-Claw Compatibility

What Is Hermes?

Hermes Agent is a separate, Python-based AI agent framework built by Nous Research. It is NOT a variant or fork of OpenClaw. Key differences:

Plugin Cross-Compatibility

Plugins are NOT directly cross-compatible at runtime. The architectures are fundamentally different (Node.js vs Python, manifest-driven vs auto-learned).

However, Hermes provides migration tools:

• hermes claw migrate — imports OpenClaw settings, memories, skills, and API keys
• Markdown-defined skills transfer cleanly
• Complex Node.js/JavaScript plugins require manual Python rewrites
• Config files (SOUL.md, MEMORY.md, AGENTS.md) have mapped destinations in Hermes

Does Hermes Use the Same Plugin System?

No. OpenClaw plugins are npm packages with openclaw.plugin.json manifests that register capabilities (providers, channels, tools) via the Plugin SDK. Hermes skills are Python-based and auto-generated by the agent from its own task execution patterns. The two systems solve similar problems with completely different architectures.

Running Both Together

Many advanced users run both:

• OpenClaw as the messaging gateway/orchestrator (channel hub)
• Hermes as a specialist agent that learns and improves at specific tasks
• They can share API keys/credentials but maintain separate runtime environments

Evidence Quality

Contradictions Found

1. "2 fields" for Copilot config — The Copilot plugin manifest only shows 1 user-configurable field (discovery.enabled). The second "field" may refer to the auth profile managed via CLI, or to a UI hint (discovery parent object). The user's source claiming "2 fields" may have been counting differently.

2. "2 fields" for Google config — The Google plugin manifest shows 2 fields under webSearch (apiKey, model). However, the overall Google plugin has much broader config including auth choices for both API key and OAuth. The "2 fields" matches the webSearch config specifically.

3. "3 fields" for Perplexity config — Confirmed: webSearch.apiKey, webSearch.baseUrl, webSearch.model. Matches exactly.

4. Web search claims Copilot gives Claude/Gemini — One generic web search result said Copilot does NOT provide Claude or Gemini access. This is contradicted by the actual OpenClaw source code which explicitly lists claude-sonnet-4.6 and claude-sonnet-4.5 in Copilot model defaults, and auto-selects anthropic-messages transport for Claude IDs. The confusion likely arises because the web search was answering about GitHub Copilot in VS Code, not about the GitHub Copilot API accessed through OpenClaw.

5. "OpenClaw" as an AI model — One search result confused OpenClaw (the agent framework) with an AI model name. OpenClaw is a framework, not a model.

Sources

Primary Sources (Official Documentation + Source Code)

1. OpenClaw GitHub Repository: https://github.com/openclaw/openclaw (357K+ stars)
   • docs/providers/github-copilot.md — Copilot provider setup guide
   • docs/providers/google.md — Google/Gemini provider setup guide
   • docs/providers/perplexity-provider.md — Perplexity provider setup guide
   • docs/providers/ollama.md — Ollama provider setup guide
   • docs/providers/index.md — Provider directory
   • docs/concepts/model-providers.md — Model provider overview with routing config
   • extensions/github-copilot/openclaw.plugin.json — Copilot plugin manifest
   • extensions/github-copilot/models-defaults.ts — Default Copilot model catalog
   • extensions/github-copilot/models.ts — Transport selection + forward-compat logic
   • extensions/google/openclaw.plugin.json — Google plugin manifest
   • extensions/perplexity/openclaw.plugin.json — Perplexity plugin manifest

Secondary Sources (Comparison Articles)

2. OpenClaw vs Hermes Agent — A Deep Technical Comparison: https://www.vibesparking.com/en/blog/ai/openclaw/2026-04-09-openclaw-vs-hermes-agent-deep-comparison/
3. Hermes Agent Migration from OpenClaw: https://hermes-agent.nousresearch.com/docs/guides/migrate-from-openclaw/
4. OpenClaw vs Hermes Agent (Petronella Tech): https://petronellatech.com/blog/openclaw-vs-hermes-agent-2026
5. Hermes Agent vs OpenClaw (a2a-mcp.org): https://a2a-mcp.org/blog/hermes-agent-vs-openclaw
6. Hermes Agent vs OpenClaw (Turing Post): https://www.turingpost.com/p/hermes
7. Community Plugins docs: https://docs.openclaw.ai/plugins/community
8. OpenClaw npm package: https://www.npmjs.com/package/openclaw