Cline

What is Cline?

Cline is an open-source AI programming agent that can be used as a VS Code extension, a terminal CLI, an SDK, and an assistant for enterprise IDEs. It not only completes the next line of code within the editor, but it can also read projects, create plans, create and modify files, execute terminal commands, view browser results, call MCP tools, and make further corrections based on the outputs from building and testing processes.

Cline is characterized by its separation of model selection from the Agent tools. Individual developers can use Cline’s unified model services, or they can employ their own API keys from Anthropic, OpenAI, Google, OpenRouter, AWS Bedrock, etc., or run local models through Ollama and LM Studio.

The open-source client is free of charge; the actual cost comes mainly from the amount of computation required to process the selected models.

Core functions

1. Plan and Act dual mode

Cline divides thinking and execution into two modes. The Plan mode allows for reading, searching, and discussing code, but it does not enable modifying files or running commands; it is suitable for analyzing unfamiliar projects, discussing architecture, identifying boundary conditions, and developing implementation plans.

The Act mode inherits the same conversation context, and once it has access to the files and terminal tools, it proceeds to execute the plan.

For minor repairs, one can proceed directly to the Act phase; for tasks that require moderate complexity, it’s appropriate to first carry out planning before moving on to execution. For major restructurings or migrations, the Deep Planning system can be used to explore various options and generate detailed plans. Users can also choose different models for planning and execution – for example, using powerful reasoning models for planning and cheaper, faster models for execution – in order to balance quality and cost.

2. File reading and code modification

Cline allows users to search for code, read files, view definitions, create new files, and propose changes in a diff format. Each change is typically subject to the user’s approval, enabling developers to review the specific modifications before applying them.

It is suitable for implementing functions, fixing bugs, refactoring, adding tests, generating documentation, and updating configurations.

Models may alter the business logic incorrectly, fail to update the necessary call points, or introduce incompatible dependencies. Significant modifications should be carried out on a separate Git branch, and verified through code reviews, type checking, testing, and security scans.

3. Execution of terminal commands

The Act mode enables the execution of tasks such as building, testing, package management, Git operations, and running project scripts; it also allows for continued processing after errors are detected. It facilitates a loop of \"modify—run—observe—modify again\", which is closer to the actual development process than simply returning code snippets.

Commands may involve installing software, overwriting files, modifying databases, or accessing the network. Approval should be required as a default, especially for actions such as deletion, movement, installation, deployment, pushing, changing system settings, and performing operations in the production environment.

The “safe” label provided by the model is not a reliable safety boundary.

4. Browser operations

Cline allows users to open local or remote pages through browser tools, click on elements, enter data, take screenshots, and view the resulting output on the front end; it is suitable for verifying page layouts, interactions, and issues related to the console. Browser operations can also trigger actions such as submission, logging in, purchasing, or other changes in external states, and sensitive pages require manual supervision.

5. Checkpoints – Points for verification

Each time the file is modified or a tool is used, Cline saves a snapshot of the project in a separate shadow Git repository. Users can compare and restore any of these checkpoints, while still retaining the original Git history and context of the main project.

Checkpoints are enabled by default and can also cover files that have not yet been tracked by the main repository.

Checkpoints reduce the cost of trial and error, but they cannot replace proper version control and backup mechanisms. Changes made to the database, cloud environment, or system status via terminal commands may not be reversible using file snapshots; therefore, caution is needed before deleting external resources.

6. Auto Approve and YOLO Mode

Auto Approve allows automatic permission for reading, editing, executing commands, using the browser, MCP, and switching modes, depending on the type of tool. The official recommendation is to automatically approve only reading of project files by default, with other permissions being enabled as needed for specific tasks.

YOLO Mode approves everything automatically, including file operations in any part of the system, dangerous commands, browser actions, MCP tools, and the conversion of plans into actions. The developers explicitly warn that this mode disables security checks and is only suitable for isolated, temporary testing environments.

It may delete data, install software, modify the system, or submit/push code; it should not be enabled arbitrarily in real work machines or environments with production credentials.

7. MCP Extension

Cline supports the Model Context Protocol; it can connect to databases, Git services, browsers, ticketing systems, cloud platforms, and other tools, and it also helps in creating new MCP Servers. MCP makes external capabilities available to models, thereby enabling a significant expansion of Agent workflows.

Before installing MCP, it is necessary to verify the publisher, source code, permissions, and data flow. Tips provided on web pages, issues, or documents may prompt the Agent to use tools with high permissions; therefore, it is essential to restrict the available servers, parameters, and account ranges.

8. Skills, Rules, and Customizations

Users can use project rules, skill sets, and guidance documents to instruct Cline to adhere to coding styles, commands, testing procedures, and architectural principles. Teams can include these documents in the repository so that different developers achieve consistent behavior from the Agent.

Rules are incorporated into the model context, which increases the cost associated with tokens; overly long or conflicting requirements can reduce the effectiveness of these rules. Sensitive credentials cannot be included in rule files, and external skills available in public repositories must be reviewed first.

9. Subagents

Cline offers experimental Subagents that enable multiple read-only research Agents to explore large codebases in parallel, such as by analyzing authentication mechanisms, logs, and data streams separately. These subAgents can read, search for, and execute restricted read-only commands, but they cannot write files, use browsers, invoke MCP, perform online searches, or create further subAgents.

Subagents are suitable for extensive research, but not for small, well-defined tasks. Parallel exploration increases the number of model calls and associated costs; the final results are still synthesized by the main Agent and reviewed by the developer.

10. CLI and headless automation

Cline CLI offers an interactive terminal session, and it also supports one-time tasks, JSON output, pipeline input, CI/CD, and script automation. The CLI can manage MCP, history, scheduling, the backend Hub, and Kanban, and it can connect to editors via the Agent Client Protocol.

It is important to note that the current CLI documentation indicates that when a task is submitted directly, it defaults to the Act mode and is automatically approved for activation. Before using it with CI systems, servers, or directories that contain sensitive credentials, it is necessary to explicitly set the approval procedures, isolation settings for the working directory, timeout parameters, and permissions, rather than relying on the default values.

11. Cline SDK and API

Developers can integrate the Cline Agent into their own products using the SDK; they can subscribe to tool events, use custom tools, track tokens, and set cost limits. Cline also offers an OpenAI-style Chat Completions API that enables access to various models through a unified model ID, supporting streaming output, inference results, images, and cost tracking.

The Chat API is merely an interface for model inference; it is not equivalent to a fully functional Agent with executable code. The SDK and CLI are responsible for managing the Agent’s operations as well as executing various tools, while the cost of the API is calculated based on the tokens associated with the selected model.

Supported AI models and providers

Cline Provider aggregates models from Anthropic, OpenAI, Google, and other sources under a single account, offering a balance overview, unified billing, labels for free models, and trial access to new models. The model IDs are formatted as “provider/model name”, and it supports inference models, long-context models, and multimodal models.

BYOK can be connected directly to OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, GCP Vertex, Azure, DeepSeek, Groq, Cerebras, Vercel AI Gateway, as well as services that are compatible with OpenAI. Models can be run locally using Ollama or LM Studio.

The capability of the model has a direct impact on the quality of the Agent. Weak models may fail to use tools correctly, adhere to specific formatting rules, or maintain context for long-term tasks.

Although local models do not incur per-use fees, the recommended configuration according to the manufacturers is that a 4-bit quantized model requires around 32 GB of memory for basic use, while a higher-quality model needs about 64 GB; to achieve performance comparable to that of cloud services, more than 128 GB of memory may be necessary. In addition, GPU memory and the size of the model also play a role in determining the required memory capacity.

Price of the personal version and costs related to the model

The open-source extensions and CLI of Cline are available at no cost to individual developers; there are no fees for software subscriptions or access rights. However, the fact that Cline is free does not mean that all of the large models used are also free. There are different ways in which it can be utilized:

Cline does not have a fixed answer to the question of \"how much per month\". Each task contributes prompts, file contents, history, tool outputs, and model responses to the token count, which can lead to a rapid increase in costs for long conversations and large datasets.

The task title will show the estimated cost; models that support caching can reduce the costs associated with repeated processing of the same context.

The official price page does not specify fixed amounts or surcharge rates; the information provided on the Credits purchase page within the Cline Dashboard as well as the real-time catalog of models should be referred to. When using BYOK, the prices set by the respective model manufacturers apply.

Enterprise edition

The Enterprise version comes with a customized pricing model that includes all open-source features, as well as JetBrains extensions, SSO, OIDC, SCIM, SLA, dedicated support, centralized billing, a team management dashboard, RBAC, authentication logs, restrictions on model providers, and unified configuration. Advanced settings and fine-grained permissions may be made available gradually over time.

Companies can also make use of VPC deployment, OpenTelemetry, as well as existing cloud service models. Cline’s client architecture reads code locally and does not create an index of code stored in the cloud.

When BYOK is used, the request is sent directly to the selected model provider, without going through Cline’s hosted inference service.

Whether the code leaves the environment ultimately depends on the model endpoint: when an external cloud model is called, the necessary context is sent to that cloud service; it is only with local or private endpoints that stricter controls can be implemented.

Supported platforms

The personal open-source version provides VS Code extensions and a CLI, and it is possible to integrate other environments using SDKs or ACPs. The JetBrains series of extensions are currently available among the enterprise offerings, including IntelliJ IDEA, PyCharm, WebStorm, GoLand, and more.

The CLI supports interactive as well as headless operation, and is suitable for use in macOS, Linux, and Windows terminals. The release schedule for different versions may vary; GitHub currently releases updates for both the IDE and CLI versions on a continuous basis.

Open-source licenses and privacy boundaries

Cline’s official GitHub repository is licensed under the Apache-2.0 license; it contains code for extensions, CLI tools, and SDKs, and allows viewing, modifying, and redistributing such code. This open-source repository is active, and it provides contribution guidelines, security policies, as well as numerous version releases.

In the official GitHub discussions, the Cline team clearly distinguishes between the open-source client and the hosted API service: when using one’s own API Key, requests, code, and autocomplete features do not pass through Cline’s servers, and the open-source license as well as the terms set by the model provider apply in such cases; when choosing Cline as the API Provider, optional hosted routing and billing services are utilized, and it is necessary to accept its service terms as well.

The API Key is stored in the IDE’s built-in credential storage and is sent only to the selected providers. Users should still protect their local credentials, permissions, MCP configurations, and logs; companies, on their part, should implement policies through proxies, VPCs, and model approval lists.

Cline’s tutorial

Complete a basic task.

1. Clarify the code tasks to be completed in Cline, the scope of the repository, and the acceptance criteria.
2. Connect to or import the test project, and first back up the current branch;
3. First, generate a plan using the Plan and Act dual mode, and then verify the modified files;
4. Make minor changes by using file reading and code modification;
5. Run tests, static checks, and builds; unverified code is not accepted directly.
6. Manually check permissions, keys, dependencies, and handle exceptions before merging;

Create reusable professional workflows

1. Select a low-risk, real-world project as a template;
2. Fix the sequence of use for the Plan and Act dual modes, file reading and code modification, as well as terminal command execution;
3. Record the environment, model, prompts, and failure conditions;
4. Set up manual approval for write, deploy, and delete actions;
5. Compare speed, cost, test pass rate, and the amount of rework;
6. Expand to a team or production environment only after stability has been verified;

Which users is it suitable for?

• Developers who wish to use VS Code to edit files, run commands, and verify results;
• For users who wish to freely choose between Claude, GPT, Gemini, OpenRouter, or a local model;
• Teams that place emphasis on open source, BYOK, and avoiding lock-in to a single model;
• For advanced users who need a terminal CLI, JSON output, and CI/CD automation;
• Developers who wish to use MCP to connect databases, browsers, and internal tools;
• Enterprises that require SSO, RBAC, centralized billing, JetBrains, and private inference.

Product advantages

• It is open-source under Apache-2.0, and the software can be used freely for personal use;
• Separate planning from action – understand first, then act.
• Files, terminals, browsers, and MCP together form a complete set of Agent tools;
• Checkpoints allow the file state to be restored, reducing the cost associated with trial and error;
• It supports a large number of cloud models, aggregation providers, BYOK, and local models;
• It also provides VS Code, CLI, SDK, and model APIs;
• Enterprises can standardize permissions, models, billing, and deployment.

Limitations and security recommendations

Cline’s autonomy implies high token costs and significant operational risks. Complex tasks require the repeated transmission of code, tool outputs, and historical data; when expensive models are used, a single task can cost several dollars or even more.

Cost thresholds should be set, tasks should be broken down, and new contexts should be created regularly.

Do not enable YOLO Mode on production servers. The default automatic approval for the headless mode of CLI also needs to be reviewed explicitly.

Before running the Agent, it is necessary to use containers, accounts with limited permissions, separate branches, and recoverable backups; access to unnecessary keys and cloud resources must be prevented.

Checkpoints can only restore files; they cannot undo database writes that have already been performed, external API requests, Git pushes, deletions of cloud resources, or software installations. Actions with a high impact always require manual confirmation.

Local models do not achieve the same quality of programming as those in the cloud right after being installed. Factors such as context, tool calls, hardware speed, and degree of quantization can affect the results; it is therefore necessary to test them using actual projects first.

Frequently Asked Questions

Is Cline free?

Open-source extensions, CLI, and SDK are available at no cost, with no personal subscription fees. When using cloud models, it is still necessary to purchase Cline Credits based on the number of tokens used or to pay your own model provider.

Does Cline support its own API Key?

Supported. It can be connected to Anthropic, OpenAI, Google, OpenRouter, Bedrock, Vertex, DeepSeek, and others; it also supports endpoints compatible with OpenAI.

Can Cline run locally?

The client runs locally, and local models can be invoked through Ollama or LM Studio. The quality and speed of the models depend on the hardware; more powerful models typically require a large amount of memory or GPU memory.

What is the difference between Plan and Act?

Plan can only read, search for, and create plans; it cannot modify files or execute commands. Act possesses tool permissions and is used to carry out the plans, with both sharing the conversation context.

Can checkpoints restore all operations?

No. It can restore snapshots of project files, but it cannot automatically reverse changes to the database, cloud storage, network settings, or any conditions outside the system.

Does Cline support MCP?

It provides support and can assist with the configuration and creation of MCP Servers. When connecting to external tools, it is necessary to restrict permissions and verify their origin.

How much is the Enterprise version of Cline?

Custom quotes are available for the Enterprise version; there are no fixed public prices for its licenses. It includes JetBrains, SSO, SCIM, RBAC, centralized billing, auditing, VPC, and support services.

Is Cline open source?

Yes. The official repository uses the Apache-2.0 license;

The optional Cline hosting model services and enterprise business capabilities are provided in accordance with their respective terms.