GitHub Copilot BYOK vs Continue vs Cline: One VS Code Key

Bring your own model works in all three of the VS Code extensions people shortlist in 2026 — GitHub Copilot through its Custom Endpoint (BYOK) provider, Continue through one entry in config.yaml, Cline through its OpenAI Compatible provider — and because each of them sends OpenAI Chat Completions to the URL you give it, one Router One key at https://api.router.one/v1/chat/completions serves all three.

The short version: keep GitHub Copilot if you already work in it and want chat and agent sessions on your own key while inline suggestions stay on GitHub's service; pick Continue for an open-source assistant with a declarative YAML config that also runs in JetBrains; pick Cline for an open-source agent with per-step approvals and the fewest fields to fill. Below: the properties you can check — license and pricing model, what runs on your key, config surface, protocol, model id form, tool calling on a custom endpoint, China access — then a config block for each, and the one-key-per-tool setup that keeps the three bills apart in Dashboard → Logs.

If your question is editor versus terminal, Cline vs Cursor vs Claude Code and OpenCode vs Claude Code vs Codex CLI cover those shapes. This post stays inside VS Code and compares three ways of putting your own endpoint behind it.

Side by side

Two rows carry the weight. The protocol row is why one key covers all three: /v1/chat/completions is the endpoint every chat model in the catalog serves, so the same anthropic/claude-sonnet-5 or openai/gpt-5.6-sol id works in every config below. The tool-calling row is where custom endpoints differ from built-in ones: in Copilot and Continue the tool flag is something you write, not something the extension detects, so a model that lists tool calling on its model page still needs the flag set before an agent will use it.

GitHub Copilot: BYOK through the Custom Endpoint provider

Copilot's Bring Your Own Key support lives in the Language Models editor. Run Chat: Manage Language Models from the Command Palette (or select the gear icon in the chat model picker), choose Add Models → Custom Endpoint, enter a group name, a display name, your Router One key and the API type, and VS Code opens chatLanguageModels.json. Make its models array match this:

[
  {
    "name": "Router One",
    "vendor": "customendpoint",
    "apiKey": "${input:routerOneApiKey}",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "anthropic/claude-sonnet-5",
        "name": "Claude Sonnet 5 (Router One)",
        "url": "https://api.router.one/v1/chat/completions",
        "toolCalling": true,
        "vision": true,
        "maxInputTokens": 120000,
        "maxOutputTokens": 8192
      }
    ]
  }
]

Three facts about the file that the docs spell out. The url is used as-is when it already contains /chat/completions, /responses or /messages; otherwise VS Code appends the path for the API type and inserts /v1 if it is missing — the docs recommend the full URL, which is what the example uses. apiKey stays an ${input:…} variable so the raw key never lands in the file, and you can change it later from the Language Models editor. And maxInputTokens plus maxOutputTokens must not exceed the model's context window, because VS Code treats their sum as the total; the numbers above are a conservative start that sits well inside the window shown on the model page — raise them once a test turn works.

Version and plan gating. The Custom Endpoint provider previewed in VS Code Insiders 1.121 (May 20, 2026) and shipped in Stable 1.122 (May 28, 2026); it replaces the deprecated OpenAI Compatible provider and the github.copilot.chat.customOAIModels setting, so if Add Models only lists the old provider, update VS Code before touching the JSON. BYOK models work without signing into a GitHub account and without a Copilot plan. On Copilot Business or Enterprise, the organization policy Bring Your Own Language Model Key in VS Code gates the feature — GitHub's April 2026 changelog says it is enabled by default and that an administrator can turn it off — so a missing Custom Endpoint option on a work machine is a question for the admin, not a config bug. BYOK usage is billed by the provider you configured, here your Router One wallet, and does not count against Copilot request quotas.

The gotchas. A newly added model may not appear until you restart VS Code. When you use agents in chat, only models with toolCalling: true are listed; the flag is your declaration, so choose a model whose page lists tool calling and confirm with one agent turn in the trace. Utility tasks — titles, commit messages, PR descriptions — stay on Copilot's built-in models unless you point chat.utilityModel and chat.utilitySmallModel at your Router One model or set chat.byokUtilityModelDefault to Main Agent Model; once you do, those background calls land on the same key. The full walkthrough, including the Responses and Messages API types, is on the GitHub Copilot setup page.

Continue: one entry in config.yaml

Continue is an open-source (Apache-2.0) assistant for VS Code and JetBrains whose whole model setup is a YAML file. Its openai provider takes an apiBase, which is the documented way to reach an OpenAI-compatible endpoint:

# ~/.continue/config.yaml — merge into models if the file already exists
name: Router One
version: 1.0.0
schema: v1
models:
  - name: Claude Sonnet 5 (Router One)
    provider: openai
    model: anthropic/claude-sonnet-5
    apiBase: https://api.router.one/v1
    apiKey: sk-your-api-key
    useResponsesApi: false
    roles: [chat, edit, apply]
    capabilities: [tool_use, image_input]

name, version and schema are required at the top level of a new file; an existing file keeps its own and gains the entry under models. useResponsesApi: false pins the entry to /v1/chat/completions — Continue otherwise defaults to the Responses endpoint for o-series and GPT-5 model names, and Chat Completions is the endpoint every catalog model serves. The Continue setup page shows the same block with placeholders and the merge rules.

The gotchas. capabilities overwrites Continue's autodetection, which the reference says is based on provider and model; a Router One id under the openai provider is exactly the "custom deployment" case the docs name, so declare tool_use yourself — the reference marks it "required for Agent mode" — and add image_input only if the model page lists image input. roles defaults to [chat, edit, apply, summarize]; autocomplete is its own role with its own request pattern, so add it only after testing that model in that role rather than assuming a chat success carries over. The older config.json format is deprecated.

Cline: three fields and an agent loop

Cline is an open-source (Apache-2.0) coding agent for VS Code that brings its own bill: you either buy Cline's usage-billed credits or plug in a provider key, and its "OpenAI Compatible" provider is the one that takes any base URL:

# Cline → Settings (gear icon) → API Provider: OpenAI Compatible
Base URL:  https://api.router.one/v1
API Key:   sk-your-api-key
Model ID:  anthropic/claude-sonnet-5

The docs call the Base URL "a crucial step" and note that it is never https://api.openai.com/v1; the Model ID is whatever id the provider serves, so copy it from /models verbatim. Under Model Configuration the documented fields are Max Output Tokens, Context Window size, Image Support, Computer Use, and input and output prices — fill in the context window from the model page and the prices from the catalog so Cline's own cost display lines up with the gateway trace. The Cline setup page has the field-by-field version.

The gotchas. There is no tool-calling flag to set: Cline drives its own agent loop from the extension with its own tool set, and its OpenAI Compatible model configuration has no toolCalling or capabilities equivalent, so the practical test is a small real task with approvals on. Cline asks before file writes and shell commands unless you enable auto-approve, which is worth leaving off until a model has earned it. "Model Not Found" from Cline usually means the id is not one the endpoint serves — copy it again from the catalog; the error codes page explains the gateway's 4xx bodies.

One key for all three — or better, one key each

The literal answer to "one key for all three" is yes: the same sk- key is accepted in chatLanguageModels.json, in config.yaml and in Cline's settings, and every call lands in the same wallet. The setup that pays off is one key per extension, created in Dashboard → API Keys and named for the tool:

• A hard cap per tool. Set maxSpend on each key — a small cap for a week's trial of the extension you know least — and a runaway agent session stops at the cap with a 402 while the wallet and the other two keys are untouched. rateLimit and tokenLimitTpm slow a retry loop mid-flight.
• Reading the three apart. Every request records the model, input and output tokens, cost, latency and status in Dashboard → Logs; filter by key and "was that expensive afternoon Copilot's agent or Cline?" is a fact, not a guess. Copilot's utility tasks, once pointed at your key, show up as many small calls on the Copilot key; Cline's approvals show up as one call per step. The cost tracking page lists what the ledger records, and per-key cost attribution shows the pattern with more tools.
• Switching models without touching the tool. Change id in Copilot's JSON, model: in Continue's YAML, or the Model ID field in Cline — no new account or billing relationship. Two pages that help with the choice: Claude Sonnet 5 vs GPT-5.4 and GPT-5.3 Codex Spark vs Claude Sonnet 5. Live per-model rates are on /models; pricing starts as low as 10% of official provider list prices (up to 90% off) on select models, and Pro/Max/Ultra plans sit alongside the wallet on pricing.
• Failover you do not configure. When an upstream route returns a retryable 5xx or a timeout, Router One may retry the same requested model on another healthy route. It never swaps in a different model, and a long agent session should still tolerate the occasional failed call.

Note the boundary: the agent loop, the approvals and the tool execution happen in the extension; Router One meters, traces and caps the model calls. What the gateway accepts on each endpoint is written down on the API compatibility fact sheet.

From mainland China

All three extensions install from the VS Code Marketplace; what needs a reachable endpoint is the model traffic, and that goes wherever the URL points. Router One's endpoints are directly reachable from the mainland with no VPN, and the wallet tops up with a card or Alipay through one hosted checkout, or with USDT/USDC on six chains (Tron, BSC, Ethereum, Polygon, Base, Arbitrum) — no US credit card required; paying for LLM APIs with Alipay has the steps. Copilot's inline suggestions and semantic search are GitHub-hosted and outside the gateway's scope, so expect those to behave as they do today. If an extension still reports 403 or "unsupported country, region, or territory" after the switch, the request has not actually reached the new URL — the region-block fix lists what to check. The Cursor page covers the same setup for the IDE fork, and the AI coding tools use case shows the whole toolbox on one wallet.

FAQ

Does GitHub Copilot BYOK need a Copilot subscription? No. The VS Code docs state that BYOK models work without signing into a GitHub account and without a Copilot plan, so a Router One key alone unlocks chat and agent sessions. A plan still buys the GitHub-hosted features: inline suggestions, semantic search, embeddings and the built-in utility models.

Which URL goes into each tool? Copilot takes the full endpoint, https://api.router.one/v1/chat/completions, in models[].url; Continue and Cline take the base URL, https://api.router.one/v1, and append /chat/completions themselves. All three send OpenAI Chat Completions, which every chat model in the catalog serves.

Can I use Claude models in GitHub Copilot through Router One? Yes. With apiType chat-completions, any Claude id from the catalog, such as anthropic/claude-sonnet-5, works on the /v1/chat/completions URL. The Messages API type with https://api.router.one/v1/messages is an alternative for Claude-family models; VS Code then sends x-api-key instead of a Bearer header, and Router One accepts both.

Why does my model disappear when I switch to an agent? In Copilot, only models with toolCalling: true are listed when you use agents; in Continue, Agent mode needs capabilities: [tool_use]. Both are declarations you write in the config, not capabilities the extension detects. Set the flag for a model whose page lists tool calling, restart VS Code if the model is missing from the picker, and check one agent turn in the trace.

Do I need three API keys? One key works in all three tools. One key per tool, funded by the same wallet, is the recommended setup: each key carries its own maxSpend cap, and Dashboard → Logs filters by key, so per-tool spend is a fact rather than an estimate.

Next steps

• Copilot, step by step: GitHub Copilot + Router One
• Continue and Cline: Continue setup and Cline setup; the same key also fits Roo Code and Kilo Code
• How the endpoint behaves: OpenAI-compatible API and the tool calling guide
• Editor versus terminal: Cline vs Cursor vs Claude Code and OpenCode vs Claude Code vs Codex CLI
• Live rates and plans: models and pricing

Create three keys at router.one, cap each one, and let a week of real work in each extension make the call.