Continue is a common open-source AI coding assistant for VS Code and JetBrains. It supports bringing your own model key and can connect to third-party gateways through the OpenAI-compatible protocol. For teams in mainland China, pointing Continue at a unified gateway can lock down the access path, centralize billing, and make it easy to switch between models.

In 2026, however, Continue was acquired by Cursor, and the official repository is no longer actively maintained. It can still be installed and used, but the configuration method, available features, and long-term risk need to be reassessed. This article follows the order of installation, preparation, configuration, verification, and team rollout, and gives practical integration instructions.

Status note: In June 2026, Continue was acquired by Cursor. The official repository has been set to read-only and is no longer actively maintained; the hosted Hub and login service have also been shut down. The extension can still be installed and used, but versions are essentially frozen at the pre-acquisition state, and teams should factor maintenance risk into their evaluation.

Trademark note: Continue is a trademark of Continue Dev, Inc.; Cursor is a trademark of Anysphere, Inc. This article is for technical explanation only, and we have no affiliation with or agency relationship with those companies. Features, interfaces, and billing terms are subject to the official pages and the currently installed version.

1. How Continue still works in 2026

After the acquisition, the biggest change is on the cloud side. Continue's Hub used to host shared assistants, configuration blocks, and team synchronization, and login depended on it as well. With the Hub offline, those capabilities are no longer available, and any remote uses: references in the configuration may fail to resolve.

Local capabilities remain: the extension can be installed, config.yaml is still read, and once you supply your own key it can call OpenAI-compatible endpoints, the Anthropic protocol, or local models. It has gone from an active project with cloud collaboration to a final local-only version that still works.

That leads to two judgments. Teams already using it can continue, but should freeze the version, back up configurations, and prepare a replacement. Teams planning a new rollout should list "no longer maintained" as a selection criterion, rather than looking only at whether it is open source or supports multiple models.

2. Install on VS Code and JetBrains

The VS Code path is the most direct:

  1. Open VS Code and press Cmd/Ctrl + Shift + X to open the Extensions panel.
  2. Search for Continue, confirm that the publisher is Continue, and click Install.
  3. After installation, a Continue icon appears in the left sidebar; you can drag it to the right sidebar so you can ask questions while writing code.
  4. Press Cmd/Ctrl + L to open Chat, or select code and press the same shortcut to bring it into the conversation.

JetBrains deserves a second look. As of 2026, Continue's official README recommends that JetBrains users switch to Continue CLI; the final plugin version is distributed through GitHub Releases, and whether it is visible in the plugin marketplace varies by region and version. Teams with an existing plugin can keep using it, but new projects should not be bet on a plugin that no longer receives updates.

The CLI is the safer alternative path; it reads the same config.yaml as the IDE extension:

# Requires Node.js 20 or later
npm install -g @continuedev/cli
cn --version
cn --config ~/.continue/config.yaml

3. Prepare a key, Base URL, and model ID

Before configuring, prepare three things: a gateway key, a compatible endpoint, and an exact model ID.

  1. Open the ZSQH AI Gateway sign-up page, register, and sign in to the console.
  2. Go to the "API Keys" page and create a key. Name it with the user and device, for example continue-zhang-macbook.
  3. Set a spending cap and expiration as needed. Do this for personal accounts too, to avoid unexpected usage.
  4. Copy the key and save it in a password manager. The console usually shows it in full only once.
  5. Open model pricing and copy the model ID you want to use. Models and prices change; use what the page currently shows.

Use this set of values during configuration:

Base URL: https://ai.zhongshangqihang.com/v1
API Key:  sk-... (create it in the console; store it in .env or a password manager)
Model:    use the model ID currently shown on the model pricing page

Fill the Base URL up to /v1. Do not enter the website homepage, and do not append /chat/completions yourself, or the client will add it again and produce a duplicated path.

4. Write config.yaml: provider and models

Continue's global configuration lives at ~/.continue/config.yaml (macOS/Linux) or %USERPROFILE%\.continue\config.yaml (Windows). When config.yaml exists, it is loaded in preference to the older config.json; do not mix the two formats.

Avoid writing the key directly into YAML. First put one line in ~/.continue/.env, without quotes around the value:

ZSQH_API_KEY=sk-your-gateway-key

Then reference it in config.yaml:

name: zsqh-continue
version: 0.0.1
schema: v1

models:
  - name: ZSQH primary model
    provider: openai
    model: YOUR_MODEL_ID
    apiBase: https://ai.zhongshangqihang.com/v1
    apiKey: ${{ secrets.ZSQH_API_KEY }}
    roles: [chat, edit, apply]
    capabilities: [tool_use]

  - name: ZSQH autocomplete model
    provider: openai
    model: YOUR_FIM_MODEL_ID
    apiBase: https://ai.zhongshangqihang.com/v1
    apiKey: ${{ secrets.ZSQH_API_KEY }}
    roles: [autocomplete]

What the fields mean:

  • provider: openai means requests are sent using the OpenAI-compatible protocol; third-party compatible gateways also use this value.
  • apiBase overrides the default address; fill it up to /v1.
  • apiKey reads from .env via ${{ secrets.NAME }}.
  • roles determines which features the model handles; the default is [chat, edit, apply, summarize].
  • capabilities: [tool_use] lets Agent mode call tools; add it only when the gateway model actually supports tool use.

The autocomplete model is optional. Configure it only when the pricing page offers a model that supports FIM or a completion endpoint; otherwise remove it, or use a local Ollama model for completion while chat and edit still go through the gateway.

5. Verify chat, edit, and autocomplete

After saving the configuration, Continue usually reloads automatically; if you changed .env, restart the IDE as the official FAQ recommends. Then verify in this order:

  1. Open Chat and explicitly select the model you just configured in the model selector; do not use auto-select.
  2. Send a short request, such as "explain this function in the current file", and confirm that it returns normally.
  3. Open the gateway console's usage or request log and confirm a record with the same time, model, and key.
  4. Select a block of code, press Cmd/Ctrl + I to open Edit, ask for a small change, then accept or reject the diff.
  5. Create a new file and type a comment or the start of a function to test Tab autocomplete; if nothing happens, first check whether the autocomplete model is an FIM model.
  6. If tool_use is configured, ask the Agent to read a file and suggest changes, and confirm that tool calls work.

Do not rely only on whether the editor replies; use the gateway log to confirm that requests really go through the custom API.

6. How model roles divide the work

Feature Role Model requirement Notes
Chat chat General instruction-following Sidebar Q&A, code explanation
Edit edit, apply Code understanding and precise changes Select code and press Cmd/Ctrl + I
Autocomplete autocomplete FIM-trained, low latency Chat models usually complete poorly
Agent chat plus tool_use Supports tool calling Must be declared in capabilities
Codebase retrieval embed Embedding model Affects @Codebase availability

One model can handle chat, edit, and apply at the same time; you do not need a separate entry for every role. What really needs separate configuration is autocomplete: it fires frequently, and its latency and FIM requirements are completely different from chat. Setting a chat model as autocomplete commonly results in slow, long, or missing completions.

Embedding and reranking are optional capabilities; whether they are available depends on the model and the API documentation.

7. Common limitations and pitfalls

  • Remote uses: references may stop working. After the Hub shutdown, shared configuration blocks no longer resolve; replace them with inline provider, model, and apiKey.
  • Autocomplete is not automatic. The model needs FIM or completion support; an ordinary Chat Completions model may not be suitable.
  • The context length and capabilities of custom models are not detected automatically. Declare them manually with defaultCompletionOptions.contextLength and capabilities when necessary.
  • Agent mode depends on tool calling. If the gateway only supports chat endpoints, ordinary conversation works but the Agent may fail.
  • The project is no longer actively maintained. IDE upgrades, system certificate changes, and dependency updates may all cause compatibility issues, so teams should keep a rollback plan.
  • Base URL and model ID are the two most common error sources. The former has an extra or missing /v1; the latter differs in case or version suffix.
  • IDE extensions usually cannot read environment variables exported in a terminal. Put the key in a .env file rather than only in shell configuration.

8. Team rollout checklist

  1. Freeze a verified version and save the VSIX, JetBrains plugin, or CLI installer so the same version can be found later.
  2. Create gateway keys per person and per device, set spending caps and expiration, and do not use one shared key for everyone.
  3. Put the config.yaml template in an internal repository, use ${{ secrets.NAME }} placeholders, and add .env to ignore rules.
  4. Start with three to five developers for a two-week pilot, recording request success rate, average latency, completion acceptance, and per-person spend.
  5. Maintain a model mapping table: purpose, model ID in the configuration, corresponding gateway model, and fallback model on failure.
  6. Make Continue's maintenance freeze a quarterly review item, compare actively developed alternatives in advance, and keep a migration path.
  7. When a member leaves, changes machines, or a project ends, disable the corresponding key the same day and clean up the local .env.

For cost, run real requests for a week first, then estimate using current data from model pricing. Prices change with providers; do not budget from old screenshots.

9. FAQ

Can Continue still be installed after the acquisition?

Yes. The VS Code extension is still offered in the marketplace, and the CLI can be installed; for the JetBrains plugin, the official README already recommends switching to CLI. Being installable is not the same as being maintained, and new projects should assess the long-term risk.

How far should the Base URL go?

Use https://ai.zhongshangqihang.com/v1. Do not enter the website homepage, and do not append /chat/completions, or you are likely to get duplicated paths or a 404.

Why does chat work but Tab autocomplete does not?

Autocomplete needs a separate autocomplete model, and the model must support FIM or a completion endpoint. A chat model may converse well yet still not complete. First confirm whether the gateway offers a suitable completion model.

Can one key serve multiple models?

Yes. The key is an authentication credential; the model is determined by the model field. Multiple model entries can reuse the same key; if the team needs separate accounting, split keys by role or project.

Should JetBrains users install the plugin or use the CLI?

If the team already has a working plugin, it can continue to be used, but freeze the version. For new environments, prefer Continue CLI as the official README recommends; it reads the same config.yaml and carries lower maintenance risk.

Next steps

First create a test key at the ZSQH AI Gateway, run through Chat, Edit, and autocomplete with the examples in this article, and then distribute the configuration template to the team. Model availability and current prices are subject to model pricing.

Related reading: