Continue Open-Source AI Coding Agent for VS Code and JetBrains

Install and configure Continue

code --install-extension Continue.continue

name: Local Continue
version: 0.0.1
schema: v1
models:
  - name: Ollama Qwen Coder
    provider: ollama
    model: qwen2.5-coder:7b
    roles:
      - chat
      - edit
      - apply

  - name: Local Autocomplete
    provider: ollama
    model: qwen2.5-coder:1.5b
    roles:
      - autocomplete

Current config.yaml fields

OpenSourcesAI verdict

Continue is one of the strongest choices for developers who want model flexibility without abandoning their existing IDE. Its current value is broader than chat and autocomplete: Plan mode provides read-only codebase exploration, Agent mode can edit files and run tools with permission controls, and config.yaml can define model roles, rules, prompts, docs, and MCP servers. The tradeoff is configuration and model selection. A weak tool-calling model, a chat model used for autocomplete, or overly permissive tool policies can make the experience unreliable or unsafe.

Best for

Developers and engineering teams that want configurable AI assistance inside VS Code or JetBrains, need to mix hosted and local models by role, prefer source-controlled rules and prompts, and want read-only planning plus permissioned agent workflows without moving into a proprietary AI-first editor.

Why use it

Use Continue when different coding tasks should use different models and policies. A fast fill-in-the-middle model can handle autocomplete, a stronger chat model can plan or use tools, an embedding model can index the codebase, and a reranker can improve retrieval. The configuration can live with the project so teams can review and version the assistant’s behavior instead of relying entirely on individual editor settings.

Chat, Plan, and Agent modes

Chat mode provides conversation and manually supplied context without tools. It is useful for explanation, debugging discussion, and architectural questions where the developer wants to remain in control of every action.

Plan mode restricts the built-in toolset to read-only operations such as reading files, listing directories, searching code, viewing diffs and repository maps, and fetching reference material. This creates a safer investigation phase before changes are authorized.

Agent mode adds write and execution tools, including file creation, file editing, and terminal commands. By default, the user is asked for permission before tool execution unless the policy is changed to Automatic. The quality and safety of Agent mode depend on both the selected model’s tool-use ability and the configured permissions.

config.yaml and team-controlled behavior

Continue’s current configuration format is config.yaml. It can define models, their roles, provider settings, rules, prompts, documentation sources, and MCP servers. The older config.json format remains documented for migration but is deprecated and should not be the basis of a new team setup.

Configuration-as-code is valuable because model choices and agent guidance can be reviewed like any other project artifact. Teams can pin a model route, define coding conventions, share prompts, and document approved tools instead of asking every developer to recreate settings manually.

Secrets should not be committed with the YAML. Use environment-variable references, provider authentication mechanisms, or an approved secret workflow, and distinguish repository-shared configuration from personal credentials and local permissions.

Model roles and why one model is rarely best at everything

• Chat: reasoning, discussion, planning, and Agent or Plan conversations.
• Autocomplete: low-latency fill-in-the-middle suggestions while typing.
• Edit: targeted code transformations from explicit edit instructions.
• Apply: deciding how a proposed code change should be integrated into a file.
• Embed: vector representations used by semantic codebase and documentation search.
• Rerank: reordering retrieved context so the most relevant results reach the chat model.

Autocomplete requires a specialized model

Continue’s autocomplete role is designed for fill-in-the-middle models that receive the code before and after the cursor and predict the missing text. This is a specialized workload: a small model trained for FIM can outperform a much larger general chat model while returning suggestions quickly enough to feel interactive.

Local autocomplete can be a good privacy and latency fit when the model is small, the runtime is warm, and the hardware can generate suggestions quickly. Large local chat models may feel too slow for inline completion even if they are useful in the sidebar.

Measure suggestion latency, acceptance rate, repetition, syntax quality, and interruption cost. A model that produces impressive demos but distracts developers with late or noisy completions is not a successful autocomplete deployment.

Context, retrieval, rules, and documentation

Continue can use highlighted code, files, diffs, terminal output, repository search, codebase retrieval, and documentation as context. More context is not automatically better: irrelevant retrieved chunks consume the model window and can steer the answer toward stale or neighboring implementations.

Rules should express stable project constraints—testing requirements, architecture boundaries, formatting, safety gates, and prohibited actions—rather than trying to encode every possible task. Prompts can provide reusable workflows for reviews, debugging, migration, or documentation.

Embedding and reranking models influence retrieval quality independently from the chat model. Teams should test known code-navigation questions and verify that the correct files and symbols are retrieved before trusting broad codebase answers.

Tools, MCP, and permission design

Built-in and MCP tools can extend Continue from an IDE assistant into an agent that reads files, searches the web, queries services, edits code, and executes commands. Each tool expands the model’s authority and the amount of data that can leave the editor.

Tool policies can be Ask First, Automatic, or Excluded in the IDE. Automatic should be reserved for actions whose scope and failure behavior are well understood. Terminal commands, writes, network calls, and external-service mutations should normally retain explicit approval in shared or sensitive repositories.

MCP server source, authentication, tool schemas, logs, and permissions should be reviewed independently. A trusted Continue extension does not make every connected server trustworthy.

How Continue compares with other coding agents

Aider is stronger for terminal- and Git-native editing with automatic commit history. Cline is stronger when the priority is a highly visible VS Code agent loop with per-action approvals and broad tool use. Cursor and Windsurf provide more integrated commercial AI-editor experiences with less model-configuration ownership.

Continue is strongest when the team wants to stay in VS Code or JetBrains, assign different models to different roles, and version rules and configuration. Its flexibility is an advantage for teams with local or self-hosted models and a cost for users who want the tool to choose everything automatically.

Key features

• VS Code and JetBrains extensions with Chat, Plan, and Agent modes for conversation, read-only exploration, and permissioned code or terminal actions.
• Current config.yaml format for models, roles, rules, prompts, documentation sources, context, MCP servers, and shared team configuration; legacy config.json is deprecated.
• Separate model roles for chat, edit, apply, autocomplete, embeddings, and reranking so each workload can use an appropriate model.
• Autocomplete designed around fill-in-the-middle models rather than assuming a general chat model will produce good inline suggestions.
• Built-in codebase, file, diff, terminal, search, and repository context plus configurable MCP tools and external documentation.
• Permission policies that can ask before, automatically allow, or exclude tools, with read-only planning workflows available before implementation.

Common AI use cases

• Explore an unfamiliar repository in read-only Plan mode before changing code.
• Use Agent mode to implement a scoped bug fix with approval before file and terminal actions.
• Run private local chat or autocomplete models through Ollama, LM Studio, or another compatible endpoint.
• Assign separate models to chat, autocomplete, embedding, and reranking roles.
• Share project rules, prompts, model routes, documentation, and MCP configuration through config.yaml.
• Ask questions about selected files, diffs, terminal output, or the wider codebase without leaving the IDE.
• Create repeatable coding workflows across VS Code and JetBrains users.

Business use cases

• Standardize approved AI coding models and rules across an engineering team.
• Keep selected coding workloads on local or self-hosted infrastructure.
• Evaluate model providers without forcing a migration to a different editor.
• Create role-specific cost controls by using smaller models for autocomplete and premium models for complex planning.
• Integrate internal documentation and approved MCP services into developer workflows.

How AI builders can use it

• Install the extension and begin with Chat or Plan mode before enabling write-capable Agent workflows.
• Create a minimal config.yaml with one chat model and one specialized autocomplete model.
• Add project rules and documentation only after verifying the base model and context behavior.
• Keep write and terminal tools on Ask First until the team has reviewed real task traces and failure modes.
• Test retrieval with known repository questions and inspect which files are supplied to the model.
• Run normal lint, tests, builds, code review, and branch protections outside the assistant workflow.

Who should use it

• Developers who want AI assistance inside VS Code or JetBrains.
• Teams that need model-provider flexibility and source-controlled configuration.
• Organizations combining hosted, self-hosted, and local models by task role.
• Developers who want a read-only planning mode before agentic changes.
• Teams willing to review tool permissions, retrieval quality, and model-role fit.

Who should not use it

• Users who want a fully managed AI-first editor with almost no configuration.
• Teams unwilling to evaluate which models support tools, autocomplete, embeddings, or reranking well.
• Repositories without normal tests, code review, branch protections, and rollback practices.
• Organizations that have not reviewed code and prompt data flows to selected providers and MCP servers.
• Users expecting a small local model to match premium agent performance on complex multi-file work.

Evaluation checklist

• Will the team use VS Code, JetBrains, Continue CLI, or a combination?
• Which model is assigned to each role: chat, autocomplete, edit, apply, embed, and rerank?
• Does the Agent model reliably support the required tools and structured calls?
• Is config.yaml stored and reviewed without committing secrets?
• Which repository rules and prompts are stable enough to share?
• Which built-in and MCP tools are Ask First, Automatic, or Excluded?
• Does codebase retrieval return the correct files and symbols for known questions?
• What latency is acceptable for autocomplete and Agent actions?
• Which provider data, retention, and training terms apply to code and prompts?

Security and admin notes

• Keep provider API keys and tokens out of committed config.yaml files.
• Use Plan mode or excluded write tools for repositories where read-only analysis is required.
• Leave file writes and terminal commands on approval unless automation has been explicitly reviewed.
• Audit MCP servers, tool schemas, network destinations, and credentials before connection.
• Treat model output, retrieved documentation, terminal results, and web content as untrusted inputs.
• Run changes on branches and require independent tests, diffs, and human code review before merge.
• Review provider retention and training policies before sending proprietary or regulated code.

Pricing notes

Continue is Apache-2.0-licensed open-source software. Cost depends on the selected hosted APIs or local infrastructure, model roles, context volume, autocomplete request frequency, embeddings, reranking, and Agent tool loops. Using smaller role-specific models can reduce cost, but operating local endpoints also requires hardware and maintenance.

Tradeoffs

Continue offers unusually flexible model and workflow configuration across existing IDEs, but flexibility shifts decisions to the user or team. The wrong autocomplete model feels slow or noisy, the wrong Agent model fails at tools, and broad permissions can create risk. Configuration, retrieval, and model roles need active evaluation rather than one-time installation.

Recommended workflow

• Start with Chat and Plan modes using one reliable model.
• Configure a specialized FIM autocomplete model and measure latency and acceptance.
• Create a minimal config.yaml and keep secrets external.
• Add project rules and retrieval sources gradually.
• Enable Agent mode with write and terminal tools on Ask First.
• Review real task traces, then automate only narrowly trusted tools.
• Keep normal branch, CI, test, and code-review controls authoritative.

Pros

• Open-source and model-provider agnostic.
• Works across VS Code and JetBrains rather than requiring a new editor.
• Clear Chat, Plan, and Agent workflow separation.
• Role-specific models for autocomplete, chat, edits, embeddings, and reranking.
• Source-controlled YAML configuration, rules, prompts, docs, and MCP support.

Cons

• Requires more configuration and model evaluation than commercial AI-first editors.
• Local-model quality and latency vary widely by role and hardware.
• Agent safety depends on tool policies and user review.
• Codebase retrieval requires embedding and reranking validation.
• The ecosystem and configuration formats evolve, making old tutorials easy to misapply.

Alternatives

• Aider may be better when terminal and Git-native editing are the priority.
• Cline may be better when a visual VS Code agent loop and explicit action approvals are central.
• Cursor may be better when a polished commercial AI-first editor is preferred over model independence.
• Windsurf may be better for users seeking an integrated commercial editor and autonomous workflows.
• Tabby may be better when self-hosted code completion for a team is the primary requirement.

FAQ