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.

ACP (Agent Client Protocol) standardizes how editors connect to AI agents, the same way the Language Server Protocol (LSP) standardized language server integration. Kiro CLI implements ACP so you can use it in a compatible editor without a custom integration for each agent. See Agent Client Protocol for the client and harness architecture.

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:

For CLI v2, a content-filtered final response ends with stopReason: refusal rather than end_turn. ACP clients can present it as a refusal instead of normal completion, without exposing internal details.

Kiro extends the CLI v2 ACP server 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 on the v2 server.

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

CLI v2 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

• Agent Client Protocol (ACP) — how ACP connects clients to the unified agent harness
• Migrate an ACP client to CLI V3 — migrate from the CLI v2 ACP server
• Interactive Chat — uses ACP internally
• MCP Integration — MCP servers can be passed to ACP sessions
• CLI commands reference