Continue

What it is and how it works

Continue is an open-source coding assistant that lives inside VS Code and JetBrains IDEs as an extension/plugin, rather than as a standalone application or terminal tool. Architecturally it's a client that sits between your editor and a model backend you configure yourself: it can talk to hosted APIs (OpenAI, Anthropic, Mistral, Gemini, etc.) or to a local inference server such as Ollama, LM Studio, or any OpenAI-compatible endpoint (vLLM, llama.cpp server, LocalAI). The project draws a hard line between "the tool" and "the model" — Continue ships no weights and bundles no default provider; every install starts with an empty config.yaml (or the older config.json) that you populate with model blocks for chat, autocomplete, embeddings, and reranking, each of which can point at a different backend.

The extension is built around three functional modes that share the same config. Chat is a sidebar conversation with the codebase, where Continue indexes the open workspace (using an embeddings model you specify) to pull relevant context into prompts via @ mentions of files, folders, or symbols. Autocomplete is inline, tab-to-accept completion similar to Copilot, driven by a separate (usually smaller/faster) model — this is the mode most commonly pointed at a local Ollama model like a Qwen2.5-Coder or a StarCoder variant, since latency matters more than raw capability for ghost-text suggestions. Agent mode is the newer addition, giving the model tool-calling access to run terminal commands, edit multiple files, and iterate — positioning Continue against Cline, Cursor's agent mode, and Aider rather than just against Copilot-style autocomplete tools.

Because model selection is entirely external, Continue's own codebase is really an orchestration and context-management layer: prompt templates per model family, a retrieval/indexing pipeline for the workspace, a diff-application engine for edits, and a config schema that lets teams check a shared config.yaml into version control so an entire team gets the same model routing and system prompts.

Deployment patterns

The dominant solo pattern is a laptop or workstation running Ollama (or LM Studio) locally, with Continue's config.yaml pointing chat and autocomplete at different local models — commonly a mid-size instruct model for chat/agent work and a small, fast completion-tuned model for inline autocomplete, since the two modes have very different latency budgets. This is the setup Continue is most associated with in the local-AI community: it's frequently cited as the reference client for "I want Copilot but fully offline against my own Ollama instance."

A second common pattern runs the model on a separate GPU box — a homelab server, a workstation with a bigger card, or a rented GPU instance — with Ollama or vLLM exposed on the LAN, and Continue configured with that machine's IP as the API base. This decouples the editor (which can run on a thin laptop) from inference (which needs the GPU), and is popular among people who have one beefy machine and want to code from anywhere on their network.

For teams, Continue supports an organization/hub layer (continue.dev's hub) where shared configs, custom system prompts, and approved model lists can be distributed so every developer's IDE uses the same assistants and the same (often self-hosted, for compliance reasons) backend. Because config is just YAML, it also works fine checked into a repo's .continue directory with no hub involvement — simpler teams just commit the config file.

How it compares

Against GitHub Copilot, Continue's core differentiator is openness and backend flexibility: Copilot is a closed pipeline to Microsoft/OpenAI-hosted models with no local option, while Continue can run entirely offline against Ollama with zero API cost. The tradeoff is polish — Copilot's autocomplete latency and acceptance-rate tuning benefit from a single, tightly optimized hosted model, whereas Continue's quality varies with whatever local model you've chosen and how well you've tuned context settings.

Against Cline, which is also open-source, VS-Code-native, and BYO-model, the comparison is closer. Cline has leaned harder into autonomous agent workflows (plan/act modes, more aggressive multi-file editing) and has a reputation for a more refined agent UX, while Continue historically built its reputation on the chat+autocomplete combo first and added agent mode later — this is reflected directly in the tool's own listed con of less-polished UX relative to Cline. Continue's JetBrains support is a real differentiator here, since Cline is VS Code (and forks) only.

Against Cursor, the difference is architectural: Cursor is a full VS Code fork with deep, proprietary editor-level integration and a polished first-party experience, but it's not open-source and pushes users toward its own hosted models. Continue trades some of that integration depth for being a normal extension you can install into your existing VS Code or JetBrains setup without switching editors, and for being fully auditable/self-hostable end to end.

Best use cases and honest limitations

Continue is the right choice for developers who want a genuinely local-first, provider-agnostic assistant and are willing to spend time tuning config.yaml — particularly JetBrains users, since open-source agent tooling for JetBrains IDEs is thin and Continue is one of the few credible options there. It's also a good fit for teams that need to standardize on a self-hosted or compliance-approved model and want that enforced via a shared config rather than a vendor's hosted stack.

It's a weaker fit for users who want a polished, zero-configuration experience out of the box — the flexibility that makes it powerful (any model, any provider, any mode) also means first-run quality depends entirely on your model choices, and the agent-mode UX genuinely lags Cline and Cursor in refinement. Users chasing the most autonomous, aggressive multi-file agent behavior will likely be happier with Cline or Cursor; users who just want the best possible cloud-model coding experience with no setup will likely prefer Copilot or Cursor. Continue earns its place specifically at the intersection of "I want this in my IDE," "I want to choose or self-host the model," and "I'm fine configuring it myself" — which is a real and fairly large niche in the local-AI operator community, but not the majority use case for casual users.

Install as a VS Code or JetBrains extension. VS Code: Extensions panel (Ctrl+Shift+X), search "Continue", install. JetBrains: Plugins marketplace, search "Continue", install. Continue is an open-source AI code assistant that works as an IDE extension, connecting to any LLM provider (cloud API or local). After install, open the Continue sidebar (Ctrl+L / Cmd+L or the Continue icon). On first launch, Continue walks through model configuration: pick a provider (Anthropic, OpenAI, local, Ollama, etc.), enter API key if needed, and select a chat model. For local models via Ollama: select "Ollama" as provider, set model to llama3.2, and ensure ollama serve is running. The chat interface supports @file, @folder, and @code context references — drag files into chat for context. Tab autocomplete: enable in Continue settings (powered by smaller, faster models — Starcoder, CodeLlama, Codestral). Verify: type a comment like // create a function that sorts by date and press Tab — Continue inserts completion. Time-to-first-response: ~5 seconds for chat, ~200ms for tab completions. All configuration lives in .continue/config.json (per-project) or global settings.

Best for: developers who want provider flexibility — use local models for tab completions and cloud models for complex chat within the same tool, teams with multiple LLM providers or model preferences that need a single consistent IDE extension, VS Code + JetBrains dual-IDE users who want the same AI tool across both, open-source shops that prioritize self-hosted code assistant tooling, developers who prefer extensible, config-file-driven tools over managed platforms. Not suited for: developers who want zero-config setup (use Cursor or GitHub Copilot), autonomous agentic coding where the AI creates files and runs commands (use Cline or Claude Code), non-developer team members (Continue assumes IDE literacy).

Use Continue when you want an open-source, provider-flexible AI assistant that works across VS Code and JetBrains — connect any LLM (cloud or local), any model, any tab-completion backend. Switch to Cursor when you want a fully integrated AI-native IDE with polished inline editing and agent mode — Continue is an extension, Cursor is a platform. Use Cline when you want autonomous agentic coding inside VS Code — Continue is assistive (chat + completions), Cline is agentic (file creation, terminal execution, autonomous loops). Use GitHub Copilot for the simplest "just works" completions across every IDE — Continue requires initial model configuration. Use Aider for terminal-based pair programming with git diff workflow — Continue is IDE-integrated. Continue's key advantage: provider independence. You can switch from OpenAI to Anthropic to local Llama without changing tools. Its weakness: setup friction compared to managed solutions.

Problem: Tab completions never appear or are extremely slow (>1 second). Fix: Continue's tab model is configured separately from the chat model. In config.json, check the "tabAutocompleteModel" object has correct provider and model settings. Tab autocomplete needs low latency — use a smaller model (Starcoder 3B, Codestral 7B) locally or a fast API. If using a local model, ensure it's loaded and responsive before expecting completions. Problem: @file references return "No context found." Fix: Continue indexes files referenced with @file using the file path relative to the workspace root. If the file path includes spaces or special characters, wrap in quotes: @"file with spaces.ts". The file must exist on disk. For large files, Continue may truncate context — it respects a configurable max-chars limit. Problem: Chat model switch doesn't take effect. Fix: Continue caches model config at startup. After changing config.json, reload: Cmd+Shift+P → "Continue: Reload Config." The chat interface shows the active model — verify the switch took effect. Some model names differ between providers ("claude-4" vs "claude-sonnet-4-20250514"). Check provider docs for exact model IDs.