Continue
The open-source AI coding assistant — bring any LLM, run it anywhere
AICoding score
ollama pull qwen2.5-coder:1.5b llama3.1:8b nomic-embed-text local models · $0 name: My Local + Cloud Config
version: 1.0.0
schema: v1
models:
- name: Llama 3.1 8B # chat + edit
provider: ollama
model: llama3.1:8b
apiBase: http://localhost:11434
roles: [chat, edit, apply]
- name: Qwen Coder 1.5B # tab autocomplete
provider: ollama
model: qwen2.5-coder:1.5b
roles: [autocomplete]
- name: Claude Sonnet # cloud, BYOK
provider: anthropic
model: claude-sonnet-4-20250514
roles: [chat, edit]
context:
- provider: codebase # @codebase RAG
- provider: docs
- provider: terminal @codebase how does the auth middleware validate tokens?
AuthMiddleware.verify() reads the JWT in headers/auth.ts:42, delegates signature checks to utils/jwt.ts, and short-circuits on missing claims. 3 call sites in routes/. Want me to add a test for the expired-token path?
A Continue setup: pull local models, declare them in one config.yaml (plus a cloud model via your own key), and ask @codebase questions grounded in your real code — all free, all auditable.
Quick Verdict
8.0 / 10 — The best open-source, bring-your-own-model assistant in 2026. If you want full control over which LLM powers your autocomplete and chat, the ability to run everything offline on Ollama, and genuine JetBrains + VS Code parity, nothing else is both free and this flexible.
Continue is an open-source AI coding assistant you add to your existing editor — VS Code, JetBrains or Neovim — rather than a new IDE or a hands-off agent. Its whole design is model freedom: connect any LLM (local Ollama, or cloud OpenAI/Anthropic/Gemini via your own key) in a single config.yaml, and pay only the provider — or nothing with a local model. Tab autocomplete, @codebase-aware chat, slash commands and MCP make it genuinely useful day to day.
The honest trade-offs: it needs setup (you pick and configure the model), autocomplete quality tracks the model you choose, and its autonomous agent mode is lighter than Cursor's or Cline's. For control, privacy and cost, Continue remains the open-source default.
Use Continue if…
- You want to bring your own model and avoid vendor lock-in
- You need local / offline coding (privacy, air-gapped)
- You use both VS Code and JetBrains and want parity
- You want a free assistant with no per-seat subscription
Skip Continue if…
- You want zero-setup plug-and-play — Copilot is easier
- You need the most mature autonomous agent — Cursor/Cline win
- You need enterprise compliance certs (SOC 2) — Cody fits better
- You require a guaranteed-actively-maintained project
Core Features
Bring your own model (BYOK)
Continue ships no model — you declare any LLM in a single config.yaml: local Ollama/LM Studio, or cloud OpenAI, Anthropic, Gemini, xAI, OpenRouter via your API key. Chain a fast local model for tab completion and a frontier model for chat, switch per task, and pay only your provider. No vendor lock-in, no markup.
Tab autocomplete
Inline ghost-text completions as you type, comparable to Copilot when backed by a strong model. You choose the autocomplete model — a small local coder model keeps it fast and free, or a cloud model raises quality. Tune debounce, max tokens and temperature per your hardware.
Context-aware chat (@codebase)
Ask questions about your whole project; @codebase indexes and retrieves relevant files via embeddings, while @docs, @terminal, @git and @folder inject the right context. Answers reference real code rather than guessing, which is what makes it genuinely useful beyond a generic chatbot.
Slash commands & custom prompts
Predefined prompts like /edit, /comment, /share and your own team commands (test generation, refactor, review) turn recurring workflows into one keystroke. Combine with custom system prompts and coding rules so every response matches your team's conventions.
Local-first & private
Run the entire assistant against a local model — no code leaves your machine, ideal for proprietary, regulated or air-gapped work. Even on cloud models, Continue is open source and auditable, so you can verify exactly what it sends to the provider.
MCP & custom context providers
Extend Continue with Model Context Protocol servers (databases, logs, internal docs as tools) and custom context providers, so the assistant sees the systems your team actually works in. Config lives in one file you can version-control across the team.
Integrations & Ecosystem
IDEs
First-class extension: tab autocomplete, chat sidebar, @codebase, and slash commands. The most popular way to run Continue.
Marketplace → Continue Genuine parity across IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider and more — same features, no feature lag versus VS Code.
Plugins → Continue Continue works in Neovim for terminal-first developers who want the same assistant without leaving the editor.
plugin Local Models
Run autocomplete, chat and @codebase fully offline. Point apiBase at http://localhost:11434 and pull coder + chat + embeddings models. Zero cost, zero data egress.
apiBase: localhost:11434 Alternative local-server path; expose a model over its OpenAI-compatible endpoint and connect Continue to it for private inference.
OpenAI-compatible endpoint Cloud Providers
Bring your own key for GPT, Claude, Gemini or xAI models. Billed by the provider at provider rates — no Continue markup, no lock-in.
connect API key Route through OpenRouter or any OpenAI-compatible endpoint to access a wide model catalog from one key.
connect API key Context & MCP
@codebase, @docs, @terminal, @git, @folder inject the right project context into prompts so answers reference real code.
config: context Extend Continue with Model Context Protocol servers — databases, logs and internal docs become tools the assistant can use.
add MCP server Pricing
The VS Code extension and JetBrains plugin are free and Apache-2.0. Connect any model — a local Ollama model costs nothing, or a cloud key is billed by that provider at provider rates. Continue itself never charges for the connection.
- Full assistant, free
- Any LLM (BYOK)
- Local models (Ollama)
- VS Code + JetBrains
Managed sharing of assistant configurations — prompts, context rules and model settings — across a team, plus analytics and SSO. Pricing has shifted through 2026, so verify the current rate on continue.dev before relying on it. The free extension still works without Hub.
- Shared configs
- Team analytics
- SSO (reported)
- Optional
On-premise or self-hosted deployment, custom integrations and SLA/audit options for organizations with compliance requirements. Because the core is open source, many teams self-host Continue against local models at no licensing cost and add enterprise controls themselves.
- On-prem option
- Custom integrations
- Audit controls
- Open-source base
* The extension is free and open source (Apache-2.0). With a local Ollama model your recurring cost is $0; cloud models are billed by the provider at provider rates. Continue Hub (Teams) pricing has shifted through 2026 — verify the current rate on continue.dev. Enterprise / self-host is custom.
Continue vs The Field
Continue vs Cursor
Editor-native agent vs drop-in assistantCursor is a VS Code fork with the most mature agentic experience (Composer multi-file edits, polished UX) at $20/mo. Continue drops into your existing VS Code or JetBrains editor, stays free with your own model, and keeps local/offline use — but its autonomous agent mode is less mature. Pick Cursor for the immersive agent; pick Continue to keep your editor and your model with a $0 floor.
Cursor for agent · Continue for controlContinue vs GitHub Copilot
Model freedom vs least-setup defaultCopilot is the plug-and-play default across VS Code, JetBrains, Xcode and Neovim at $10/mo, with IP indemnification and GitHub-native PR flows. Continue wins on model freedom (any LLM, local Ollama), full privacy/offline, and zero per-seat cost — at the price of configuring your own model and keys. Choose Copilot for instant setup; Continue for control and privacy.
Copilot for setup · Continue for freedomContinue vs Cline
Config-driven assistant vs autonomous OSS agentCline (Apache-2.0) is a free VS Code + JetBrains agent with a real autonomous loop and the most active community development. Continue is lighter on autonomy but offers genuine JetBrains parity, a cleaner RAG (@codebase) story, and Continue Hub for sharing team configs. Both are free and BYOK; pick Cline for hands-off agentic editing, Continue for an assistant you stay in control of with your own models.
Cline for agent · Continue for assistantContinue vs Sourcegraph Cody
Local freedom vs enterprise codebase graphCody is built on Sourcegraph's code-graph indexing — best-in-class on massive multi-repo codebases, with SOC 2 Type II and on-prem for regulated teams. Continue wins on local/offline operation, model freedom and a $0 floor, but lacks Cody's enterprise compliance certs and large-monorepo retrieval. Choose Cody for enterprise scale; Continue for privacy and model choice.
Cody for enterprise · Continue for localWho Continue Is Best For
Privacy-first & offline development
Run Continue against a fully local Ollama model so proprietary code, healthcare or financial logic never leaves your machine. The strongest privacy posture of any mainstream assistant, and it costs $0 in API fees.
Multi-model experimentation
Researchers and AI enthusiasts compare model behavior side by side through one interface — Claude for reasoning, GPT for breadth, a local model for speed. Swap providers per task without changing tools, and avoid betting your workflow on a single vendor.
Cost-conscious individuals & startups
The core extension is free; with local models the total cost of ownership approaches zero, or you pay only for the cloud API you already have credits for. No subscription, no per-seat fee — ideal for bootstrapped teams watching spend.
Teams split across VS Code & JetBrains
Continue is one of the few assistants with genuine JetBrains parity, so a team using both editors gets consistent autocomplete, chat and @codebase behavior. Share a sanitized config via Continue Hub or dotfiles so everyone runs the same setup.
Standardized AI rules across a team
Publish coding rules, slash commands and context providers as a shared config so every developer's assistant follows the same conventions. Reviewers stop seeing inconsistent AI output, and onboarding gets a ready-made setup.
Open-source customization
Because Continue is Apache-2.0 and config-driven, you can inspect, modify and extend it — custom context providers, MCP servers, slash commands and self-hosted deployments. For teams that refuse black-box tooling, that transparency is the point.
Getting Started
Install the Continue extension
In VS Code open Extensions (Ctrl/Cmd+Shift+X), search Continue and click Install. In a JetBrains IDE, go to Settings → Plugins → Marketplace, search Continue, install and restart. No account required to start.
Get a model — local or cloud
For local use, install Ollama and pull models: ollama pull qwen2.5-coder:1.5b llama3.1:8b nomic-embed-text (small coder for completion, larger for chat, embeddings for @codebase). Or grab a cloud API key from OpenAI / Anthropic / Gemini — you pay that provider directly.
Write ~/.continue/config.yaml
Declare your models with provider, model id and apiBase, assign roles (chat, edit, apply, autocomplete, embed), and add context providers like codebase, docs, terminal. Restart the editor and the models appear in the selector. Omit API keys if you version-control the file.
Connect a cloud provider (optional)
For higher-quality completions, add a cloud model block (e.g. Anthropic Claude or OpenAI GPT) with your API key in the config or the UI. Continue routes chat and edits to it while keeping a local model for fast tab completion — best of both, billed by the provider.
Start coding with it
Use tab autocomplete as you type, ask @codebase questions about your project, run /edit or /comment on a selection, and add your own slash commands for repeated workflows. Tune the config as you learn which models fit which tasks.
FAQ
Is Continue free?
Yes. The VS Code extension and JetBrains plugin are completely free and open source under Apache-2.0. You connect your own model — a local Ollama model costs $0, or a cloud key (Claude, GPT, Gemini) billed by that provider at provider rates. Continue itself never charges for the connection. There is an optional Continue Hub for sharing team configs, but the core assistant is free to use.
Continue vs GitHub Copilot — which should I pick?
Copilot is the least-setup default: install, sign in with your GitHub account, and autocomplete/chat just work across VS Code, JetBrains, Xcode and Neovim for $10/mo, with IP indemnification and GitHub-native PR flows. Continue wins when you want model freedom (any LLM, including local Ollama), full privacy/offline operation, and zero per-seat cost — at the price of configuring your own model and keys. Pick Copilot for plug-and-play; pick Continue for control and privacy.
Continue vs Cursor — which is better?
Cursor is a VS Code fork with the most mature agentic experience (Composer multi-file edits, smooth UX) and the broadest feature set, at $20/mo. Continue is an open-source assistant you drop into your existing VS Code or JetBrains editor — it does not replace the editor and its autonomous agent mode is less mature than Cursor's. Continue's edge is model freedom, JetBrains parity, local/offline use, and a $0 floor. Pick Cursor for the most immersive agent; pick Continue if you want to keep your editor and your model.
Can I run Continue fully offline / with local models?
Yes — this is one of Continue's core strengths. Point it at Ollama or LM Studio and run autocomplete, chat and @codebase entirely on your machine; no code leaves your infrastructure. A typical local setup pulls a small coder model for tab completion (qwen2.5-coder:1.5b), a larger model for chat (llama3.1:8b), and an embeddings model (nomic-embed-text) for codebase search. Quality trails frontier cloud models on hard tasks but is a genuine zero-cost, fully private option.
Does Continue work in JetBrains IDEs?
Yes — Continue is one of the few open-source assistants with genuine JetBrains parity, not just a VS Code port. The plugin installs in IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider and the rest of the family, with the same autocomplete, chat, edit and @codebase features. That makes it a natural pick for teams split across VS Code and JetBrains who want one assistant with consistent behavior.
What does "bring your own model" (BYOK) mean in Continue?
Continue ships no model of its own. In a single config.yaml you declare which models to use and where they run: Ollama or LM Studio locally, or any cloud provider (OpenAI, Anthropic, Gemini, xAI, OpenRouter…) via your API key. You can chain them — a fast local model for tab completion, a frontier cloud model for chat — and switch per task. Because you own the keys, there is no vendor lock-in and no JetBrains/Cursor markup.
Does Continue have an agent mode?
Continue has an agent mode that can plan and execute multi-step edits, but reviews consistently rate it as less mature and less autonomous than Cursor's Composer or Cline's agent loop. It shines as a context-aware assistant — tab completion, @codebase chat, /edit and /comment slash commands — rather than as a hands-off coder that rewrites your repo. If autonomous agentic editing is the priority, Cline or Cursor are stronger today; Continue is the better fit when you want to stay in control and bring your own model.
How do I configure Continue (config.yaml)?
Continue reads ~/.continue/config.yaml (or %USERPROFILE%\.continue\config.yaml on Windows). You list models with their provider, model id and apiBase, assign roles (chat, edit, apply, autocomplete, embed), and declare context providers like @codebase, @docs, @terminal and @git. Restart the editor and the models appear in the selector. Many teams version-control a sanitized config in their dotfiles repo so every developer gets the same setup (omit API keys).
Is Continue safe for proprietary code?
If you run a local model via Ollama or LM Studio, your code never leaves your machine — the strongest privacy posture available. If you connect a cloud model (Claude, GPT…), your prompts and code go to that provider under its data-handling policy; choose a provider with a no-train / enterprise agreement if that matters. Continue itself is open source and auditable, so you can verify exactly what it sends. For strict air-gapped requirements, the local-model path is the one to use.
Is Continue still maintained in 2026?
Continue remains free and open source and the extensions still install and run. Reports through 2026 indicate the project's pace slowed — several write-ups describe a Cursor acquisition and a read-only open-source repository after the v2.0.0 release (with telemetry removed and auth pulled out before the handoff). We could not independently confirm the acquisition, so treat it as unverified. If you need a guaranteed-actively-maintained local-first assistant, Cline + Ollama is the most active community alternative; Continue itself still works and its bring-your-own-model path is intact.