Kiro CLI

Kiro CLI is a command-line tool powered by a generative AI assistant. You can use it to ask questions about AWS architecture, resources, and general development tasks.

You can install Kiro CLI in several ways on multiple operating systems, including Arm-based Linux distributions and macOS.

Before you begin

You need a Builder ID to use Kiro CLI. If you don’t have one, visit Do more with AWS Builder ID and select Sign up with Builder ID to create your AWS Builder ID.

You’ll learn how to install Kiro CLI on macOS and Arm Linux.

How to download and install Kiro CLI

You can invoke the CLI using the kiro-cli command.

Install Kiro CLI on Linux and macOS with a single command:

    

        
        
curl -fsSL https://cli.kiro.dev/install | bash

    

Install Kiro CLI on macOS using Homebrew

You can also use Homebrew to install Kiro CLI.

Start by installing Homebrew if it’s not already available on your computer.

Install Kiro CLI using Homebrew:

    

        
        
brew install kiro-cli

    

Install Kiro CLI on Arm Linux by downloading a ZIP file

You can download and install Kiro CLI on any Arm Linux distribution using the installer.

Before starting, ensure that curl and unzip are available on your computer.

    

        
        
sudo apt update
sudo apt install curl unzip -y

    

Download the ZIP file with curl:

    

        
        
curl --proto '=https' --tlsv1.2 -sSf 'https://desktop-release.q.us-east-1.amazonaws.com/latest/kirocli-aarch64-linux.zip' -o 'kirocli.zip'

    

Extract the installer and run it:

    

        
        
unzip kirocli.zip
bash ./kirocli/install.sh

    

You’ll be prompted by the installer about updating your shell configuration:

    

        
        ✔ Do you want kiro to modify your shell config (you will have to manually do this otherwise)? 

        
    

To automate the install, add the --no-confirm flag to the install.sh command.

    

        
        
curl --proto '=https' --tlsv1.2 -sSf 'https://desktop-release.q.us-east-1.amazonaws.com/latest/kirocli-aarch64-linux-musl.zip' -o 'kirocli.zip'

    

Confirm Kiro CLI is working

You now have the latest version of Kiro CLI installed.

Confirm the CLI is available by printing the version:

    

        
        
kiro-cli version

    

The output shows the version, and is similar to:

    

        
        kiro-cli 2.16.1

        
    

Log in with your Builder ID

Before you can use Kiro CLI features, you need to log in with your AWS Builder ID.

Run the login command:

    

        
        
kiro-cli login

    

Follow the prompts to authenticate. The CLI opens a browser window (or provides a URL for remote sessions) where you sign in with your Builder ID credentials.

After a successful login, you can start using Kiro CLI:

    

        
        
kiro-cli chat

    

Configure your AWS account to get the most from Kiro CLI

Kiro CLI can answer questions and solve problems related to your AWS resources. For example, you can ask for the IP address of an EC2 instance instead of going to the AWS console or looking up the AWS CLI command to get it. Kiro CLI accesses your AWS resources and returns the information you ask for.

To get account-specific answers, configure AWS CLI credentials.

To set up the AWS CLI and generate and configure access keys, follow the AWS CLI Install Guide and the AWS Credentials Install Guide .

Set the Kiro CLI context to tailor responses

Kiro CLI can read your context. If you provide more information about yourself, you get tailored responses that match your development environment.

There are multiple options to store context.

Use the /context command to see the possible locations to store your context.

    

        
        
/context show

    

The output is similar to:

    

        
        Active agent context: kiro_default
 
   – AGENTS.md 0.0% (no matches)
   – README.md 0.1%
 
 Session (temporary)
   <none>
 
 Tools
   Built-in 3.5% · 14 tools
     · code 0.3%
     · glob 0.1%
     · goal 0.3%
     · grep 0.2%
     · introspect 0.2%
     · knowledge 0.6%
     · read 0.3%
     · shell 0.2%
     · subagent 0.3%
     · todo_list 0.4%
     · use_aws 0.2%
     · web_fetch 0.1%
     · web_search 0.1%
     · write 0.2%

        
    

For example, you can create a new file to store your context as follows:

    

        
        
echo "I am an Arm Linux developer. I prefer Ubuntu and other Debian based distributions. I don't use any x86 computers so please provide all information assuming I'm working on Arm Linux. Sometimes I use macOS and Windows on Arm, but please only provide information about these operating systems when I ask for it." > ~/.kiro/context.md

    

When you invoke kiro-cli chat, you can confirm your context information was read by loading it and asking about it.

Load the context file:

    

        
        
/context add ~/.kiro/context.md

    

Confirm the context file was read:

    

        
        
did you read my context information?

    

The response confirms the context file was read, and is similar to:

    

        
        Yes, I read your context information. Here's what I picked up:
  
  - You're an Arm Linux developer who prefers Ubuntu/Debian-based distributions.
  - You don't use x86 computers, so I'll default to aarch64/arm64 for any architecture-specific
  guidance.
  - I'll only bring up macOS or Windows on Arm if you specifically ask about them.
  
  Let me know how I can help!

        
    

Ask questions like “How do I install the AWS CLI?” to verify that the answers match the provided context.

Change the model Kiro uses

When you start kiro-cli chat, the model is printed:

    

        
        Model: Auto (/model to change)

        
    

Use the /model command to list other available models:

    

        
        
/model

    

The output is similar to:

    

        
        ❯ auto                 1.00x credits    Models chosen by task for optimal usage and consistent q...
  claude-sonnet-4.6    1.30x credits    Claude Sonnet 4.6 model with 1M context window
  claude-opus-4.5      2.20x credits    Claude Opus 4.5 model
  claude-sonnet-4.5    1.30x credits    Claude Sonnet 4.5 model
  claude-sonnet-4      1.30x credits    Hybrid reasoning and coding for regular use
  claude-haiku-4.5     0.40x credits    The latest Claude Haiku model
  deepseek-3.2         0.25x credits    Experimental preview of DeepSeek V3.2
  minimax-m2.5         0.25x credits    MiniMax M2.5 model
(+3 more)

        
    

Use the arrow keys to select the model you want to use.

You can ask Kiro to set the default model for future sessions.

Configure the Arm MCP Server for Kiro CLI

You can use a Model Context Protocol (MCP) such as the Arm MCP Server with Kiro CLI.

The Arm MCP Server provides AI assistants with tools and knowledge for Arm architecture development, migration, and optimization. You can configure the Arm MCP Server locally using Docker.

First, pull the MCP server image to your local machine:

    

        
        
docker pull armlimited/arm-mcp:latest

    

You also need Docker running on the system. For instructions, see the Docker install guide .

Modify the file ~/.kiro/settings/mcp.json to add the Arm MCP Server via a Docker container.

To analyze a local codebase, use a -v command to mount a volume to the Arm MCP Server /workspace folder so it can access code you want to analyze with migrate-ease and other tools.

Replace the path /path/to/your/workspace with the path to your local codebase:

    

        
        
{
  "mcpServers": {
    "arm_mcp_server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v",
        "/path/to/your/workspace:/workspace",
        "-v",
        "/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro",
        "-v",
        "/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro",
        "armlimited/arm-mcp:latest"
      ],
      "env": {},
      "timeout": 60000
    }
  }
}

    

To enable Arm Performix features through the Arm MCP Server, replace /path/to/your/ssh/private_key and /path/to/your/ssh/known_hosts with the SSH private key and known_hosts file used for your target device.

(Optional) Use an alternative containerization tool

You can use other containerization tools besides Docker that are free and don’t require licenses, such as Podman, Finch, Colima, and Rancher Desktop. Choose one of the following options and use its CLI in place of docker to configure the Arm MCP Server.

    

        
        
podman pull armlimited/arm-mcp:latest

    

    

        
        
{
  "mcpServers": {
    "arm_mcp_server": {
      "command": "podman",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v", "/path/to/your/workspace:/workspace",
        "-v", "/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro",
        "-v", "/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro",
        "armlimited/arm-mcp:latest"
      ],
      "env": {},
      "timeout": 60000
    }
  }
}

    

    

        
        
finch pull armlimited/arm-mcp:latest

    

    

        
        
{
  "mcpServers": {
    "arm_mcp_server": {
      "command": "finch",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v", "/path/to/your/workspace:/workspace",
        "-v", "/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro",
        "-v", "/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro",
        "armlimited/arm-mcp:latest"
      ],
      "env": {},
      "timeout": 60000
    }
  }
}

    

    

        
        
docker pull armlimited/arm-mcp:latest

    

    

        
        
{
  "mcpServers": {
    "arm_mcp_server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v", "/path/to/your/workspace:/workspace",
        "-v", "/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro",
        "-v", "/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro",
        "armlimited/arm-mcp:latest"
      ],
      "env": {},
      "timeout": 60000
    }
  }
}

    

    

        
        
docker pull armlimited/arm-mcp:latest

    

    

        
        
{
  "mcpServers": {
    "arm_mcp_server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v", "/path/to/your/workspace:/workspace",
        "-v", "/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro",
        "-v", "/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro",
        "armlimited/arm-mcp:latest"
      ],
      "env": {},
      "timeout": 60000
    }
  }
}

    

Verify that the Arm MCP Server is working

Start Kiro CLI chat from your local shell and list the tools from the MCP server to verify it’s working:

    

        
        
kiro-cli chat

    

Use the /tools command to list the available tools:

    

        
        
/tools

    

You’ll see the Arm MCP Server tools listed in the output. If the arm-mcp server says it’s still loading, wait a moment and run /tools again.

Use Arm prompt files with the Arm MCP Server

The Arm MCP Server provides a rich set of tools and knowledge base, but to make the best use of it, you should pair it with Arm-specific prompt files. These prompt files supply task-oriented context, best practices, and structured workflows that guide the agent in using MCP tools more effectively across common Arm development tasks.

Get the prompt files

Browse the agent integrations directory for Kiro to find prompt files for specific use cases:

• Arm migration ( arm-migration.md ): Helps the agent systematically migrate applications from x86 to Arm, including dependency analysis, compatibility checks, and optimization recommendations.

Each prompt file is a Markdown configuration that you can reference in your Kiro CLI sessions to enable more targeted, task-specific assistance.

If you’re facing issues or have questions, reach out to mcpserver@arm.com .

Next steps

You’re now ready to use Kiro CLI with the Arm MCP Server for Arm-specific development assistance.

For an AI-assisted x86-to-Arm migration walkthrough, see Automate x86-to-Arm application migration using the Arm MCP Server .