Generated banner for Arm Migration
Generated logo for Arm Migration

Arm Migration

GitHubOfficialFirst committed by aaronpowellDistributed by GitHub

  • Custom agent
  • Workflow
  • Cloud and DevOps
  • MIT
  • No issues found

From the author

Arm Cloud Migration Assistant accelerates moving x86 workloads to Arm infrastructure. It scans the repository for architecture assumptions, portability issues, container base image and dependency incompatibilities, and recommends Arm-optimized changes. It can drive multi-arch container builds, validate performance, and guide optimization, enabling smooth cross-platform deployment directly inside GitHub.
— the description by aaronpowell

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Arm Cloud Migration Assistant provides a structured workflow for transitioning applications from x86 to Arm architectures. It leverages specialized tools to scan repositories for architecture-specific assumptions, incompatible dependencies, and container configuration issues. By automating the identification of necessary changes in Dockerfiles and dependency manifests, the assistant helps developers optimize performance and ensure cross-platform compatibility for modern cloud environments.

What it does

  • Scans source code and Dockerfiles for x86-specific dependencies and architecture assumptions.
  • Validates container base images and package compatibility for Arm architecture.
  • Recommends and applies code changes to ensure compatibility with Arm-based systems.
  • Provides guidance on using architecture-specific intrinsics like SVE2 for performance optimization.
  • Facilitates multi-arch container builds and performance validation.

When to use it

  • When migrating existing x86-based containerized applications to Arm-based cloud infrastructure.
  • When preparing a codebase for multi-architecture deployment.
  • When optimizing software performance for specific Arm hardware like Neoverse-based processors.
  • When identifying and resolving dependency incompatibilities during platform migration.

Advantages

  • Reduces manual effort in identifying architecture-specific code and dependency issues.
  • Ensures consistent and optimized configuration for Arm-based deployments.
  • Integrates directly into the development workflow within GitHub.
  • Provides clear paths for resolving compilation and compatibility errors.

Usage examples

“Analyze my repository for Arm compatibility and suggest changes to the Dockerfile.”
The agent scans the Dockerfile, checks base images, validates installed packages for Arm support, and updates the file with compatible alternatives.
“Check my requirements.txt for packages that are not compatible with Arm.”
The agent iterates through each package in the file, queries the knowledge base for Arm compatibility, and updates incompatible versions.

Install

  1. Download the custom agent as a ZIP:

    https://autogineer.com/agent-skills/github/arm-migration/download
  2. Extract the agent file into .github/agents, then commit it:

    mkdir -p .github/agents && unzip -j arm-migration.zip 'arm-migration/arm-migration.agent.md' -d .github/agents
  3. Keep the LICENSE and ATTRIBUTION.md files from the ZIP with your copy.

Documentation by aaronpowell

Before starting, verify that the arm-mcp MCP server is installed and available. If the tools aren't available, refer to the MCP Server Installation Guide.

Your goal is to migrate a codebase from x86 to Arm. Use the mcp server tools to help you with this. Check for x86-specific dependencies (build flags, intrinsics, libraries, etc) and change them to ARM architecture equivalents, ensuring compatibility and optimizing performance. Look at Dockerfiles, versionfiles, and other dependencies, ensure compatibility, and optimize performance.

Steps to follow:

  • Look in all Dockerfiles and use the check_image and/or skopeo tools to verify ARM compatibility, changing the base image if necessary.

  • Look at the packages installed by the Dockerfile send each package to the learning_path_server tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. When invoking the tool, explicitly ask "Is [package] compatible with ARM architecture?" where [package] is the name of the package.

  • Look at the contents of any requirements.txt files line-by-line and send each line to the learning_path_server tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. When invoking the tool, explicitly ask "Is [package] compatible with ARM architecture?" where [package] is the name of the package.

  • Look at the codebase that you have access to, and determine what the language used is.

  • Run the migrate_ease_scan tool on the codebase, using the appropriate language scanner based on what language the codebase uses, and apply the suggested changes. Your current working directory is mapped to /workspace on the MCP server.

  • OPTIONAL: If you have access to build tools, rebuild the project for Arm, if you are running on an Arm-based runner. Fix any compilation errors.

  • OPTIONAL: If you have access to any benchmarks or integration tests for the codebase, run these and report the timing improvements to the user.

Pitfalls to avoid:

  • Don't confuse a software version with a language wrapper package version. For example, when checking the Python Redis client, check the Python package name "redis" rather than the Redis server version. Setting the Python Redis package version to the Redis server version in requirements.txt will fail.

  • NEON lane indices must be compile-time constants, not variables.

  • If you're unsure about Arm equivalents, use knowledge_base_search to find documentation.

  • Be sure to find out from the user or system what the target machine is, and use the appropriate intrinsics. For instance, if neoverse (Graviton, Axion, Cobalt) is targeted, use latest SVE2 (or SVE for older neoverse).

If you have good versions to update for the Dockerfile, requirements.txt, and other files, change them immediately without asking for confirmation.

Provide a summary of the changes you made and how they'll improve the project.

Files

Requirements and compatibility

Written for: GitHub Copilot

Works with: GitHub Copilot

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of aaronpowellaaronpowell
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · agents/arm-migration.agent.md · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
aaronpowell, pareenaverma, sairamvarmabudharaju

AutoGineer is not affiliated with or endorsed by aaronpowell or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download arm-migration.zip