Continue

Provides real-time code completion across VS Code and IntelliJ by integrating with each IDE's Language Server Protocol (LSP) to extract syntactic and semantic context. The system uses LSP context providers to gather surrounding code, type information, and symbol definitions, then compiles this into LLM prompts with codebase-aware ranking. Completion suggestions are streamed back and inserted via IDE-native diff operations, maintaining full IDE undo/redo compatibility.

Implements a pluggable context provider architecture that allows chat to dynamically gather relevant code snippets, documentation, and project metadata before sending queries to LLMs. Providers include file search, symbol lookup, git history, and custom MCP (Model Context Protocol) integrations. The core orchestrator routes user messages through selected providers, compiles context into a unified prompt with token budgeting, and streams LLM responses back to the chat UI with inline code references.

Provides a native IntelliJ plugin that integrates Continue into JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm, etc.) via a custom IDE protocol client. The plugin communicates with the Continue core process, handles IDE operations (file editing, navigation), and manages UI state. Unlike VS Code, the IntelliJ plugin uses the IDE's native UI components rather than a webview, providing deeper IDE integration. Background agents can run autonomously in the IDE, executing tasks without blocking the user.

Provides a command-line interface to Continue that enables chat, code generation, and agent execution from the terminal. The CLI includes a TUI (text user interface) chat mode for interactive conversations, batch mode for scripting, and sub-agent orchestration for running multiple agents in parallel. The CLI can be integrated into shell scripts, CI/CD pipelines, and development workflows. Output is formatted for terminal readability (syntax highlighting, tables, etc.).

Implements a message compilation layer that converts user queries, context, and tool results into LLM-compatible message formats with automatic token budgeting. The system estimates token counts for each message component, prioritizes context by relevance, and truncates or excludes components that exceed the token budget. Streaming responses are handled asynchronously, with tokens buffered and parsed to extract tool calls, code blocks, and structured data. The system supports both streaming and non-streaming LLM APIs.

Integrates with a remote control plane service that provides centralized configuration management, user authentication, and telemetry collection. Users can log in to Continue and sync settings across devices via the control plane. The system collects anonymized telemetry (feature usage, error rates, latency) to improve Continue. Configuration can be managed remotely for teams, enabling IT to enforce policies or standards. The control plane client handles authentication, configuration sync, and telemetry reporting asynchronously.

Enables users to request code edits (refactoring, bug fixes, feature additions) directly in the editor. The system generates code diffs using LLM output, previews changes in a side-by-side diff view, and applies edits via IDE-native operations that integrate with undo/redo stacks. The diff management layer handles merge conflicts, multi-file edits, and rollback. Edit requests can be scoped to selected code ranges or entire files, with context automatically gathered from LSP and codebase indexing.

Provides a unified interface to 40+ LLM providers (OpenAI, Anthropic, Ollama, Bedrock, Azure, local models, etc.) through an abstraction layer that normalizes API differences. The system detects provider capabilities at runtime (function calling, vision, prompt caching, streaming) and adapts message compilation accordingly. Prompt caching is automatically applied when supported, reducing latency and cost for repeated context. Provider selection is configurable per-user or per-organization, with fallback chains for reliability.

Enables LLM agents to call external tools (APIs, shell commands, custom functions) through a unified schema-based interface. Tools are defined as JSON schemas with input/output types, and the system automatically adapts tool definitions to each provider's function-calling format (OpenAI, Anthropic, Ollama). Tool execution is sandboxed and logged, with results fed back to the LLM for agentic loops. Built-in tools include file operations, shell execution, and web search; custom tools can be registered via MCP.

Provides a YAML-based configuration system that defines LLM providers, context providers, tools, and agent behaviors without code changes. Configurations are composed from reusable YAML blocks, validated against JSON schemas, and loaded through a pipeline that supports environment variable substitution and secret management. Profiles allow users to switch between configurations (e.g., 'fast' vs 'accurate' modes). The control plane enables remote configuration sync across devices and team-wide settings management.

Indexes the user's codebase by parsing files, extracting symbols and documentation, and storing embeddings in a local vector database. The indexing system uses tree-sitter for language-aware parsing and supports incremental updates when files change. Semantic search queries (e.g., 'find functions that handle authentication') are converted to embeddings and matched against the index, returning ranked results with file locations and context snippets. The index is stored locally to avoid cloud data leakage.

Implements the Model Context Protocol standard, allowing Continue to connect to external MCP servers that provide custom tools, context sources, and resources. MCP servers run as separate processes and communicate with Continue via stdio or HTTP, enabling integration with external services (Jira, Notion, GitHub, databases, etc.) without modifying Continue code. The MCP client handles server lifecycle management, message routing, and error recovery. Tools and resources from MCP servers are automatically registered and available to LLM agents.

Enables users to request complex coding tasks (e.g., 'add user authentication to the app') and have Continue autonomously decompose the task into steps, execute each step, and apply changes. The agent uses chain-of-thought reasoning to plan the task, calls tools (file operations, shell commands, LLM generation) to execute steps, and iterates based on feedback. The agent maintains context across steps and can recover from errors (e.g., retrying a failed command or asking for clarification). Execution is logged and can be paused/resumed.

Provides a native VS Code extension that integrates Continue into the editor UI via a webview-based chat sidebar, inline code actions, and command palette commands. The extension communicates with the Continue core via a message-passing protocol, handles IDE operations (file editing, diff viewing), and manages UI state (chat history, model selection, settings). The webview uses React for the UI and maintains a persistent connection to the core for real-time updates. Commands are registered in the command palette for quick access to features like 'Continue: Edit', 'Continue: Chat', etc.