One agent core now spans four developer surfaces
Cline is bigger than the VS Code extension many developers first encountered. The repository now presents a shared agent core through a terminal client, VS Code, a JetBrains plugin, and a Node.js SDK. The agent can read and edit a project, run shell commands, inspect errors, browse, and call external tools. Plan mode separates investigation from execution, while checkpoints and IDE diffs give users ways to inspect or reverse changes.
That breadth changes the buying decision. A developer can run an interactive terminal session, stream NDJSON into another program, schedule a recurring job, or build a custom agent with lifecycle hooks. The same project also connects conversations from Slack, Telegram, Discord, Google Chat, WhatsApp, and Linear. This saves teams from adopting a separate agent for each surface, but it also creates a much larger security and operating boundary than an editor autocomplete tool.
Auto-approved shell access needs an intentional boundary
The CLI documentation says tool calls are auto-approved by default. Users can pass --auto-approve false to require confirmation, while --yolo skips prompts and background Zen sessions run with full tool approval because no terminal remains attached. Cline's own README lists package installation, test execution, deployment, and database management among the commands it can perform. Those are useful abilities with real consequences.
Start interactive work with approvals enabled and read the requested command as carefully as a teammate's pull request. For unattended jobs, use a disposable checkout, scoped credentials, and an account that cannot reach production. Checkpoints can rewind workspace edits, but they cannot undo a package published to a registry, a remote API call, or a database command. Cline gives you control switches; your runtime decides how much damage a wrong approval can cause.
What happened when we ran it
Our sandbox installed commit 09ee902 in 129 seconds, adding 2,435 packages and consuming 3,838 MB on disk. The build succeeded in 64 seconds. This was a 57.8 MB checkout containing 3,923 files and about 709,473 lines of source, arranged as a workspace monorepo. We found 16 CI workflow files, no Dockerfile, and no top-level tests directory.
The test command failed with exit code 1 after 500 seconds. One reported Vitest group had 72 passing tests and no failures. The final core end-to-end summary was different: two files failed, one passed, and the seven tests inside them ended with three failures and four passes. The log points to src/hub/daemon/singleton.e2e.test.ts and says the test:e2e script exited with code 1. It does not state a cause, so we cannot call the failure environmental or product-specific.
The practical result is mixed. Installation and compilation worked, which clears the first contributor hurdle. The complete test command did not produce a clean signal in the supplied 3-CPU, 8 GB container, and it occupied more than eight minutes before exiting. Anyone changing the shared core should reproduce the failing end-to-end cases in the project's supported development environment before trusting a local patch.
Provider choice shifts cost and privacy to configuration
Cline supports Anthropic, OpenAI, Google, OpenRouter, cloud platforms, inference vendors, local Ollama or LM Studio, and generic OpenAI-compatible endpoints. The CLI can also use a ChatGPT subscription through its OpenAI Codex provider. This range is a genuine strength for teams that test several models or must route some repositories to local inference. It also means model behavior, context limits, prices, and data handling vary with the chosen provider.
Authentication is another moving part. Interactive OAuth and saved API-key flows are documented, and non-interactive runs fail when a selected OAuth provider lacks stored credentials. Chat connectors require bot tokens, signing secrets, webhooks, or public base URLs depending on the service. Release cli-v3.0.60 fixed credentials in Git remote URLs being included in workspace information sent to the model, a useful reminder to treat repository metadata as part of the prompt boundary.
MCP support is useful, while current CLI reports need attention
MCP servers can give Cline access to databases, APIs, and infrastructure. The CLI includes an install wizard for local commands plus HTTP and SSE servers. Open issue 13596 says MCP configuration is limited to user-level files rather than a repository-scoped file a team can opt into. Open issue 13597 reports that an enabled offline remote MCP server can terminate the CLI, although the VS Code extension continues with the server marked unavailable.
Those reports matter to teams building repeatable agent workspaces. A user-level configuration is harder to review and share with the code that depends on it, while a failed optional server should not take down an unrelated coding session. The latest release did fix another MCP installer bug involving a -- argument separator. Given the fast release pace, test the exact client and transport you intend to standardize rather than treating MCP behavior as identical across every surface.
Current activity is high, and the queue is correspondingly large
GitHub recorded a push on August 27, 2026, one day after CLI v3.0.60 was published. The repository had 66,932 stars and 1,113 combined issues and pull requests when fetched. Recent activity included fixes and features across the desktop client, model providers, the SDK, sessions, and MCP. The combined count says nothing by itself about defect volume, but same-day issue and pull-request updates show that both users and maintainers are working in the repository.
Cline makes the most sense when its multiple surfaces replace separate tools your team would otherwise operate. A solo editor user may find the 2,435-package contributor install excessive, yet can still use the published extension or CLI binary without building this monorepo. For teams adopting schedules, connectors, or headless agents, the first design document should cover approval defaults, credential scope, and recovery from external side effects before the first autonomous task runs.