+++
title = "Cline SDK Released: The Open-Source Agent Runtime for AI Development"
date = 2026-05-24
draft = false
description = "Cline SDK 1.0.0 released. Introduction of the Cline SDK as an open-source agent runtime. The new foundation powering Cline's CLI and Kanban interfaces. Upgrade urgency: high."
slug = "cline-sdk-released-open-source-agent-runtime"
tags = ["cline sdk", "release", "version", "ai agents", "open-source"]
categories = ["Releases"]
author = "AI Expert"
showReadingTime = true
showTableOfContents = true
toc = true
+++

> ⚠️ **HIGH PRIORITY** — Important fixes and foundational changes. Upgrade soon.

> **Version:** 1.0.0 | **Released:** 2026-05-24 | **Upgrade from:** N/A (First Public Release of Cline SDK - fundamental re-architecture)

## Release at a Glance

The Cline team is excited to announce the **Cline SDK 1.0.0**, a major milestone establishing Cline as an open-source agent runtime for AI development. This release fundamentally re-architects how Cline operates, providing a robust, extensible foundation for building sophisticated agentic AI applications.

Here's the TL;DR for developers:

*   **New Open-Source Core:** Cline's capabilities are now powered by the `Cline SDK`, an open-source agent runtime.
*   **Unified Ecosystem:** Cline's CLI, Kanban, and IDE extensions have been rebuilt or migrated to leverage this new SDK, ensuring a consistent and powerful developer experience.
*   **Advanced AI Agent Features:** The SDK enables agents to understand project structure, make coordinated code changes, and automatically correct errors (syntax, types, imports).
*   **High Upgrade Urgency:** All developers currently using or planning to use Cline should prioritize upgrading to benefit from the new architecture and improved agent accuracy.

This release marks a significant step towards democratizing agentic AI development, providing the tools needed to create more intelligent and autonomous coding assistants.

## Headline New Features

The Cline SDK 1.0.0 introduces a suite of powerful capabilities designed to empower developers building the next generation of AI agents.

### The Cline SDK: Open-Source Agent Runtime

At its core, Cline SDK 1.0.0 is an open-source runtime specifically engineered for AI agents. It provides the foundational logic and APIs necessary for agents to interact with codebases, understand context, and execute complex tasks. This shift to an SDK-centric architecture means more transparency, extensibility, and community contribution opportunities.

### Unified Foundation for Cline's Ecosystem

The new SDK now underpins all of Cline's primary interfaces: the **CLI**, **Kanban**, and **IDE extensions**. This unification ensures that whether you're interacting with Cline through your terminal, a visual board, or directly within your editor, you're leveraging the same powerful and consistent agent runtime. This eliminates inconsistencies and streamlines development across tools.

### Advanced Code Editing Capabilities

One of the most impactful features of the new SDK is its enhanced ability to interact with and modify code. Agents powered by the Cline SDK can now:

*   **Read Project Structure:** Understand the hierarchical organization of files and directories within a project.
*   **Understand File Relationships:** Analyze dependencies and connections between different code files.
*   **Make Coordinated Changes:** Perform complex refactoring or feature implementations that require modifications across multiple files, ensuring consistency and correctness.

This capability moves beyond simple file edits, allowing agents to act as true collaborators on large projects.

```typescript
// Conceptual example: Using the SDK to define an agent's project interaction
import { AgentRuntime, ProjectContext, CodeChange } from '@cline/sdk';

class MyRefactoringAgent extends AgentRuntime {
  async run(context: ProjectContext): Promise<CodeChange[]> {
    const filesToRefactor = context.findFiles('src/**/*.ts');
    const changes: CodeChange[] = [];

    for (const file of filesToRefactor) {
      // Logic to analyze file content, identify patterns, and propose changes
      const updatedContent = await this.llm.refactorModule(file.content);
      changes.push({
        filePath: file.path,
        oldContent: file.content,
        newContent: updatedContent
      });
    }
    return changes;
  }
}

// The SDK handles applying these changes across the project context.

// Conceptual example: SDK's internal error correction loop
// (Developer interacts with the high-level agent API, this happens under the hood)
async function executeAgentTask(task: AgentTask) {
  let codeOutput = await agent.generateCode(task.prompt);

  // SDK's built-in validation and correction loop
  let attempts = 0;
  while (hasErrors(codeOutput) && attempts < MAX_CORRECTION_ATTEMPTS) {
    const errors = analyzeErrors(codeOutput);
    codeOutput = await agent.correctCode(codeOutput, errors);
    attempts++;
  }

  if (hasErrors(codeOutput)) {
    throw new AgentCorrectionFailedError("Agent failed to auto-correct code.");
  }
  return codeOutput;
}

// package.json (BEFORE)
{
  "name": "my-cline-project",
  "workspaces": [
    "packages/*",
    "cli" // Direct dependency on the old CLI source tree
  ],
  "scripts": {
    "run-old-cli-feature": "node cli/src/main.js --feature"
  }
}

// old-project-script.js (BEFORE - Hypothetical direct import)
// This path no longer exists.
const oldCliCore = require('../../cli/src/core');
oldCliCore.performLegacyTask();

# Terminal command (BEFORE - Direct invocation of old CLI script)
node cli/src/main.js --check-syntax myFile.ts

// package.json (AFTER)
{
  "name": "my-cline-project",
  "dependencies": {
    "@cline/sdk": "^1.0.0", // New SDK dependency
    "@cline/cli": "^1.0.0"  // New CLI if you need its commands
  },
  "scripts": {
    "run-new-cline-agent": "node my-agent-script.js", // Using the SDK
    "use-cline-cli": "cline --new-command"             // Using the new CLI package
  }
}

// new-project-script.js (AFTER - Using the new SDK)
import { AgentRuntime, ProjectContext } from '@cline/sdk';

class MyNewAgent extends AgentRuntime {
  async run(context: ProjectContext) {
    // ... use SDK APIs to interact with the project and agents
  }
}
// Example: Instantiating and running an agent
const myAgent = new MyNewAgent();
// myAgent.run(someProjectContext);

# Terminal command (AFTER - Using the new global/local CLI command)
cline --check-project-health

// old-custom-ide-extension.ts (BEFORE - Relying on internal Cline extension APIs)
// This API might have been internal and is now removed or changed.
declare const ClineIDE: {
  getLegacyWorkspaceContext(): any;
  registerOldCommand(commandId: string, handler: Function): void;
};

ClineIDE.registerOldCommand('my.custom.cline.command', () => {
  const context = ClineIDE.getLegacyWorkspaceContext();
  // ... perform actions using old Cline internal logic
});

// new-custom-ide-extension.ts (AFTER - Using the new Cline SDK)
import { ProjectContext, AgentRuntime, CodeChange } from '@cline/sdk';
import * as vscode from 'vscode'; // Or other IDE API

export function activate(context: vscode.ExtensionContext) {
  vscode.commands.registerCommand('my.custom.cline.newCommand', async () => {
    const currentWorkspace = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
    if (!currentWorkspace) {
      vscode.window.showErrorMessage('No workspace open.');
      return;
    }

    // Initialize Cline SDK context
    const projectContext = new ProjectContext(currentWorkspace);
    const myAgent = new MyCustomAgent(); // Your agent built with @cline/sdk

    try {
      const changes: CodeChange[] = await myAgent.run(projectContext);
      // Apply changes using IDE's API, e.g., vscode.workspace.applyEdit
      vscode.window.showInformationMessage(`Agent completed with ${changes.length} changes.`);
    } catch (error: any) {
      vscode.window.showErrorMessage(`Agent failed: ${error.message}`);
    }
  });
}

// Your custom agent logic, built on the Cline SDK
class MyCustomAgent extends AgentRuntime {
  async run(context: ProjectContext): Promise<CodeChange[]> {
    // ... implement agent logic using SDK APIs
    return [];
  }
}

# Using npm
npm install @cline/sdk@latest @cline/cli@latest

# Using yarn
yarn add @cline/sdk@latest @cline/cli@latest