continuedev/continue

Overview

Continue is an open-source AI coding assistant. It ships as a VS Code extension, a JetBrains plugin and a terminal CLI called cn. In the IDEs it combines several features that usually come as separate products: chat with @-context, an agent mode that calls tools, a read-only plan mode, tab autocomplete, “next edit” suggestions and codebase indexing for retrieval. Models, rules, MCP servers and tools are declared in a config.yaml, locally or through the Continue hub.

The IDE extension has three parts. core/ is a large TypeScript library that owns config, LLM providers, indexing, context providers and tool implementations. gui/ is a React webview with the chat UI. A thin IDE shim connects the two over a typed message protocol. In VS Code, Core runs in the extension host process. JetBrains runs the same core as a separate Node binary built from binary/.

The agent loop does not live in core. In the IDEs it runs in the GUI as a chain of Redux thunks. The webview streams a reply from core, decides which tool calls need approval, executes them, and then streams again. The CLI has its own, separate loop in extensions/cli, built on the @continuedev/openai-adapters package rather than core’s BaseLLM. That split explains several of Continue’s quirks.

Architecture

flowchart LR
  U["User in IDE"] --> GUI["React webview (gui/)"]
  GUI --> THK["streamNormalInput thunk"]
  THK -->|"llm/streamChat"| CORE["Core (core/core.ts)"]
  CORE --> LLM["BaseLLM providers"]
  THK -->|"tools/call"| CT["callTool: built-in / MCP"]
  THK --> CLT["Client tools: edit, find-replace"]
  CLT --> APPLY["ApplyManager + vertical diff"]
  CORE --> IDX["CodebaseIndexer: FTS, LanceDB, snippets"]
  CORE --> MCP["MCPManagerSingleton"]
  CT --> MCP
  CLI["cn CLI"] --> CLOOP["streamChatResponse loop"]
  CLOOP --> ADP["openai-adapters"]

Component	Path	Role
Core	core/core.ts	Message handlers for chat, tools, config, indexing, compaction
LLM layer	core/llm/index.ts, core/llm/llms/	BaseLLM, about 65 provider and helper modules, tool-support table
GUI loop	gui/src/redux/thunks/	streamNormalInput, callToolById, streamResponseAfterToolCall, policy checks
Tools	core/tools/	Definitions, callTool, built-in implementations, system-message tool fallback
Edit engine	core/edit/	Find-and-replace matching, lazy apply, streamed diff lines
VS Code shim	extensions/vscode/src/	Hosts Core in-process, applies edits as vertical diffs
JetBrains	extensions/intellij/, binary/	Kotlin plugin plus the packaged core binary
Indexing	core/indexing/, core/context/retrieval/	FTS5, LanceDB embeddings, code snippets, retrieval pipelines
Terminal security	packages/terminal-security/	Shell command risk classifier
CLI	extensions/cli/	cn TUI and headless agent with its own permissions
Config	packages/config-yaml/	config.yaml schema and hub resolution

How a request flows

Take an agent-mode request in VS Code:

1. Build the request. streamNormalInput picks the selected chat model and the active tools, applies per-model tool overrides, and decides between native tool calling and the system-message fallback (streamNormalInput.ts). The tools depend on the mode: chat gets none, plan gets only read-only built-ins plus MCP tools, agent gets everything enabled (selectActiveTools.ts).
2. Compile and prune. The GUI asks core for llm/compileChat, which fits messages into the context window and reports whether anything was pruned (streamNormalInput.ts, core.ts).
3. Stream. llm/streamChat registers an abort controller per message and runs llmStreamChat, which calls BaseLLM.streamChat on the provider (core.ts).
4. Policy. After the stream, the GUI preprocesses tool arguments and evaluates policies. Calls marked allowedWithoutPermission run immediately. If any call needs permission, only built-in read-only calls run and the rest wait for the user (streamNormalInput.ts).
5. Execute. callToolById runs edit tools in the client and sends everything else to core as tools/call (callToolById.ts). Core’s callTool routes MCP tools by URI and built-ins through a switch (callTool.ts).
6. Loop. streamResponseAfterToolCall dispatches streamNormalInput again with depth + 1. The recursion ends when the model returns no tool calls or a call waits for approval (streamNormalInput.ts). The only depth cap is a check that applies in tests.

Key components

Edits as client tools

edit_existing_file, single_find_and_replace and multi_edit are client tools (builtIn.ts). The find-and-replace version reads the file through the IDE, computes the new contents with executeFindAndReplace, and hands the full text to the apply flow (singleFindAndReplaceImpl.ts). Matching tries exact, trimmed, case-insensitive and whitespace-ignored strategies in that order (findSearchMatch.ts). In VS Code, ApplyManager.applyToFile opens the file and shows the change as a vertical diff. Find-and-replace results apply instantly. Whole-file edits stream through an “apply” model (ApplyManager.ts). The user can accept or reject the diff, which is the main undo path. There is no git checkpointing.

Tool policies and shell classification

Each tool has a default policy: allowedWithoutPermission, allowedWithPermission or disabled. Tools can tighten that per call. run_terminal_command defaults to asking, and then passes the command through evaluateTerminalCommandSecurity (runTerminalCommand.ts). That function tokenises with shell-quote, evaluates each line and each pipe segment, and keeps the most restrictive result. A parse failure falls back to “ask” (evaluateTerminalCommandSecurity.ts). Separate checks cover critical commands (disabled), high-risk package managers, network tools, interpreters and rm, and safe read-only commands. Nothing is sandboxed. Approved commands run in the IDE terminal with your permissions.

Codebase index and context

CodebaseIndexer batches files 200 at a time into a SQLite FTS5 index, a chunk index, a code-snippets index and LanceDB embeddings (CodebaseIndexer.ts). Retrieval combines them, with optional reranking that retrieves twice as many candidates as it keeps. The codebase tool and the @codebase provider sit on top of it. More than 30 context providers cover files, terminal output, git diff, docs and a repo map. Conversation compaction is a manual action: conversation/compact writes an LLM summary onto a history item, and later prompts start from that summary (core.ts, conversationCompaction.ts).

Models

BaseLLM in core/llm/index.ts is subclassed per provider (Anthropic, OpenAI, Gemini, Bedrock, Vertex, Mistral, Ollama, LM Studio, llama.cpp, vLLM and many more). toolSupport.ts records which provider and model pairs support native tools. The rest use SystemMessageToolCodeblocksFramework, which describes tools in the system prompt and parses tool calls out of code blocks. Models are assigned to roles (chat, edit, apply, autocomplete, embed, rerank), so a cheap model can autocomplete while a larger one runs the agent.

The cn CLI

streamChatResponse is a straightforward while (true) loop. On each iteration it rebuilds the system message and tools for the current permission mode, compacts before the API call if needed, streams, handles tool calls, checks the context again after tools, and auto-compacts at 80% (streamChatResponse.ts). Its permission policy is first-match-wins. Edits and writes ask. Read-only tools are allowed. In headless -p mode, Bash and the wildcard are allowed without asking (defaultPolicies.ts).

Extending it

• MCP servers. Declare them in config.yaml. Their tools are called through callToolFromUri, and their resources appear as context.
• Rules. Markdown rules, including AGENTS.md, AGENT.md and CLAUDE.md, are loaded and attached to prompts.
• Tool overrides. Per-model toolOverrides rename, re-describe or disable tools.
• Context providers. Subclass BaseContextProvider in core/context/providers/.
• Built-in tools. Add a definition under core/tools/definitions/, an implementation, and a case in callBuiltInTool.
• Other hosts. Core takes any IDE and IMessenger, which is how the JetBrains binary reuses it. packages/continue-sdk and cn serve cover programmatic use.

Running it

• IDE. Install the VS Code or JetBrains extension, then add models in config.yaml (local or hub). Indexing starts in the background on open.
• CLI. npm i -g @continuedev/cli, then cn for the TUI, cn -p "..." for headless output, or cn serve to expose a session over HTTP.
• Required. Node.js for development builds, a model provider key or a local server (Ollama, LM Studio, llama.cpp), and optionally an embeddings model for @codebase.

Strengths and caveats

• Strength: complete IDE assistant. Autocomplete, next-edit, chat, plan and agent modes share one config and one provider layer.
• Strength: reviewable edits. Every agent edit lands as an accept/reject diff in the editor, not as a silent write.
• Strength: careful shell classifier. The terminal-security package parses commands properly, including pipes, multi-line input and obfuscation.
• Strength: real retrieval. Hybrid FTS and vector search with optional reranking, which most terminal agents lack.
• Caveat: the loop lives in UI code. IDE agent behaviour is spread across Redux thunks and recursion, and has no turn cap outside tests. The CLI has a second, separate loop and LLM client, so the two can drift.
• Caveat: no sandbox or checkpoints. Safety is policy plus diff review. Headless cn -p auto-allows shell and MCP tools by default.
• Caveat: manual compaction in the IDE. The IDE prunes to fit and offers a compact action. Only the CLI auto-summarises.

Sources: code at 5522c6f, verified Q&A.