Continue is an open-source coding assistant that integrates into VS Code and the JetBrains IDEs, bringing four functions into a single panel: chat, autocomplete, inline editing and an agent mode that runs tasks for you. Unlike closed tools, it does not tie you to a specific model: you choose the engine, from the cloud to a model running on your own machine. In this guide you will see what Continue is, how to install it, how to connect a local model with Ollama, how rules and agents are configured, and how it differs from GitHub Copilot. The same explanation is available in Spanish.

Key takeaways

  • Continue is an open-source coding assistant (Apache 2.0 licence) for VS Code and JetBrains that has more than 3.6 million installs on the VS Code Marketplace and 34,900 stars on GitHub.
  • It brings four modes into one panel: chat, autocomplete (Tab), inline edit and an agent mode with tool use, and it supports more than 100 different models.
  • It works with your own API key or a local model: it has first-class integration with Ollama, so you can work without sending your code to any external service.
  • It is configured with a single config.yaml file where you define each model by its role (chat, autocomplete, edit, apply) and add rules, context providers and MCP servers.
  • In June 2026, Cursor (Anysphere) acqui-hired the Continue team and the project moved to maintenance mode: the 2.0 release is the last from the original team, but the Apache 2.0 code stays available and the extension keeps working with your own models.

What is Continue?

Continue is an open-source coding assistant installed as an extension in VS Code and as a plugin in the JetBrains IDEs (IntelliJ, PyCharm, WebStorm and the rest), and it also exists as a command-line tool and a Neovim plugin. It ships under the Apache 2.0 licence, so you can read, audit and modify all of its code. On the VS Code Marketplace it exceeds 3.6 million installs, and its GitHub repository[1] is close to 34,900 stars.

Its philosophy is the opposite of a black box: instead of imposing a model, Continue is an open wrapper around the engine you choose. It brings four functions together in one place. Chat answers questions about your code; autocomplete suggests the next line as you type; inline edit changes a snippet without leaving the file; and agent mode chains several actions (read files, edit, run tools) to solve a whole task, just like an agent such as Cline.

It is worth being honest about the state of the project. In June 2026, Cursor (whose legal name is Anysphere) hired the Continue team and pulled the company’s commercial product. The practical consequence for users is twofold: on one hand, the Continue cloud is shutting down (hosted data is deleted from 15 July 2026); on the other, the code stays free. According to its own repository, it is "no longer actively maintained and is read-only for all users", but the 2.0 release was cleaned of telemetry and mandatory authentication, so the extension works as a purely local tool that connects to the models you control.

Installation in VS Code and JetBrains

Installing Continue takes less than a minute. In VS Code, open the extensions view (Ctrl+Shift+X), search for "Continue" and click Install. If you prefer the command line, you can install it with the code binary:

code --install-extension Continue.continue

In the JetBrains IDEs the process is equivalent: go to Settings > Plugins, search for "Continue" in the Marketplace and click Install. After installing, a Continue icon appears in the sidebar. The first time it will ask how you want to feed it: you can paste an API key from a commercial provider (Anthropic, OpenAI, Google, among more than a hundred models) or point it at a model you already have on your machine. Since the cloud product has been retired, the recommended path today is the second one: your own key or your own model.

Connecting a local model with Ollama

Continue’s most interesting card is that it can run without leaving your computer. If you have Ollama installed on your own machine, you connect it in seconds. All the configuration lives in a single config.yaml file, saved at ~/.continue/config.yaml for your global setup or in a project’s .continue/ folder. Each model is declared with its provider and roles:

name: My config
version: 1.0.0
schema: v1
models:
  - name: Local chat
    provider: ollama
    model: llama3.1:8b
    roles:
      - chat
      - edit
  - name: Local autocomplete
    provider: ollama
    model: qwen2.5-coder:1.5b
    roles:
      - autocomplete

The top-level name, version and schema fields identify and version your configuration (schema is always v1 for now), and inside each entry of models you set its provider, the backend that serves the model, here ollama, and its model, the exact identifier that backend recognises, such as llama3.1:8b. The roles field is the heart of the system: one model can serve several duties and, above all, you can split the work. The practical move for most setups is to use a small, fast model for autocomplete (which fires on every keystroke) and reserve a more capable one for chat and editing. The available roles are chat, autocomplete, edit, apply, embed, rerank and summarize. With this setup, not a single line of your code leaves your machine.

Rules, context and custom agents

Beyond choosing the model, Continue lets you shape how it behaves. Rules are Markdown files you place in your project’s .continue/rules/ folder; their content is appended to the system prompt for chat, agent and edit, so you can set conventions (for example, "always use strict TypeScript" or "follow the team style guide") without repeating them in every request.

Context providers are the @ commands you type in the chat to inject specific information: @file for a file, @codebase to search the whole repository, @docs for a documentation set, @git for the changes. And because agent mode supports the Model Context Protocol (MCP), you can give it new tools by connecting external servers, the same way as installing an MCP server. This combination of rules, context and tools is what turns Continue into a bespoke agent rather than a generic chatbot.

Continue versus Copilot

Both tools write code with AI inside the editor, but they start from opposite business models. GitHub Copilot is proprietary software tied to the Microsoft ecosystem: it is paid by subscription (the Pro plan costs $10 a month), works with a bounded set of provider-chosen models and sends your context to its servers. It is convenient and deeply integrated, as seen in its agent approach in Copilot, but it is a closed box.

Continue plays the opposite card: it is open source and free as a tool, it does not charge you to use it and it lets you choose any model, including a local one with no per-token cost. In exchange, you manage the keys or the model server. After the Cursor acquisition, that openness is exactly what keeps the project alive: being Apache 2.0, the community can keep using and forking it. If you want a full editor rather than an extension, also compare it with Cursor; if you prefer another open extension with Plan and Act modes, look at Cline.

Frequently asked questions

Is Continue free?

Yes. The extension and the JetBrains plugin are free and open source under the Apache 2.0 licence: you do not pay for the tool. The only possible cost is the language model you connect to it. If you use a commercial model through your API key, you pay for its token usage; if you use a model you run on your own machine with Ollama, the cost is zero beyond electricity. That is its biggest appeal against paid subscriptions.

Does Continue still work after the Cursor acquisition?

Yes, with caveats. In June 2026 Cursor (Anysphere) hired the team and closed the commercial product, and the Continue cloud is shutting down from 15 July 2026. However, the open-source extension keeps working: the 2.0 release shipped without telemetry or mandatory authentication, so it operates as a local tool that connects to your own models. The repository became read-only, but being Apache 2.0 the community can maintain and fork it.

Can I use Continue without sending my code to the cloud?

Yes, and it is one of its strengths. If you configure a local model with Ollama and assign it to the chat, edit and autocomplete roles, no part of your code leaves your machine. It is the right option when you work with private code or under confidentiality requirements, at the cost that a local model tends to reason worse on long tasks than a frontier cloud model.

Conclusion

Continue is the open bet among coding assistants: four functions (chat, autocomplete, edit and agent) in one panel, a hundred models of your choosing and a single config.yaml to govern it all. The Cursor acquisition shut down its cloud, but it also left a clean, local 2.0 tool under the Apache 2.0 licence that the community can keep using. The next step is to install it, connect a model with Ollama to work at no cost and with no cloud, and compare it with Cline or with Cursor to decide which fits your way of programming best.

Sources: [1] Continue documentation, config.yaml reference[2], [2] Continue on GitHub[1], [3] Continue on the VS Code Marketplace[3], [4] Cursor acquires Continue, The New Stack[4].

Visitas: 0

Sources

  1. GitHub repository
  2. Continue documentation, config.yaml reference
  3. Continue on the VS Code Marketplace
  4. Cursor acquires Continue, The New Stack

Route: AI Coding Agents