Cline

Cline accepts natural-language task descriptions and decomposes them into multi-step execution plans using LLM reasoning. The agent operates in two modes: 'plan' mode generates structured task breakdowns before execution, and 'act' mode executes individual steps with tool calls. The system maintains message state across steps, allowing the LLM to reason about prior results and adjust subsequent actions dynamically. This is implemented via a Task Lifecycle system that tracks state transitions and integrates with the AI Provider layer for streaming LLM responses.

Every file write, terminal command execution, and browser action is presented to the user for approval before execution. The system implements a checkpoint-based approval model where the agent generates an action, the UI displays it with context (diff preview for files, command preview for terminal), and the user can approve, reject, or modify before execution. This is enforced at the Tool Executor layer, which intercepts all tool calls and routes them through the approval UI before delegation to host environment handlers.

Cline is distributed as a VS Code extension that provides a sidebar UI for chat, task history, settings, and approvals. The Extension Architecture uses a WebView for the UI layer, communicating with the extension backend via a message-passing protocol. The Chat Interface allows users to send prompts and receive streaming responses, with real-time approval UI for consequential actions. This is implemented via a WebView Communication system that handles bidirectional message passing between the VS Code extension and the WebView, with a Controller and Orchestration layer that manages task execution and state synchronization.

Cline is also distributed as a standalone CLI tool (npm package 'cline') that can be used outside VS Code. The CLI Architecture supports two modes: interactive mode for real-time chat and approvals, and headless mode for automated execution (e.g., in CI/CD pipelines). The CLI uses the same core engine as the extension, with a command-line interface for task submission and result retrieval. This is implemented via a CLI Commands and Options system that parses arguments and delegates to the core task execution engine.

Cline supports Git worktrees, allowing the agent to execute tasks in isolated branches without affecting the main workspace. The Worktree Management system creates temporary worktrees for task execution, enabling safe experimentation and multi-branch workflows. This is implemented via integration with Git commands and the file system, with automatic cleanup of temporary worktrees after task completion.

Cline supports hooks and workflows that allow users to define custom automation triggered by task events (e.g., on task start, on approval, on completion). Hooks can invoke external scripts or tools, enabling integration with custom workflows. Workflows are multi-step task templates that can be chained together. This is implemented via a Hooks System that registers event listeners and a Workflows system that manages task chaining and execution order.

Cline supports user authentication and account management, with optional credit-based billing for API usage. The Authentication System handles login/logout and session management, while the Account Service manages user profiles and billing information. The Credits and Billing system tracks API usage and enforces quotas. This is implemented via an Authentication System that integrates with identity providers, and a remote configuration system that syncs user settings and billing information.

Cline uses remote configuration and feature flags to control behavior dynamically without requiring updates. The Banner and Feature Flag Systems allow the backend to enable/disable features, show announcements, or adjust behavior based on user properties. This is implemented via a remote configuration service that syncs settings on startup and periodically, with a feature flag evaluation system that checks flags before executing features.

Cline can create new files and edit existing files with awareness of the codebase structure and syntax. The File Operations subsystem supports reading, writing, and editing files with support for multiple languages and frameworks. The agent can perform targeted edits (e.g., adding a function to a specific location in a file) by understanding the code structure, not just appending text. This is implemented via language-specific parsers and integration with the Workspace system, which provides codebase indexing and symbol resolution.

Cline can execute arbitrary terminal commands in the user's workspace and stream output back to the LLM for analysis. The Terminal Integration subsystem captures stdout, stderr, and exit codes, allowing the agent to detect failures and adapt subsequent commands. Commands are executed in the context of the workspace directory, with access to environment variables and installed tools. This is implemented via a host-environment abstraction layer that delegates to VS Code's terminal API (for extension) or Node.js child_process (for CLI), with streaming output captured and fed back to the LLM for real-time reasoning.

Cline can control a headless browser (Puppeteer-based) to navigate websites, fill forms, click buttons, and extract content. The Browser Automation subsystem takes high-level instructions (e.g., 'log in to GitHub and create a new repository') and translates them into browser actions. Screenshots are captured and sent to the LLM for visual understanding, enabling the agent to locate elements and verify actions. This is implemented via a browser control layer that manages Puppeteer instances and integrates screenshot analysis with the LLM's vision capabilities.

Cline supports the Model Context Protocol (MCP) standard, allowing users to connect external tools and services as MCP servers. The MCP Architecture layer manages MCP server lifecycle (startup, shutdown, health checks) and exposes MCP tools and resources to the agent. Tools are dynamically registered and made available to the LLM, enabling the agent to call external services (e.g., database queries, API calls, file system operations on remote systems) without hardcoding integrations. This is implemented via an MCP Server Management system that handles server discovery, connection, and tool marshaling.

Cline supports multiple LLM providers (OpenAI, Anthropic, Google, Ollama, and others) with a unified interface. The AI Provider Integration layer abstracts provider-specific APIs and implements streaming response handling for all providers. Users can select different models for different tasks, and the system handles provider-specific features (e.g., vision capabilities, function calling schemas). This is implemented via a Provider Implementations registry that maps provider names to API clients, with a Model Selection system that allows runtime model switching.

Cline maintains awareness of the user's workspace structure, including file organization, project configuration, and code symbols. The Context Management system indexes the codebase (using tree-sitter or language-specific parsers) to enable symbol resolution, import tracking, and cross-file references. The agent can query the workspace for relevant files, understand project structure, and make decisions based on codebase topology. This is implemented via a Workspace Integration layer that provides APIs for file discovery, symbol lookup, and dependency analysis.

Cline maintains a persistent history of all tasks, including prompts, actions taken, approvals, and results. The State Manager system persists task state to disk, allowing users to resume interrupted tasks or review past executions. Checkpoint snapshots capture the state of the workspace at key points, enabling rollback if needed. This is implemented via a Disk Storage Organization system that stores task metadata, execution logs, and snapshots in a structured format, with a State Manager that handles serialization and retrieval.

Cline allows users to define custom rules and skills that guide agent behavior. Cline Rules are user-defined constraints or preferences (e.g., 'always use TypeScript', 'never delete files without confirmation') that are injected into the system prompt. Skills are reusable task templates or workflows that the agent can invoke. This is implemented via a Customization System that manages rule definitions, skill registration, and system prompt injection, allowing users to tailor the agent's behavior without modifying core code.