Agent Client Protocol (ACP)

Kiro CLI implements the Agent Client Protocol (ACP), an open standard that enables AI agents to work with any compatible editor. This means you can use Kiro's agentic capabilities in JetBrains IDEs, Zed, and other ACP-compatible editors.

What is ACP?

AI coding agents and editors are tightly coupled, but interoperability isn't the default. Each editor must build custom integrations for every agent, and agents must implement editor-specific APIs. This creates integration overhead, limited compatibility, and developer lock-in.

ACP solves this by providing a standardized protocol for agent-editor communication—similar to how the Language Server Protocol (LSP) standardized language server integration. Agents that implement ACP work with any compatible editor, and editors that support ACP gain access to all ACP-compatible agents.

Quick start

Run Kiro as an ACP agent:

kiro-cli acp

The agent communicates over stdin/stdout using JSON-RPC 2.0. Configure your editor to spawn this command, and you're ready to go.

Editor setup

Kiro CLI can be used as an ACP agent in any editor that supports the protocol.

JetBrains IDEs

JetBrains IDEs (IntelliJ IDEA, WebStorm, PyCharm, etc.) support ACP through AI Assistant. See the JetBrains ACP documentation for full details.

To add Kiro as a custom agent:

1. Open the AI Chat tool window
2. Click the settings button and select Add Custom Agent
3. Add the following to ~/.jetbrains/acp.json:

{
  "agent_servers": {
    "Kiro Agent": {
      "command": "/full/path/to/kiro-cli",
      "args": ["acp"]
    }
  }
}

The agent will appear in the AI Chat mode selector.

Zed

Zed supports ACP agents natively. See the Zed external agents documentation for full details. Add the following to your Zed settings (~/.config/zed/settings.json):

{
  "agent_servers": {
    "Kiro Agent": {
      "type": "custom",
      "command": "~/.local/bin/kiro-cli",
      "args": ["acp"],
      "env": {}
    }
  }
}

Select "Kiro Agent" from the agent picker in Zed's AI panel.

Other editors

Any editor supporting ACP can integrate Kiro by spawning kiro-cli acp and communicating via JSON-RPC over stdio. See the ACP specification for protocol details.

Supported ACP methods

Kiro CLI implements the following ACP methods, giving you access to session management, model selection, and streaming responses when using Kiro through any ACP-compatible editor.

Core protocol

Agent capabilities

The Kiro ACP agent advertises these capabilities during initialization:

• loadSession: true - Supports loading existing sessions
• promptCapabilities.image: true - Supports image content in prompts

Session updates

The agent sends these session update types via session/notification:

Kiro extensions

Kiro extends ACP with custom methods (prefixed with _kiro.dev/ per the ACP spec) to expose Kiro-specific features like slash commands, MCP servers, and context compaction. Clients that don't support these extensions can safely ignore them—they're optional enhancements.

Slash commands

MCP server events

Session management

Example: Initialize connection

Here's how an ACP client initializes a connection with Kiro:

// Client sends initialize request
{
  "jsonrpc": "2.0",
  "id": 0,
  "method": "initialize",
  "params": {
    "protocolVersion": 1,
    "clientCapabilities": {
      "fs": {
        "readTextFile": true,
        "writeTextFile": true
      },
      "terminal": true
    },
    "clientInfo": {
      "name": "my-editor",
      "version": "1.0.0"
    }
  }
}

// Kiro responds with capabilities
{
  "jsonrpc": "2.0",
  "id": 0,
  "result": {
    "protocolVersion": 1,
    "agentCapabilities": {
      "loadSession": true,
      "promptCapabilities": {
        "image": true
      }
    },
    "agentInfo": {
      "name": "kiro-cli",
      "version": "1.5.0"
    }
  }
}

After initialization, create a session and start prompting:

// Create a new session
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "session/new",
  "params": {
    "cwd": "/home/user/my-project",
    "mcpServers": []
  }
}

// Send a prompt
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "session/prompt",
  "params": {
    "sessionId": "sess_abc123",
    "content": [
      {
        "type": "text",
        "text": "Explain this codebase"
      }
    ]
  }
}

Session storage

ACP sessions are persisted to disk at:

~/.kiro/sessions/cli/

Each session creates two files:

• <session-id>.json - Session metadata and state
• <session-id>.jsonl - Event log (conversation history)

Logging

ACP agent logs are written to the standard Kiro log location:

Control log verbosity with environment variables:

KIRO_LOG_LEVEL=debug kiro-cli acp
KIRO_CHAT_LOG_FILE=/path/to/custom.log kiro-cli acp

Related

• Interactive Chat - Uses ACP internally
• MCP Integration - MCP servers can be passed to ACP sessions
• CLI Commands Reference