I Tried Having Kiro CLI Execute Tasks from Amazon Quick Desktop via ACP Integration

Introduction

Amazon Quick Desktop is an AI work assistant that runs on your desktop. You give instructions in natural language through a chat UI, and it lets you manage coding, document creation, and integrations with various services in one place.

Kiro CLI, on the other hand, is an AI agent provided by AWS that supports ACP (Agent Client Protocol). It runs headless from the terminal and autonomously performs file operations, command execution, and code generation.

In this article, I verified how to have Kiro CLI execute tasks via ACP from Amazon Quick Desktop (hereafter, Quick).

• Configuring and verifying local Kiro CLI (task execution, multi-turn conversation, security)
• Attempting a remote connection via SSH (failure → identifying the cause → success)

https://kiro.dev/docs/cli/acp/

What is ACP (Agent Client Protocol)?

ACP is a protocol that standardizes communication between AI agents and clients (editors or desktop apps). Following the same idea as how LSP (Language Server Protocol) standardized communication between editors and language servers, it standardizes interaction with AI agents.

The main characteristics are as follows.

• Communicates using JSON-RPC 2.0 over stdin/stdout
• Not locked in to any particular editor or client
• Manages session-based agent interaction (starting, continuing, and completing tasks)

In Quick, you can register Kiro, Claude Code, Codex, GitHub Copilot, Gemini CLI, Cursor, and others as Coding Agents.

https://agentclientprotocol.com/protocol/transports

Environment

Steps to Configure Local Kiro CLI

Configuring the connection to local Kiro CLI via ACP takes three steps.

Open Settings → Capabilities → MCP tab

Open Settings → Capabilities → MCP tab in Quick. The MCP tab also contains MCP Servers settings, but Kiro CLI is registered in the "CODING AGENTS" section at the bottom of the page.

Add Kiro with Add Agent

When you click "+ Add Agent", the Add Coding Agent Skill dialog appears. Kiro is shown as a preset, so you can register it just by selecting it.

Registration complete

Kiro was registered in the Enabled state.

The configuration values are as follows.

Command and Arguments are set automatically when you select the preset.

How Coding Agent Skills Work

When you register Kiro, "Coding Agent Skills" is automatically loaded into Quick as a built-in skill. Internally, it communicates with the ACP agent using the Send Message To Acp Agent tool.

Verification

Task Execution

Just by giving instructions in natural language in Quick's chat, Kiro executes the task.

• "Ask Kiro to do XX"
• "use Kiro to ..."

Multi-turn Conversation

As long as you continue giving instructions as the same task, Kiro retains the conversation context. Continuous exchanges that build on earlier instructions are possible, such as "Update the README based on the previous result." Internally, these are managed as continuing tasks via task_name.

Non-blocking Parallel Execution

In this verification, Quick's chat remained usable as normal even while a long-running task was executing. I also confirmed that running tasks on local Kiro and remote Kiro at the same time works, with each completing independently.

Security Checks

I checked the security behavior when executing tasks via ACP.

Approval dialog

When Kiro tries to execute a potentially dangerous command (such as sudo), an approval dialog appears in Quick's UI. It will not run unless a human presses "Allow."

sudo execution result in this environment

In this environment, even if approved, the OS-level password prompt functioned as an additional guardrail. When I actually tried sudo ls -la /root/, it was blocked with the following error.

sudo: a terminal is required to read the password;
either use the -S option to read from standard input or configure an askpass helper
sudo: a password is required

Delegating approval decisions to AI could not be confirmed

In this verification, I did not find a way to delegate approval decisions to Quick AI. The approval dialog seems to be designed to involve human judgment.

Remote Connection via SSH (Failure → Success)

Motivation

Being able to connect to Kiro CLI on a remote machine via SSH would offer the following benefits.

• You can use the remote IAM role without placing credentials locally
• You can isolate the development environment, confining the effects of dependency pollution and version mismatches from adding or updating packages to the remote side
• Quick's unified management (records and parallel management) can also be applied to remote work

Prerequisites

Because stdin/stdout are used for communication in ACP connections over SSH, the following must be in place beforehand.

• Non-interactive login must be possible, such as with SSH key authentication
• The initial host key confirmation must be completed
• Kiro CLI must be installed and authenticated on the remote side
• No extraneous standard output (banners, motd, etc.) should be emitted at SSH login

I confirmed in advance that ACP communication works over SSH. When sending a JSON-RPC initialize request, Kiro CLI Agent v2.6.0 responded normally.

(printf '{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"protocolVersion":1,"clientCapabilities":{},"clientInfo":{"name":"test","version":"0.1.0"}}}\n'; sleep 5) | ssh 192.0.2.10 /home/your-user/.local/bin/kiro-cli acp

{"jsonrpc":"2.0","result":{"protocolVersion":1,"agentCapabilities":{"loadSession":true,"promptCapabilities":{"image":true,"audio":false,"embeddedContext":false},"mcpCapabilities":{"http":true,"sse":false},"sessionCapabilities":{},"auth":{}},"authMethods":[],"agentInfo":{"name":"Kiro CLI Agent","title":"Kiro CLI Agent","version":"2.6.0"}},"id":0}

First Attempt → Failure

I registered the remote Kiro, but it was recognized as an MCP integration and task execution failed.

When I pressed the test connection button on the settings screen, Kiro CLI Agent v2.6.0 responded and even returned a joke. The connectivity check succeeded.

However, when I actually tried to execute a task, the following error was displayed.

Skill 'user_mcp' is registered but its tools failed to load
(the integration may not have started).

I tried adding the -T option and restarting the app, but it did not help.

Root Cause Analysis

I investigated Quick's app logs (~/Library/Logs/quickwork/) via local Kiro. This itself is a practical example of ACP integration.

The following was recorded in the log.

[UserMCP] No enabled servers in config

From this message, I learned that during actual task execution it was not launched as an ACP agent and instead entered the processing path of the MCP integration. The cause is summarized as follows.

• When treated as an MCP integration, Quick treats the target as an MCP server and expects to retrieve the tool list with the tools/list method
• kiro-cli acp communicates using the ACP protocol rather than MCP, so it does not respond to tools/list
• The test connection appears to succeed because a response is returned at the initialization stage, but during actual task execution, calls such as tools/list are made as MCP, which does not mesh with kiro-cli acp, an ACP agent

Solution → Re-register under Coding Agents

I re-registered it as a "Custom ACP agent" in the "CODING AGENTS" section.

When I ran the test connection, Kiro CLI Agent v2.6.0 responded normally.

Actual task execution also succeeded, and I was able to confirm that even reading files on the remote machine worked. Kiro CLI's native tools (glob, read) work correctly over SSH.

Verification by Retrieving Environment Information from Local and Remote

I had both local Kiro and remote Kiro run uname -a and confirmed that the connection targets were different.

From Quick's chat UI, tasks can be executed in different environments with the same operation.

Key Points for Success

The key points for getting the SSH remote connection to work are the following three.

• Register it under "Coding Agents" rather than "MCP Servers"
• Add -T (disable pty). This prevents extraneous escape sequences from getting mixed in
• Understand the difference between the ACP protocol and the MCP protocol

Conclusion

The ACP integration between Quick and Kiro CLI can be configured in three steps from the Settings screen. Tasks can be executed in natural language, and I also confirmed multi-turn conversation and non-blocking parallel execution. There are advantages that differ from operating the CLI directly, such as centralized management of conversation and work history and the ability to request log investigations.

In the remote connection via SSH, there was a pitfall where it failed depending on where it was registered. Because the test connection succeeds, identifying the cause is difficult, but since kiro-cli acp communicates using the ACP protocol, it needs to be registered under "Coding Agents." Once registered in the right place, Kiro CLI's native tools worked correctly even over SSH.

References

• Kiro adopts ACP
• Amazon Quick Desktop - MCP servers