Use Any AI Model in Continue.dev (Claude, GPT & 50+)

I've set up Continue.dev on every machine I write code on, and I've watched plenty of other developers set it up too. Almost all of them use it at about 20% of what it can do.

It's not the extension's fault. Continue is genuinely excellent. The problem is how we configure it: paste in one provider key, pick one model, never touch the config again. Six months later you're still on a model that's been outclassed twice, and switching feels like a chore because it means a new API key, a new dashboard, and a new bill.

That's a setup choice, not a limitation. And you can fix it in about five minutes.

Here's how I wire Continue.dev to a single OpenAI-compatible endpoint that gives me Claude, GPT, Gemini, DeepSeek, and 50+ other models. One key, one bill, no lock-in.

What Continue.dev actually is

Continue is an open-source autocomplete and chat extension for VS Code and JetBrains. Think of it as the open chassis. It handles the editor integration, the chat sidebar, inline edits, and tab autocomplete, but it stays deliberately model-agnostic. You bring the brain.

That bring-your-own-model design is Continue's best feature. It's also where people get stuck, because the obvious move is to "pick a provider." The better move is to pick one endpoint and then pick models freely behind it.

The real problem: one extension, a drawer full of API keys

Here's what your setup probably looks like after a while:

• An Anthropic key for Claude
• An OpenAI key for GPT
• A Google AI Studio key for Gemini
• Maybe an OpenRouter key for everything else

Four billing relationships, four dashboards, four sets of rate limits. All to drive one extension. And every time a strong new model drops, which is roughly weekly now, you either ignore it or go sign up for yet another provider.

The friction is small enough to put up with and big enough that you stop experimenting. So you settle. That's the real cost. Not the dollars, but the models you never bother to try.

The fix: one OpenAI-compatible endpoint for every model

Continue supports any provider that speaks the OpenAI API format. You set provider: openai, point apiBase at the endpoint, drop in a key, and name a model. That's the whole contract.

So instead of four providers, use one OpenAI-compatible gateway that routes to all of them. I use AskCodi's gateway at https://api.askcodi.com/v1. It's OpenAI-compatible and routes a single key to OpenAI, Anthropic, Google, xAI, Fireworks, OpenRouter, and more. That's 50+ models, pay-as-you-go, with one key in your config. If that sounds like what you want, grab a key and follow along.

Step-by-step: add 50+ models to Continue.dev

1. Get an AskCodi key

Sign up at askcodi.com and create an API key. It's free to start and billed by usage (the base rate is around $1.25 per 1M tokens), so you're not signing up for a subscription just to try a model.

2. Open Continue's config.yaml

In VS Code, open the Continue panel, click the gear icon, and edit your assistant config. Newer Continue versions use config.yaml. The older config.json still works too; if you're on it, the YAML migration guide walks you across.

3. Add AskCodi as an OpenAI-compatible provider

Add one model block per model you want. The pattern is identical every time. Only name and model change:

models:
  - name: Claude Sonnet (AskCodi)
    provider: openai
    apiBase: https://api.askcodi.com/v1
    apiKey: YOUR_ASKCODI_KEY
    model: claude-sonnet-4-5
    roles:
      - chat
      - edit
      - apply

  - name: GPT (AskCodi)
    provider: openai
    apiBase: https://api.askcodi.com/v1
    apiKey: YOUR_ASKCODI_KEY
    model: gpt-5
    roles:
      - chat
      - edit

That's it. The same apiBase and apiKey serve every model. To add Gemini or DeepSeek, copy a block and change the model line.

4. Pick a model per role

Continue lets different models handle different jobs through roles. Here's the pattern I land on: a strong reasoning model for chat and edit, and a small, fast model for autocomplete. This is the part people get wrong. You really don't want a frontier model firing on every keystroke. It's slow, it's wasteful, and you'll feel the lag.

  - name: Fast Autocomplete (AskCodi)
    provider: openai
    apiBase: https://api.askcodi.com/v1
    apiKey: YOUR_ASKCODI_KEY
    model: gpt-4o-mini
    roles:
      - autocomplete

5. Find the exact model IDs

Model identifiers change as providers ship new versions, so don't guess. List what your key can actually reach:

curl https://api.askcodi.com/v1/models \
  -H "Authorization: Bearer YOUR_ASKCODI_KEY"

Use the IDs from that response verbatim in your model: fields. If a name is wrong, Continue surfaces a 404 from the gateway, which is your cue to re-check the list.

Tips once it's working

• Switch models mid-task. Use the model dropdown in the Continue chat box to jump between Claude and GPT in the same conversation. It's the fastest sanity check I know. If two frontier models agree, you can trust the answer. If they disagree, you've just found the hard part of the problem. (We pushed on this in GPT-5 vs Claude Sonnet.)
• Control cost by role. Autocomplete burns the most requests, so keep a cheap model there and save the expensive ones for chat and multi-file edits.
• Keep one config across machines. Because everything routes through one endpoint, your config.yaml is portable. No per-machine key sprawl, no re-auth dance on a new laptop.

Beyond the editor: when you want an agent, not just autocomplete

Continue is great for in-editor help: autocomplete, ask-about-this-function, inline edits. But some work is bigger than one file. "Implement this feature across the codebase, write the tests, and don't break the build" is a different kind of job.

That's where I reach for AskCodi Desktop instead. It's a local-first AI engineering team that runs across isolated git worktrees, using the same Claude or ChatGPT plan you already pay for. (If you want a feel for agent-style workflows first, see Codex CLI vs Claude Code.) The two tools pair nicely. Continue handles the fast in-flow edits, and Desktop takes the heavy builds, like the kind of multi-file Next.js dashboard that touches a dozen files at once.

The point

Continue's whole pitch is that you're not married to a model. The setup above makes that real. One OpenAI-compatible endpoint, one key, and the freedom to use whatever model is best this week without ever touching your provider accounts.

Point apiBase at https://api.askcodi.com/v1, grab a free AskCodi key, and stop settling for the model you happened to configure first.

FAQ

Is Continue.dev free? Yes. Continue is open source and free to install. You only pay for the models it calls, which is exactly why a pay-as-you-go key keeps the cost small and predictable.

What models can I use in Continue.dev? Anything behind an OpenAI-compatible endpoint. Through the AskCodi gateway that's 50+, including Claude, GPT, Gemini, and DeepSeek, all from the one apiBase and key you set above.

How do I add an API key to Continue.dev? Drop it in the apiKey field of each model block in config.yaml (see step 3). With AskCodi you reuse the same key for every model, so there's only one to keep track of.

Continue.dev or GitHub Copilot? Copilot locks you to its own models. Continue lets you choose, which is the whole point here: run the best model for each job and switch the moment a better one ships.

Sources: Continue.dev OpenAI provider docs, Continue.dev config.yaml reference.