AWS Graviton migration with Kiro CLI and the Arm MCP server

AWS Graviton processors offer price-performance benefits, but migrating applications from x86 to the Arm architecture can feel like extra work. You might wonder about compatibility issues, performance implications, or simply where to start with the migration process.

The Arm MCP server paired with Kiro CLI makes a good migration companion. Instead of manually researching compatibility matrices, hunting through documentation, or guessing about architecture-specific dependencies, you get an AI assistant that understands Arm migration.

This article explains how to set up Kiro CLI with the Arm MCP server and discover how it transforms migration questions into simple conversations. You'll see how to verify Docker image compatibility, get guidance on software porting considerations, and leverage tools that detect x86-specific code in your applications.

By the end, you'll have an environment that makes Graviton migration feel less like detective work. Whether you're planning your first migration or optimizing an existing Arm deployment, this setup will save time and increase confidence in the migration process.

Quick setup

Before diving into Graviton migration, you need Kiro CLI installed on your system.

Before installing Kiro CLI, make sure you have unzip installed.

For Ubuntu run:

sudo apt install unzip -y

Use the package manager for other Linux distributions or Homebrew on macOS.

Installing Kiro CLI

The fastest way to get Kiro CLI running is with a single curl command that handles the entire installation process. This method works seamlessly on both Arm Linux and macOS systems.

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

The installer will download the appropriate version for your system and prompt you about updating your shell configuration.

If you're on macOS you can use Homebrew as an alternative installation option:

brew install kiro-cli

Verifying your installation

Once the installation completes, confirm everything is working by checking the version:

kiro-cli version

You should see output similar to this:

kiro-cli 1.23.1

This confirms Kiro CLI is properly installed and ready to use. The version number may be different depending on when you install it, but seeing any version output means you're good to proceed.

Docker prerequisite

You'll also need Docker running on your system since the Arm MCP server runs as a containerized service. If you don't have Docker installed yet, you can download it from the Docker website. The Arm MCP server image will be pulled automatically during the configuration step, so you don't need to download anything manually right now.

If you are running on Linux, you can use the simple install:

curl -fsSL get.docker.com -o get-docker.sh && sh get-docker.sh
sudo usermod -aG docker $USER ; newgrp docker

MCP server configuration

Now that Kiro CLI is installed, you need to connect it to the Arm MCP server that provides the specialized knowledge and tools for Graviton migration. This server runs as a Docker container and integrates with Kiro CLI through a simple configuration file.

Setting up the Arm MCP server

The Arm MCP server comes pre-packaged as a Docker image. Pull the latest version with this command:

docker pull armlimited/arm-mcp:latest

This downloads the container image, which includes the Arm-specific knowledge base, migration tools, and compatibility databases you'll need for your Graviton migration projects.

Configuring the connection

Kiro CLI connects to MCP servers through a configuration file that defines how to launch and communicate with each server.

Create the configuration directory and file:

mkdir -p ~/.kiro/settings

Use an editor to create the MCP configuration file at ~/.kiro/settings/mcp.json with this content:

{
  "mcpServers": {
    "arm_mcp_server": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v", "/home/ubuntu:/workspace",
        "--name", "arm-mcp",
        "armlimited/arm-mcp:latest"
      ],
      "env": {},
      "timeout": 60000
    }
  }
}

This configuration tells Kiro CLI to launch the Arm MCP server using Docker with several important settings. The --pull=always flag ensures you're always using the latest version of the server, while the volume mount (-v /home/ubuntu:/workspace) gives the server access to your directory so it can analyze your codebase directly. You can modify the mounted directory for your project.

Understanding volume mounting

The volume mounting is important for migration work. When you run Kiro CLI from within a project directory, the Arm MCP server can examine your actual code files, Dockerfiles, dependency manifests, and build configurations. This enables it to provide specific recommendations about your codebase rather than general migration advice.

For example, if you're working on a Node.js application and run Kiro CLI from your project root, the server can analyze your package.json file to identify potentially problematic dependencies or suggest Arm-optimized alternatives.

Verification and connection testing

With your configuration in place, it's time to verify that everything is working correctly. This verification process ensures both Kiro CLI and the Arm MCP server are properly connected and ready for your migration work.

Start Kiro CLI to initiate the connection to the Arm MCP server:

kiro-cli

The first startup may take a moment as Docker starts the container and initializes the connection. You'll see Kiro CLI's prompt once everything is ready:

⚠ 0 of 1 mcp servers initialized. Servers still loading:
 - arm_mcp_server
⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀     ⢀⣴⣶⣶⣦⡀⠀⠀⠀⢀⣴⣶⣦⣄⡀⠀⠀⢀⣴⣶⣶⣦⡀⠀⠀⢀⣴⣶⣶⣶⣶⣶⣶⣶⣶⣶⣦⣄⡀⠀⠀⠀⠀⠀⠀⢀⣠⣴⣶⣶⣶⣶⣶⣦⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀    ⢰⣿⠋⠁⠈⠙⣿⡆⠀⢀⣾⡿⠁⠀⠈⢻⡆⢰⣿⠋⠁⠈⠙⣿⡆⢰⣿⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠻⣦⠀⠀⠀⠀⣴⡿⠟⠋⠁⠀⠀⠀⠈⠙⠻⢿⣦⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⣿⣇⣴⡿⠋⠀⠀⠀⢀⣼⠇⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⢠⣤⣤⣤⣤⣄⠀⠀⠀⠀⣿⡆⠀⠀⣼⡟⠀⠀⠀⠀⣀⣀⣀⠀⠀⠀⠀⢻⣧⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⣿⡿⠋⠀⠀⠀⢀⣾⡿⠁⠀⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⢸⣿⠉⠉⠉⣿⡇⠀⠀⠀⣿⡇⠀⣼⡟⠀⠀⠀⣰⡿⠟⠛⠻⢿⣆⠀⠀⠀⢻⣧⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⠙⠁⠀⠀⢀⣼⡟⠁⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⢸⣿⣶⣶⡶⠋⠀⠀⠀⠀⣿⠇⢰⣿⠀⠀⠀⢰⣿⠀⠀⠀⠀⠀⣿⡆⠀⠀⠀⣿⡆
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠹⣷⡀⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣼⠟⠀⢸⣿⠀⠀⠀⢸⣿⠀⠀⠀⠀⠀⣿⡇⠀⠀⠀⣿⡇
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⠀⣠⡀⠀⠀⠹⣷⡄⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⠀⣤⣄⠀⠀⠀⠀⠹⣿⡅⠀⠀⠸⣿⠀⠀⠀⠸⣿⠀⠀⠀⠀⠀⣿⠇⠀⠀⠀⣿⠇
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⣾⡟⣷⡀⠀⠀⠘⣿⣆⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⠀⣿⡟⣷⡀⠀⠀⠀⠘⣿⣆⠀⠀⢻⣧⠀⠀⠀⠹⣷⣦⣤⣤⣾⠏⠀⠀⠀⣼⡟
⠀⠀⠀⠀⠀⠀⠀    ⢸⣿⠀⠀⠀⠀⣿⡇⠹⣷⡀⠀⠀⠈⢻⡇⠀⢸⣿⠀⠀⠀⠀⣿⡇⢸⣿⠀⠀⠀⠀⣿⡇⠹⣷⡀⠀⠀⠀⠈⢻⡇⠀⠀⢻⣧⠀⠀⠀⠀⠉⠉⠉⠀⠀⠀⠀⣼⡟
⠀⠀⠀⠀⠀⠀⠀    ⠸⣿⣄⡀⢀⣠⣿⠇⠀⠙⣷⡀⠀⢀⣼⠇⠀⠸⣿⣄⡀⢀⣠⣿⠇⠸⣿⣄⡀⢀⣠⣿⠇⠀⠙⣷⡀⠀⠀⢀⣼⠇⠀⠀⠀⠻⣷⣦⣄⡀⠀⠀⠀⢀⣠⣴⣾⠟
⠀⠀⠀⠀⠀⠀⠀    ⠀⠈⠻⠿⠿⠟⠁⠀⠀⠀⠈⠻⠿⠿⠟⠁⠀⠀⠈⠻⠿⠿⠟⠁⠀⠀⠈⠻⠿⠿⠟⠁⠀⠀⠀⠈⠻⠿⠿⠟⠁⠀⠀⠀⠀⠀⠈⠙⠻⠿⠿⠿⠿⠟⠋⠁

╭─────────────────────────────── Did you know? ────────────────────────────────╮
│                                                                              │
│   If you want to file an issue to the Kiro CLI team, just tell me, or run    │
│                                kiro-cli issue                                │
│                                                                              │
╰──────────────────────────────────────────────────────────────────────────────╯

Model: Auto (/model to change)


> 

Now verify the Arm MCP server connection by listing its available tools:

/tools

You should see output listing the available MCP server tools. The exact tool names and descriptions may vary slightly depending on the version, but you should see several tools related to Arm migration and compatibility analysis.

This output confirms that Kiro CLI has successfully connected to the Arm MCP server and can access all its migration tools.

Knowledge base exploration

Now that you have Kiro CLI connected to the Arm MCP server, let's explore its knowledge capabilities through some migration scenarios. Rather than diving straight into code analysis, you'll start by asking the kinds of questions that come up during real migration planning sessions.

With this setup, you can have natural conversations about technical topics. Instead of hunting through documentation or trying to piece together information from multiple sources, you ask your questions and get Arm-focused answers.

Understanding Graviton software porting considerations

Let's start with a fundamental question that every migration project faces:

What are the key software porting considerations when migrating applications to AWS Graviton processors?

The Arm MCP server provides a detailed response covering the essential areas you need to evaluate. The response includes guidance on dependency compatibility, performance optimization opportunities, and common migration patterns. You'll receive specific recommendations about compiler flags, library alternatives, and testing strategies that apply directly to your Graviton migration project.

This response demonstrates the MCP server's understanding of migration challenges and provides actionable guidance you can immediately apply to your projects. Notice how it covers both technical requirements and practical implementation considerations.

Checking software compatibility

You can also ask about specific software and check if it's available on Graviton.

For teams working with Microsoft technologies, .NET compatibility is often a primary concern:

What versions of .NET are compatible with AWS Graviton processors, and are there any specific considerations for .NET applications?

The server provides specific version information and migration guidance. You'll receive details about .NET 6 and later versions' native Arm64 support, performance optimization recommendations, and guidance on handling dependencies that may need attention during migration. You can even ask for a recommended version and find out that it may be better to go with .NET 8 because it has a longer support window compared to .NET 9.

This level of detail helps you make informed decisions about software versions.

Getting Aperf installation guidance

For performance analysis and optimization work, you might need specialized tools:

How do I install and use Aperf for performance analysis on AWS Graviton instances?

The server provides installation and usage guidance. You'll receive step-by-step installation instructions and configuration recommendations on Graviton instances.

These three examples show the breadth and depth of knowledge available through the Arm MCP server. Whether you're planning a migration, troubleshooting compatibility issues, or optimizing performance, you have access to a knowledge base tailored for Arm and Graviton environments.

Advanced migration tools

Beyond answering migration questions, the Arm MCP server provides tools that analyze your actual codebase and infrastructure configurations. These capabilities transform abstract migration advice into concrete, actionable recommendations specific to your project.

Dockerfile analysis

One of the most useful tools for containerized applications is the Dockerfile compatibility checker. Instead of manually reviewing your container configurations for Arm compatibility issues, you can get automated analysis with specific recommendations.

When you have a Dockerfile in your current project directory, you can ask the MCP server to analyze it for potential Arm compatibility issues. The server examines your Dockerfile and provides detailed feedback about base image compatibility, identifies potential problems like x86-specific binaries or native libraries, and suggests optimization opportunities for multi-architecture builds.

This analysis saves time and provides specific line-by-line guidance. The MCP server understands common patterns that cause Arm compatibility issues and suggests practical solutions that fit into existing development workflows.

x86-specific dependencies

For applications with complex dependency trees, the server can scan your codebase to identify potentially problematic x86-specific dependencies before you encounter runtime issues.

The server can analyze your project files and dependency manifests to identify compatibility concerns across your entire technology stack. It examines package files, build configurations, and scripts to flag dependencies that may need attention before moving to Graviton. The analysis provides specific version recommendations and alternative packages, along with estimated migration effort, making the migration process more predictable.

Conclusion

You've learned how Kiro CLI paired with the Arm MCP server transforms AWS Graviton migration into a guided conversation that makes it easier to get started.

The setup you've completed gives you access to migration knowledge, from high-level architectural considerations to specific dependency compatibility issues. The automated tools for Dockerfile analysis and x86 dependency detection catch potential problems before they impact your deployment timeline, while the knowledge base provides context and solutions for the challenges you'll encounter.

The combination of conversational AI assistance and analysis tools represents a shift in how migration projects can be approached. You can now iterate quickly, validate assumptions immediately, and make informed decisions with confidence.

Get started with AWS T4g instances

AWS T4g instances powered by Graviton processors are available in the AWS Free Tier through December 31, 2026. This gives you an extended opportunity to test your applications, validate performance improvements, and gain hands-on experience with Graviton without incurring costs.

The free tier includes 750 hours per month of t4g.micro instances, providing ample time to experiment with your migration workflow and validate the guidance you receive from the Arm MCP server. You can use this to test containerized applications, benchmark performance differences, and refine your migration approach before committing to production deployments.

For complete details about T4g instance specifications and free tier eligibility, visit the AWS T4g instances page.

Ready to dive deeper into Arm development and migration capabilities? The Arm MCP server offers additional tools and knowledge bases that can accelerate your Graviton adoption journey. Explore the documentation, examples, and features to continue learning.