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.

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.

Run Kiro as an ACP agent:

kiro-cli acp

To use a specific agent configuration:

kiro-cli acp --agent my-agent

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

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

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 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.

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.

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.

The Kiro ACP agent advertises these capabilities during initialization:

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

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

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.

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"
      }
    ]
  }
}

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)

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

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