Continue

Continue is an open-source coding agent that integrates directly into VS Code, JetBrains IDEs, and the terminal via its cn CLI. It brings AI-assisted chat, inline editing, code autocomplete, and autonomous agent workflows to developers without locking them into a single model provider. You can wire it up to Anthropic, OpenAI, Ollama, Bedrock, or dozens of other backends through a single YAML configuration file.

The CLI (cn) runs as an interactive TUI—think a terminal-native chat interface with session persistence, slash commands, skill loading, and subagent delegation. In headless mode with the -p flag it becomes scriptable: pipe prompts from stdin, capture JSON output, and drop it into CI/CD pipelines or automation scripts without a TTY. The VS Code extension layers on top with inline editing, multi-file agent tasks, and a full chat panel powered by the same core.

Continue supports MCP (Model Context Protocol) out of the box, letting teams connect it to internal tools, documentation, and custom context providers. The skills system allows markdown-defined workflows to be loaded as slash commands, making the agent’s behavior customizable and shareable across a team. All configuration lives in a .continue/ directory under version control.

Note: As of June 2026, the continuedev/continue repository reached its final 2.0.0 release. The codebase is now read-only and serves as a reference implementation. The 2.0.0 release included removal of anonymous telemetry, decoupled authentication, and a comprehensive bug fix pass.

What You Get

• Interactive TUI CLI - A terminal-native chat interface (cn) with session history, slash commands, file attachment via @, and direct shell execution via ! prefix.
• VS Code Agent & Chat - Full agent mode for multi-file development tasks, inline edit mode that modifies code without leaving your current file, and a streaming chat panel for questions and code review.
• 30+ LLM Provider Support - Native adapters for Anthropic, OpenAI, Azure, Bedrock, Ollama, Gemini, Mistral, DeepSeek, LM Studio, Replicate, and many more, switchable via YAML config.
• Headless / CI Mode - Run cn -p for TTY-less operation: pipe prompts from stdin, receive plain text or JSON output, and integrate AI into scripts and CI pipelines.
• Skill System - Define reusable agent workflows as markdown files in .continue/skills/, loadable as slash commands to standardize team-wide AI behaviors.
• Subagent Delegation - The main agent can spawn specialized subagents for parallel or role-scoped tasks, with configurable permission modes (normal / plan / auto).
• MCP Integration - Model Context Protocol support for connecting the agent to external tools, internal APIs, and custom context providers.
• Session Persistence - Automatic session saving per terminal with cn ls to browse history and cn --resume to pick up where you left off.

Common Use Cases

• Terminal-first development - A backend engineer runs cn in a split terminal to ask questions about the codebase, request multi-file refactors, and review diffs without switching to a browser.
• CI pipeline automation - A DevOps team uses cn -p --format json in GitHub Actions to generate conventional commit messages, summarize PRs, or flag potential issues before merge.
• Cross-IDE AI standardization - A team using both VS Code and IntelliJ standardizes on Continue so all developers use the same .continue/ config, skills, and model backends regardless of editor.
• Local LLM workflows - A developer running Ollama locally configures Continue to route all requests on-device, keeping code off external servers while retaining a full agent interface.
• Custom skill libraries - A platform team writes markdown skill files for common tasks (database migration review, API contract checking) that any developer can invoke via slash commands.
• Autocomplete in restricted environments - A security-conscious organization configures Continue’s autocomplete to use a self-hosted model endpoint, replacing cloud-based completions entirely.

Under The Hood

Architecture Continue is organized as a TypeScript monorepo with three primary layers: a shared core library containing all LLM abstraction, context management, and tool logic; a gui React application that powers the VS Code webview panel; and a cli extension implementing the terminal TUI via Ink. IDE extensions (VS Code, IntelliJ) act as thin hosts that initialize the core and forward events through a well-defined protocol interface. The layered design means the same LLM adapters, context providers, and tool implementations run identically in the browser extension, the CLI, and headless CI mode. Configuration loading follows a hierarchical merge strategy—workspace .continue/ settings override global user config, with environment variables as a final escape hatch.

Tech Stack The codebase is TypeScript throughout, with a React 18 frontend in gui styled via Tailwind CSS and Ink powering the terminal TUI in cli. The core LLM layer exposes OpenAI-compatible adapters for over 30 providers, with each wrapped in a typed class extending a common BaseLLM interface. Configuration is expressed in YAML using the @continuedev/config-yaml package; embeddings and vector search use a local SQLite-backed store. Build tooling combines esbuild for bundling, TypeScript compiler for type checks, Vitest for unit and integration tests, and Husky with lint-staged for pre-commit quality gates. The VS Code extension ships a bundled binary built with esbuild.

Code Quality Test coverage is comprehensive: unit tests run via Jest and Vitest coexist across core and CLI packages, covering LLM adapters, tool implementations, session logic, and UI components. Error handling is explicit—custom error classes propagate through async chains with graceful fallbacks that log to stderr without crashing the TUI. TypeScript strict mode enforces type safety across all packages; the shared config-yaml package uses typed schemas for all configuration surfaces. Husky and lint-staged enforce Prettier formatting and ESLint rules on every commit, and CI runs the full type check and test suite on every pull request.

What Makes It Unique Continue’s primary differentiator is its provider-agnostic design: a single YAML file switches the entire stack—chat, autocomplete, embeddings, reranking—between any of 30+ LLM backends, including fully local models, without code changes. The skills system allows teams to encode institutional knowledge as plain markdown workflows that become first-class slash commands, making the agent’s behavior customizable without touching the application source. The subagent architecture lets the primary agent delegate scoped tasks to specialized agents with their own model and permission configuration. MCP integration means Continue can natively consume tools exposed by any compliant server, giving teams a standard interface to bridge internal tooling into the AI loop.

Self-Hosting

Continue is released under the Apache License 2.0, a permissive open-source license that allows commercial use, modification, and redistribution without requiring derivative works to be open-sourced. There are no usage fees, license keys, or feature gates—the full capability set is available to anyone running the software. The continuedev/continue repository reached its final 2.0.0 release in June 2026 and is now read-only; no further updates or security patches will be issued from the upstream repository.

Running Continue in a self-hosted or air-gapped context is straightforward: the CLI installs via npm or a curl script, the VS Code and JetBrains extensions are available from their respective marketplaces, and all configuration lives in a .continue/ directory that can be committed to version control. Teams routing traffic to local Ollama or a self-managed Bedrock endpoint keep all code on-premises. Operational responsibility—uptime, model hosting, access control, secret management for API keys—rests entirely with the adopting team. Because the upstream project is now archived, there is no vendor providing support, hosted updates, or managed upgrades.

The archived status is the primary trade-off relative to actively maintained alternatives. Bug fixes, new model provider support, and security patches will not come from the original maintainers; teams adopting Continue after June 2026 should plan to fork the repository if they need ongoing maintenance. The 2.0.0 release removed anonymous telemetry and decoupled authentication, making it a cleaner base for community forks. Users seeking a supported, commercially backed alternative in the same category should evaluate Cursor, Codeium, or other maintained AI coding assistants.