Cline CLI: Return to the primitives

In every craft, primitives are the tools experts never outgrow. They feel simple, they expose what's happening, they let you build your own abstractions on top. AI coding has tools. It does not have its primitives – until now.

Where we are today

AI coding is fractured: most tools are tied to single models, closed architectures, or both. Context never leaves the tool that created it. Teams pilot multiple options, but each tool hoards its understanding of the codebase. A PR review started in one agent can't continue in another. Engineers duplicate work across tools, governance has no audit trail, and what should be multiplayer collaboration becomes single-player isolation.

This isn't just inefficiency; it's structural. When context can't travel between tools, teams can't leverage the best model for each task. When history fragments across platforms, onboarding slows and institutional knowledge evaporates. Organizations lose weeks rebuilding context that should persist.

What ships today

The Cline CLI (Preview) is a scriptable agent powered by Cline Core, the same loop behind our VS Code and JetBrains extensions. This isn't an interactive terminal UI; it's infrastructure you can automate and build on, launching today for Linux and macOS. Because it shares that persistent loop, the CLI hands tasks to VS Code, JetBrains, CI, or webhooks without losing context, and it drives subagents in our IDE extensions so Cline can spawn focused subprocesses for things like deep repo exploration without muddying the parent state. These capabilities are in preview as we refine them with community feedback.

Here's how you can use the CLI

Start debugging with cline "fix this production error", attach to the same task in JetBrains when you need the IDE with cline task open [task-id], then continue in CI with identical state.

Spawn parallel instances with cline instance new to explore that legacy module while your main context stays focused on the feature you're building.

Pipe any task to your toolchain:

cat error.log | cline "analyze this" -o json | jq '.solution'

for structured output you can feed into dashboards and scripts.

Build on the CLI

Wire Cline CLI to your Sentry alerts so it automatically replays failing tests, drafts fixes, and opens PRs while staying inside your environment.

Spin up parallel agent loops across your monorepo to map dependencies, prep refactors, and run targeted tests without losing parent context.

Drop Cline CLI into your deployment pipeline with full audit trails, approval gates, and governance hooks for enterprise compliance.

These patterns show what's possible when your agent loop is infrastructure, not just another tool. When a production error hits, the CLI can analyze the stack trace, identify the root cause, write a fix with tests, and open a PR with detailed explanation. Engineers review and merge instead of debugging, completing in minutes what would have taken days. This same approach works for any webhook-driven workflow, from customer support tickets to data pipeline monitoring.

The strategic layer

The advances of frontier models have made building presentation layers for coding agents more accessible. What's hard is the foundation underneath—the agent loop that makes everything work.

Without a maintained loop, teams reinvent the same infrastructure: state handling across tool boundaries, model routing based on task complexity, prompt optimization for each model's characteristics, governance hooks for audit trails, lifecycle orchestration for complex workflows. Every team building their own agent spends months on plumbing instead of their actual product. Cline Core absorbs that infrastructure—state, routing, prompts, governance—so you can focus on the bespoke tooling you're actually trying to ship.

Fortune 100 engineering teams are already building on this architecture. Salesforce built APEX coding agent on Cline, validating that leading technology organizations are investing in this approach. When teams need agents that work across their entire stack, they're choosing Cline's open architecture.

This is what "close to the model" means: Cline is optimized for each model's strengths, you see what's happening, you have control, and you can build exactly the abstractions you need. We provide the primitive stack—context persistence, execution bridges, lifecycle hooks, structured logging—so you can focus on your presentation layer.

Organizations need consistency across their tooling while developers want to work how they prefer. Both get what they need when the agent loop is the constant and the interface is the variable. DevX teams are building custom tooling, platform teams need governance and audit trails, individual developers want their preferred editor. Cline provides the primitive they all build on.

The future isn't one AI coding tool to rule them all. It's an ecosystem where everyone builds what works for them, on top of a shared agent loop that continually improves. While we're starting with AI coding, the primitives we're building (file operations, browser control, task persistence) are the foundation for agents that work like humans do. We're providing that foundation starting today.

Get started

Here's how you can install the Cline CLI:

npm install -g cline

For the technical deep dive on architecture and implementation, read Andrei's CLI blog.

After that, reference our documentation to get started.

Join the community building on this primitive: Discord | Reddit