Continue

Continue is an open-source AI code assistant that runs inside your existing editor rather than replacing it. It ships as an extension for VS Code, Visual Studio and JetBrains IDEs, and it adds three capabilities to the places you already work: inline autocomplete, a chat panel that can be given precise context from your codebase, and configurable agents that perform multi-step tasks. The design philosophy is that the model, the prompt structure and the rules should all be under your control, which puts Continue in a different category from closed assistants that decide those things for you.

Autocomplete is the most-used surface. Continue provides tab-completion of one or more lines, and it can propose edits across multiple files as you move through a change, which is closer to how an experienced developer actually works than single-file suggestions. Because the extension runs locally, latency depends on where the model is hosted; a small model served locally or a low-latency endpoint gives a noticeably better typing experience than a large general-purpose model over the internet. Continue lets you assign different models to different roles, so you can use a fast cheap model for autocomplete and a stronger reasoning model for chat and agentic work.

Chat is where context handling matters most. The chat panel accepts at-mentions that attach specific things to the prompt: a file, a folder, a code symbol, a documentation source, a URL, the current diff, terminal output, a Git commit or a codebase-wide semantic search. Continue indexes the workspace into embeddings so that a question like where do we validate incoming webhooks can retrieve relevant code without you knowing the filename. This is the practical difference between a chatbot that only sees the open file and one that can reason about a repository. Users can also define custom context providers, which is how teams wire in internal wikis, design systems or ticket data.

The third pillar is agents and rules. An agent in Continue is a configured bundle of model, tool access, system prompt and behavioural rules, and these are expressed as files that can live in the repository under a Continue directory. That has an important consequence: coding standards, architectural constraints and preferred libraries can be committed alongside the code, so every developer on the team gets the same assistant behaviour without anyone maintaining a separate settings document. A shared hub lets teams publish agents, rules, prompts and context providers internally or publicly and install them with a command. For an organisation trying to standardise AI usage across many repositories, this version-controlled approach is materially better than asking each engineer to configure a GUI.

Model support is the widest part of the story. Continue works with hosted APIs from OpenAI, Anthropic, Google, Mistral, DeepSeek, Bedrock, Azure OpenAI, Vertex AI and OpenAI-compatible gateways, and with local models through Ollama, LM Studio, llama.cpp or vLLM. Teams with strict data policies can run everything on their own infrastructure, meaning no source code leaves the network. There is no requirement to create an account with the Continue project to use the extension with your own endpoints, which is a genuine distinction from assistants that route traffic through the vendor.

Against competitors, Continue is usually compared with GitHub Copilot, Cursor, Cody, Cline and Aider. Copilot is the default choice inside VS Code and JetBrains, with institutional backing, strong autocomplete and an increasingly capable agent mode, but it routes through Microsoft's service and its model options are curated rather than open. Cursor is a full editor fork with arguably the most polished chat and agent experience available; the cost is that you must switch editors and pay a subscription, and the internals are closed. Cody from Sourcegraph leans on enterprise code search and is strong where Sourcegraph is already deployed. Cline and Roo Code are open-source autonomous agents that live in VS Code and can execute shell commands with fewer guardrails. Aider takes the open-source, model-agnostic idea into the terminal. Continue's specific position is: stay in your editor, stay open source, bring any model, and version-control the assistant's behaviour.

Pricing is layered. The core extension is free and open source under a permissive licence, and using it with your own API keys or local models costs nothing beyond inference. Continue also offers hosted plans for teams and enterprises that add managed model access, a central place to publish and enforce shared agents and rules, usage analytics, administrative controls, single sign-on and support. In that model, the paid part is the coordination and governance layer rather than the assistant itself. If you are a solo developer, you can realistically pay only for tokens. Current figures are published on the vendor pricing page and should be checked, because the split between free extension and paid platform has evolved over time.

The limitations are worth naming. As an extension rather than a purpose-built editor, Continue cannot modify the editor itself, so some interactions are less fluid than in Cursor; there is no deep integration with editor internals like inline diff decorations that a fork can implement natively. Configuration is powerful but it is configuration: getting autocomplete latency, model choice, context providers and rules right takes time, and a team that will not invest that time may get a worse experience than with a tuned commercial default. Autocomplete quality depends heavily on model choice, and free local models can feel slow or imprecise compared with dedicated commercial completion models. Enterprise features such as centralised policy enforcement require the paid platform. Finally, as an open-source project with a commercial arm, the roadmap balances community and paying customers, and releases can introduce breaking changes to configuration formats.

Continue fits engineering teams that want AI assistance without leaving VS Code or JetBrains, organisations with data residency or vendor-lock concerns, teams that want their AI coding standards committed to source control, and individual developers who like choosing their own models and paying only for inference. It fits companies already running Ollama or an internal model gateway. It does not fit developers who want a zero-configuration experience with the best possible out-of-the-box polish, non-technical users, or organisations that require a single vendor to be contractually accountable for both the editor and the model.

In the closing comparison, the practical guidance is this. If you are happy with your editor and want control, Continue is the strongest open-source option and the only one that treats assistant behaviour as version-controlled configuration. If you are willing to change editors for the best integrated experience, Cursor is more polished. If you want the path of least resistance with vendor support and are comfortable with Microsoft's ecosystem, GitHub Copilot is the safe default. If your main need is autonomous agentic execution rather than daily editing assistance, Cline or Aider may serve better. For a team that wants one shared, auditable AI coding standard across many repositories, Continue is the tool designed for exactly that problem.