Skip to main content

Continue

What is this about?

This is a practical developer guide to Continue, the open-source coding agent that is now part of Cursor. It explains what Continue still is today, how the cn CLI and IDE agent modes work, and when Continue still makes sense compared with newer agent tools.

Checked against primary sources

This guide is based on the official Continue documentation, the official Continue site, and the current public project pages, reviewed on June 24, 2026.

1. What Continue is today​

Continue is a coding agent platform that exists in three main forms:

  • a CLI (cn)
  • a VS Code extension
  • a JetBrains plugin

The official docs currently describe it as a "pioneering open-source coding agent." At the same time, they also make its lifecycle status very clear:

  • the continuedev/continue repository is no longer actively maintained
  • the repository is read-only
  • the project shipped a final 2.0.0 release

So the right mental model in 2026 is not "fast-moving active platform," but rather:

  • a stable final-state open-source agent
  • still useful
  • still documented
  • but no longer the place where the newest product investment is happening

That new investment direction is now clearly Cursor.

2. Why Continue still matters​

Even in its final-release state, Continue still has a lot going for it.

CapabilityWhy it still matters
Open-source foundationUseful for teams that want a transparent agent baseline.
CLI + IDE surfacesYou can work in terminal or editor without changing the core agent model.
Plan / Agent / Chat modesGood separation between exploration and execution.
Rules, prompts, models, MCPThe customization surface is still strong.
Headless modeUseful for scripts, CI, or repeatable automation.
Model/provider flexibilityContinue was built to be configurable rather than locked to one provider.

The official docs still expose dedicated areas for:

  • models
  • MCP servers
  • rules
  • prompts

That means Continue remains relevant if your goal is not "latest commercial editor experience," but rather:

  • a configurable agent workflow
  • an open-source reference point
  • a CLI and IDE agent you can still learn from or keep using

3. Installation and first run​

The official CLI quickstart centers on the cn binary.

Install​

curl -fsSL https://raw.githubusercontent.com/continuedev/continue/main/extensions/cli/scripts/install.sh | bash

Or with npm:

npm i -g @continuedev/cli

Verify​

cn --version

Requirements​

According to the docs:

  • the npm install path needs Node.js 20+
  • the shell installer bundles its own runtime
  • authentication can use either a Continue account or an Anthropic API key

First session​

cd your-project
cn

For browser-based authentication:

cn login

For headless automation:

export CONTINUE_API_KEY=your-key-here
cn -p "review the repository structure and summarize the build pipeline"

That gives Continue a nice split between:

  • interactive TUI use
  • single-shot automation

4. The core workflow​

Continue's current workflow model is built around three modes:

  • Chat: pure conversation, no tools
  • Plan: read-only tools for exploration and planning
  • Agent: full tool access for making changes

In the IDE, the docs say you can cycle through modes with:

Cmd/Ctrl + .

Why Plan mode is one of Continue's best ideas​

The official Plan mode docs are very clear: Plan mode is a restricted read-only environment for safe exploration before implementation.

In Plan mode you can:

  • read files
  • search the codebase
  • inspect repo structure and diffs
  • fetch web content
  • use MCP tools

But you cannot:

  • create or edit files
  • delete files
  • run terminal commands
  • make system changes

That is a strong workflow for real projects:

  1. start in Plan
  2. understand the codebase
  3. validate the approach
  4. switch to Agent
  5. implement the change

This is still a best practice whether you use Continue, Cursor, Codex, or Claude Code.

5. Context and editing model​

Continue's Agent mode runs in the same chat interface as ordinary chat, but equips the model with tools.

The docs highlight a few important habits:

  • you can use natural-language instructions directly
  • you can add context with @ providers
  • you can include highlighted code from the editor
  • the agent decides which tools to use to finish the task

That means Continue is not just "chat beside your code." It is a real tool-using coding agent with a shared interaction surface across:

  • explanation
  • planning
  • execution

6. Permissions and safety​

Continue has one of the clearer permission models among coding agents.

The official CLI permissions docs define three levels:

  • allow
  • ask
  • exclude

Default behavior​

By default:

  • read-only tools are generally allowed
  • write tools and Bash default to ask
  • in headless mode, ask tools are excluded because nobody is there to approve them

Important flags​

cn --auto
cn --readonly
cn --allow Write
cn --exclude Bash

Persistent local policy​

Continue stores persistent tool permissions in:

~/.continue/permissions.yaml

This is useful because it makes the trust model explicit instead of burying it inside one session.

Practical best practice​

For team workflows:

  • use Plan or --readonly first
  • allow writes only when the approach is clear
  • be careful with broad --auto usage
  • keep shell permissions tighter than file-read permissions

7. Where Continue still makes sense​

Continue still makes sense when you want:

  • a documented open-source agent baseline
  • a terminal + IDE workflow with one mental model
  • a tool you can use as a reference architecture for agent permissions, modes, and customization
  • a stable environment for teams that do not need the newest vendor-specific features

It is also still useful for developers studying the evolution of coding agents, because it sits at an important point between:

  • classic editor assistants
  • terminal coding agents
  • newer full-agent IDE products

8. Where Cursor now supersedes it​

The acquisition context matters.

If your goal is:

  • active product development
  • the newest editor-native agent workflow
  • deeper investment in rules, skills, and modern agent UX

then Cursor is now the more future-facing choice.

That does not make Continue worthless. It just changes the recommendation:

  • choose Continue for stability, reference value, and its open-source final form
  • choose Cursor for the actively evolving agent experience

For the current successor workflow, see the dedicated Cursor Agent guide.

9. Recommendation​

Continue is still worth knowing, but you should adopt it with the right expectations.

Strong fit​

  • you value open-source tooling history
  • you want a stable final-state agent
  • you need a lightweight configurable CLI + IDE agent

Weak fit​

  • you want the most actively developed commercial coding agent
  • you want the latest editor-native orchestration features
  • you are standardizing on a platform for the next several years

In short: Continue is still meaningful, but today it is best understood as an important open-source milestone and a still-usable final release, not as the center of new momentum.