Cline Releases Cline SDK: Open-Source Agent Runtime Now Powers Its CLI and Kanban, with Portable IDE Extensions

Cline had an ‘agency’ before it was cool, but building on the bleeding edge often leads to some structural debt. Over time, the agent loop and VS Code extension became a package deal—making it a headache to maintain or migrate to a new environment. It is difficult to maintain layering properties in a solid context. Cline, an open-source AI code agent used by millions of developers, posted an important architecture change this week: it outsourced its internal agent harness to a standalone, open-source TypeScript SDK called. @cline/sdkand rebuild all its products on top of it.

Instead of adding another layer on top of that structure, the Cline team chose to rebuild the foundation.

What is an SDK, and How It’s Built

The main agent harness is released in the pluggable agent SDK (@cline/sdk). It now powers Cline across VS Code, JetBrains, and the CLI, and is open source for any team to build on. The main behavioral benefit of this redesign: a long-running task no longer dies by restarting the UI, and sessions can go anywhere – the agent loop remains stateless and reusable while its runtime is long-lived, portable, and invisible to the product.

The SDK is a layered TypeScript stack where each layer has a single responsibility and dependencies flow down tightly.

From bottom to top:

@cline/shared is a base package that manages types, schemas, tool helpers, hook contracts, and extended registry utilities — no upper-layer dependencies. @cline/llms sits above it, holding the provider’s portal and model catalogs. It includes Anthropic, OpenAI, Google, AWS Bedrock, Mistral, LiteLLM, and any OpenAI compatible endpoint such as vLLM, Together, and Fireworks, with all provider logic kept outside the agent loop so changing providers is a configuration change, not a code change. @cline/agents it also works as a browser-compatible, stateless agent for loop iteration, tool orchestration, and event output – importantly, it’s not session maintenance, built-in file/shell tools, or Node-specific orchestration, which makes it embedded in browser environments. Above is sitting @cline/corea Node implementation/orchestration layer responsible for sessions, storage, built-in tools, hub and remote transport, automation and scheduling, telemetry, and plugin/extension loading.

@cline/sdk itself is a public place that re-exports everything from @cline/core. For developers looking for a smaller footprint, the packages are individually installable: you can just pull them out @cline/llms by LLM representative, or just @cline/agents in a stateless loop in a serverless or browser environment, without pulling the full Node runtime stack.

Cline’s team also reports that the new CLI completes the same tasks faster and at a lower token cost than the old one on internal runs.

Reconstructed Agent Belt with Measurable Results of Measurement

With Cline 2.0, the team rewrote the information, simplified the loop, strengthened context management, improved feedback loops and error handling, and rethought how tools are defined and appear in the model.

The Cline team published the results of Terminal Benchmark 2.0 (tbench.ai) to support this. For borderline models, the Cline CLI works claude-opus-4.7 scored 74.2%, compared to Anthropic’s published score of 69.4% for Claude Code on the same model. Opened claude-opus-4.6Cline CLI scored 71.9% compared to Claude Code’s published 65.4%. In open-weight models, Cline scored 55.1% on kimi-k2.6.

Plugin System and Extensibility Layer

One of the most effective additions for dev teams building on the SDK is plugin architecture. The plugin can register devices, view lifecycle events, add rules and commands, and shape what the agent sees. Plugins can be loaded from established paths or workstations, and can start as a locale .ts or .js module, later became a package directory with cline.plugins manifest so that teams can scale in place and provide reusable capabilities when they are ready.

Beyond plugins, the SDK provides additional extensibility points including custom tools, MCP connectors, and capabilities. To add a new custom provider, use the ApiHandler and register it using @cline/llms registry — a directory of properties registerProvider again registerModel such as the correct functions issued for the runtime registry extension.

Support for many native agents

A notable design decision is that multi-agent coordination does not require a separate orchestration layer. The SDK includes groups of agents and subagents by nature, so a session can send to experts, track progress, and exchange handoff notes, all within the same core session. Subagents work with their own model, tools, and instructions.

Scheduled CRON jobs, tests, web searches, and MCP connectors are all handled natively out of the box.

Getting started

The SDK requires Node.js 22 or later.

# Install the SDK
npm install @cline/sdk

# Install the CLI globally
npm i -g @cline

# Or give your agent the Cline SDK skill
npx skills add cline/sdk-skill

Documents available at docs.cline.bot/sdk. Working examples – including examples of plugins and building multiple applications – at sdk/apps/examples again sdk/examples directory of the Cline GitHub repository. Release licensed under Apache 2.0.

Marktechpost Visual Explainer

# Full SDK — recommended starting point
npm install @cline/sdk

# CLI globally (terminal-first usage)
npm i -g @cline

# Add the SDK skill to your coding agent
npx skills add cline/sdk-skill

# Browser-compatible stateless loop only
npm install @cline/agents @cline/shared @cline/llms

# Just the provider layer (LLM proxy use case)
npm install @cline/llms @cline/shared

import { Agent } from "@cline/sdk"

const agent = new Agent({
  providerId:    "anthropic",
  modelId:       "claude-sonnet-4-6",
  apiKey:        process.env.ANTHROPIC_API_KEY,
  maxIterations: 10,
})

agent.subscribe((event) => {
  if (event.type === "assistant-text-delta")
    process.stdout.write(event.text ?? "")
})

const result = await agent.run(
  "Write a Python fn to check if a number is prime."
)

// Anthropic
{ providerId: "anthropic", modelId: "claude-sonnet-4-6" }

// OpenAI
{ providerId: "openai",    modelId: "gpt-4o"            }

// Any OpenAI-compatible endpoint
{ providerId: "openai",    baseUrl: " }

import { AgentPlugin, createTool } from "@cline/sdk"

const myPlugin: AgentPlugin = {
  name: "my-plugin",
  tools() {
    return [createTool({
      name:        "fetch_docs",
      description: "Fetch internal API docs by slug",
      async run({ slug }) {
        return fetchFromInternalDocs(slug)
      },
    })]
  },
}

# Connect agent to Telegram, WhatsApp, Slack
cline connect

# Headless CI: auto-approve + structured JSON output
cline -y --json "Run tests and fix any failures"

# Pipe git diff into the agent
git diff origin/main | cline "Review these changes"

Key Takeaways

• Cline has released its internal agent harness to the open source TypeScript SDK (@cline/sdk), which reposts @cline/core; CLI and Kanban have already been migrated, and VS Code and JetBrains extensions are in progress
• The SDK is a four-layer stack: @cline/shared (species/resources) → @cline/llms (provider gateway) → @cline/agents (browser compatible stateless loop) → @cline/core (Node runtime: sessions, storage, built-in tools, automation, telemetry)
• Sessions are now robust in all environments – a task that has been running for a long time no longer dies on a UI restart
• Native support for plugins, subagents, CRON jobs, checkpoints, MCP connectors, and multi-provider switching without affecting the agent loop
• Enter with npm install @cline/sdk (requires Node.js 22+); documents on docs.cline.bot/sdk

Check it out Repo again Technical details. Also, feel free to follow us Twitter and don’t forget to join our 150k+ ML SubReddit and Subscribe to Our newspaper. Wait! are you on telegram? now you can join us on telegram too.

Need to work with us on developing your GitHub Repo OR Hug Face Page OR Product Release OR Webinar etc.? contact us