OpenRouter for Copilot Chat — 300+ AI Models (GPT, Claude, DeepSeek, Gemini) for VS Code

The fastest way to run 300+ OpenRouter models — OpenAI GPT, Anthropic Claude, DeepSeek, Google Gemini, Meta Llama, Mistral — inside GitHub Copilot Chat in VS Code, including hundreds of free AI models. One API key, zero runtime dependencies, and full agent mode, vision, and thinking support.

300+ models — OpenAI, Anthropic, Google, DeepSeek, Meta, and more — inside Copilot Chat's model picker, with vision, thinking mode, and a multi-agent swarm.

Table of Contents

• Quick Start — 60 seconds to 300+ models
• Why OpenRouter for Copilot Chat?
• Architecture at a Glance
• Features
  • Agent Swarm
  • Vision Proxy
  • Thinking Mode
  • Ponytail
  • Code Simplifier
• Models
• Getting Started
• Settings
• Commands
• FAQ
• License

Quick Start — 60 seconds to 300+ models

1. Get a key — create a free account at openrouter.ai/keys and copy your API key.
2. Set it — run OpenRouter: Set API Key; it lands in your OS keychain, never on disk.
3. Chat — pick any of the 300+ models in Copilot Chat, or type @swarm and let a team of agents do the work.

Why OpenRouter for Copilot Chat?

You already have Copilot's agent mode, tool calling, MCP, and skills. What you might not have is the models you want to run them on. This extension keeps the entire Copilot stack and swaps the brain:

• Don't replace Copilot — power it up. No sidebar, no new UI. Just a new model in the picker you already use.
• One API key, 300+ models. Every model on OpenRouter — OpenAI, Anthropic, Google, DeepSeek, Meta, Mistral, and more — in the picker you already use.
• One protocol. OpenRouter is a single OpenAI-compatible Chat Completions endpoint. No per-model protocol routing.
• Everything Copilot gives you still works. Agent mode, tools, instructions, MCP, skills — untouched, now on your OpenRouter account.
• Zero runtime dependencies. Pure VS Code API + Node.js built-ins. No Python, no Docker, no proxy process to babysit.

How it compares

Architecture at a Glance

┌─────────────────────────────────────┐
│   VS Code · Copilot Chat            │
│                                     │
│   Model Picker ──────────────────┐  │
│   Agent Swarm (@swarm) ──────────┤  │
│   Vision Proxy (describes first) ┘  │
└─────────────────┬───────────────────┘
                  │
                  ▼
   OpenRouter API · /api/v1/chat/completions

Every model is served through a single OpenAI-compatible endpoint, images are described before they reach the model, and the Agent Swarm orchestrates parallel agents — all inside the model picker you already know.

Features

🐝 Agent Swarm — parallel agents on one task (@swarm)

Type @swarm and a team of autonomous agents takes over: research agents explore the codebase in parallel, review agents verify the plan before a single line is written, and an implementation agent — on the exact model you have selected — does the work and runs the tests.

Your task
   |
   v
Decompose into <= 3 focus areas
   |
   +--> Research Agent · Area 1 ----+
   +--> Research Agent · Area 2 ----+---> Findings
   +--> Research Agent · Area 3 ----+
                                        |
                                        v
                         Reviewer A ----+
                         Reviewer B ----+---> Implementation Agent
                                                  (chat-selected model)
                                                  |
                                                  v
                                               runTests
                                                /   \
                                           fail/     \pass
                                              v       v
                          Implementation Agent      Report
                          (fix, then retest)        (findings + review
                                   ^                     + diff + tests)
                                   |
                                   +--- loop back

• Every agent is autonomous — its own tool loop and turn budget. Research and review are read-only; only the implementer edits.
• Resilient by design — a rate-limited or failed sub-agent degrades to a marked note; the swarm never sinks.
• Your model, your cost — research/review default to free models; implementation always runs on the model you picked.

Role models are configurable via openrouter-for-copilot.agentRoles — see Settings.

👁 Transparent Vision Proxy

Drop a screenshot into chat and the proxy describes it before the model sees it — the coding model focuses on code while a vision model handles the pixels. Falls back to any installed VS Code vision model automatically.

🧠 Thinking Mode with Reasoning Effort Control

OpenRouter exposes reasoning through a reasoning_effort setting (none / low / minimal / medium / high / xhigh / max). The extension also requests include_reasoning: true and surfaces reasoning tokens through Copilot Chat's thinking channel. Pick the effort level per model from Copilot Chat's native picker menu.

🦥 Ponytail — Lazy Senior Dev Verification

Every coding request carries a Ponytail-style system instruction that makes the model think like a lazy senior developer — efficient, not careless. Before writing any code it climbs a 7-rung ladder:

1. Does this need to be built at all? (YAGNI)
2. Does it already exist in the codebase? Reuse it.
3. Does the standard library do this? Use it.
4. Does a native platform feature cover it? Use it.
5. Does an already-installed dependency solve it? Use it.
6. Can this be one line? Make it one line.
7. Only then: write the minimum code that works.

Three intensity modes — lite (reminder), full (complete ladder, default), ultra (strict, edge-case-first) — plus off. Injected only into real coding requests; utility calls stay lean and cheap. Switch live with OpenRouter: Set Ponytail Mode.

🧹 Code Simplifier — Autonomous Code Refinement

An always-on refinement agent that reviews recently modified code and flattens nesting, kills redundancy, renames vague identifiers, and replaces chained ternaries — while never changing behaviour, API signatures, or safety checks. When active, Ponytail auto-downgrades to Lite for compatibility.

♻️ Inherits Every Copilot Capability

Because the extension plugs into Copilot's native provider API, you keep the full stack for free: agent mode, tool calling, instructions & skills, MCP, and prompt-caching stats.

💰 Cost Visibility · 🔒 Security by Default

• Per-turn list-price estimates in the status bar and logs — USD pricing pulled live from the OpenRouter /api/v1/models response.
• API key in VS Code SecretStorage (OS keychain) — never in settings.json, never in Git history.

Getting Started

Prerequisites

• VS Code 1.116 or later. This extension relies on non-public Copilot Chat APIs that may break on newer VS Code versions — report an issue if you hit one.
• GitHub Copilot subscription (Free / Pro / Enterprise — the free tier works)
• An OpenRouter account — sign up at openrouter.ai and create a key at openrouter.ai/keys.

Installation

Install from the registry used by your editor:

1. Microsoft VS Code — install from the VS Code Marketplace.
2. Editors that use Open VSX — install from Open VSX.

Usage

1. Create an API key at openrouter.ai/keys
2. Run OpenRouter: Set API Key from the Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
3. Paste your OpenRouter API key — it's stored in VS Code's secure SecretStorage (OS keychain)
4. Open Copilot Chat, click the model picker, pick any OpenRouter model (e.g. gpt-4o, anthropic/claude-3.5-sonnet, deepseek/deepseek-chat-v3)
5. That's it — chat away!

Models — the full OpenRouter catalogue, live

The full OpenRouter catalogue (300+ GPT, Claude, DeepSeek, Gemini, Llama, Mistral & Qwen models) is fetched live from GET /api/v1/models and merged with your custom models. A small offline baseline (OpenAI gpt-4o-mini, Anthropic claude-3.5-sonnet, DeepSeek deepseek-chat-v3-0324:free, Google gemini-flash-1.5) keeps the picker working with no network.

Every model is served through the same OpenAI-compatible endpoint, so there is no per-model protocol routing. Picker names are prefixed with their provider (e.g. OpenAI · gpt-4o, Anthropic · claude-3.5-sonnet) so you can tell models apart at a glance. Free models end in :free.

All models support tool calling. Models that advertise reasoning support thinking mode with reasoning-effort control. Image attachments go through the Vision Proxy.

Settings

Example settings.json for a custom OpenAI-compatible proxy:

{
  "openrouter-for-copilot.baseUrl": "https://proxy.example.com/v1",
  "openrouter-for-copilot.customModels": [
    "my-model",
    {
      "id": "team-coder",
      "name": "Team Coder",
      "maxInputTokens": 200000,
      "maxOutputTokens": 131072,
      "toolCalling": true,
      "thinking": true
    }
  ],
  "openrouter-for-copilot.modelIdOverrides": {
    "team-coder": "provider/team-coder"
  }
}

Commands

FAQ

Can I use OpenRouter models in Copilot Chat for free?

Yes. OpenRouter hosts hundreds of free models (their IDs end in :free, e.g. deepseek/deepseek-chat-v3-0324:free). For @swarm runs, the extension even audits free models automatically — probing which ones respond fastest and routing research/review through them with zero configuration.

Does this replace GitHub Copilot?

No — it extends it. You keep agent mode, tool calling, MCP, skills, and instructions; the extension just adds 300+ OpenRouter models to the model picker. You still need a GitHub Copilot subscription (the free tier works).

Is my API key safe?

Yes. The key is stored in VS Code's SecretStorage (OS keychain) — never in settings.json, never in Git history. Logs are privacy-preserving by default (minimal/metadata modes strip prompts); only explicit verbose mode writes full dumps.

Which models support vision and thinking?

Any model that advertises vision on OpenRouter works through the Vision Proxy (images are described by a vision model before reaching the coding model). Models advertising reasoning support thinking mode with reasoning_effort control (none → max) from Copilot Chat's native picker menu.

Can I use my own OpenAI-compatible endpoint?

Yes — set openrouter-for-copilot.baseUrl and add your models under openrouter-for-copilot.customModels. Anything that speaks the OpenAI Chat Completions protocol works, including local servers (Ollama, LM Studio, vLLM) and private gateways.

Does it work in Cursor, VSCodium, or other VS Code forks?

Any editor that uses the Open VSX registry can install from Open VSX. The extension relies on current Copilot Chat APIs, so test it in your fork after updating.

How do I control cost?

Free models for research/review, maxTokens per response, per-turn USD price estimates in the status bar, and implementFallback ordering if a paid model is unavailable. You can also cap spending at the OpenRouter dashboard level.

Support

Found a bug or a missing model? Open an issue — Copilot Chat APIs move fast and reports keep the extension working on newer VS Code versions. Star the repo if the extension saves you money or unlocks the model you wanted.

License

MIT