> Markdown mirror of https://router.one/blog/github-copilot-byok-vs-continue-vs-cline for AI assistants and crawlers. Router One is an OpenAI-compatible LLM API gateway.
> Published: 2026-09-07 · Author: Router One Team

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

_GitHub Copilot BYOK vs Continue vs Cline in VS Code: license, config, protocol, tool calling and China access, plus one Router One key for all three._

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](https://router.one/blog/cline-vs-cursor-vs-claude-code) and [OpenCode vs Claude Code vs Codex CLI](https://router.one/blog/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

|  | GitHub Copilot (BYOK) | Continue | Cline |
| --- | --- | --- | --- |
| License and price of the extension | Proprietary. Individual Free, Pro, Pro+ and Max plans; Business and Enterprise seats. BYOK works without a plan | Open source (Apache-2.0). The extension is free; the model bill goes to the provider you configure | Open source (Apache-2.0). The extension is free; bring a provider key, or buy Cline's own usage-billed credits |
| What runs on your key | Chat and agent sessions in the Chat view, plus utility tasks if you opt in. Inline suggestions, semantic search and embeddings stay on GitHub's service | Every role you assign to the model: chat, edit, apply, summarize. Autocomplete is a separate role you assign only after testing it | Everything Cline does — there is no vendor-side model unless you choose the Cline provider |
| Config surface | Language Models editor → Add Models → Custom Endpoint, which writes `chatLanguageModels.json` | One entry under `models` in `~/.continue/config.yaml` | Three fields in the settings panel: Base URL, API Key, Model ID |
| Protocol sent | `apiType: "chat-completions"` → OpenAI Chat Completions (Responses and Messages selectable per model) | `provider: openai` with `useResponsesApi: false` → Chat Completions | OpenAI Compatible provider → Chat Completions |
| Model id | `models[].id`, sent verbatim | `model:`, sent verbatim | Model ID field, sent verbatim |
| Tool calling and agents on a custom endpoint | Only models with `toolCalling: true` are listed when you use agents — a flag you declare | Agent mode needs `capabilities: [tool_use]`, which overrides autodetection — declare it for a custom endpoint | No tool-calling switch among the documented fields; Cline runs its own agent loop, and a test task tells you whether a model keeps up |
| From mainland China | Marketplace install; model traffic goes wherever the URL points | Same | Same |

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](https://router.one/models) 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](https://router.one/models) 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:

```json
[
  {
    "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](https://router.one/integrations/github-copilot).

## 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:

```yaml
# ~/.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](https://router.one/integrations/continue) 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:

```text
# 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](https://router.one/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](https://router.one/integrations/cline) 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](https://router.one/llm-api-error-codes) 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](https://router.one/llm-cost-tracking) lists what the ledger records, and [per-key cost attribution](https://router.one/blog/track-llm-api-costs-per-key) 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](https://router.one/models/compare/claude-sonnet-5-vs-gpt-5-4) and [GPT-5.3 Codex Spark vs Claude Sonnet 5](https://router.one/models/compare/gpt-5-3-codex-spark-vs-claude-sonnet-5). Live per-model rates are on [/models](https://router.one/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](https://router.one/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](https://router.one/facts/api-compatibility.md).

## 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](https://router.one/alipay-llm-api) 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](https://router.one/unsupported-country-region-territory) lists what to check. The [Cursor page](https://router.one/cursor-china) covers the same setup for the IDE fork, and the [AI coding tools use case](https://router.one/use-cases/ai-coding-tools) 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](https://router.one/integrations/github-copilot)
- Continue and Cline: [Continue setup](https://router.one/integrations/continue) and [Cline setup](https://router.one/integrations/cline); the same key also fits [Roo Code](https://router.one/integrations/roo-code) and [Kilo Code](https://router.one/integrations/kilo-code)
- How the endpoint behaves: [OpenAI-compatible API](https://router.one/openai-compatible-api) and the [tool calling guide](https://router.one/llm-tool-calling)
- Editor versus terminal: [Cline vs Cursor vs Claude Code](https://router.one/blog/cline-vs-cursor-vs-claude-code) and [OpenCode vs Claude Code vs Codex CLI](https://router.one/blog/opencode-vs-claude-code-vs-codex-cli)
- Live rates and plans: [models](https://router.one/models) and [pricing](https://router.one/pricing)

Create three keys at [router.one](https://router.one/), cap each one, and let a week of real work in each extension make the call.

## See also

- Canonical page: https://router.one/blog/github-copilot-byok-vs-continue-vs-cline
- Claude Code China: https://router.one/claude-code-china
- All blog posts: https://router.one/blog
- Models and per-model token rates: https://router.one/models (markdown: https://router.one/models.md)
- Pricing: https://router.one/pricing
- API docs (markdown): https://router.one/docs.md
- Company facts: https://router.one/facts/company.md