{"slug": "hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus", "title": "Hyperloom - Autonomous Agentic Inference Optimization for AMD GPUs", "summary": "AMD introduced ROCm Hyperloom, an open-source agentic system that automates inference workload optimization for AMD Instinct GPUs, reducing optimization time from weeks to hours. The system uses a multi-agent architecture with components like TraceLens-Agent, GEAK, and Arbor to profile, analyze, plan, optimize, and validate workloads autonomously.", "body_md": "# Hyperloom - Autonomous Agentic Inference Optimization for AMD GPUs[#](#hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus)\n\nAMD is excited to introduce [ROCm™ Hyperloom](https://github.com/AMD-AGI/Hyperloom), a new open-source, agentic system aimed at automating the time-consuming task of optimizing end-to-end inference workloads. Using Hyperloom reduces the time to optimize an end-to-end workload from weeks to hours, saving time and enabling valuable resources to be allocated to other critical tasks. By combining various tools into an autonomous optimization loop, Hyperloom allows you to get the best performance out of your model and custom configuration on AMD Instinct GPUs.\n\nIn this blog, you’ll learn what Hyperloom is, how its component stack fits together, how the optimization loop operates, and how to get started with Hyperloom to optimize your own inference workloads.\n\n## Why choose Hyperloom[#](#why-choose-hyperloom)\n\nThe standard inference optimization workflow requires specialized skills to manually execute every step: profile the workload, analyze the output, identify potential optimizations, implement changes, test for correctness, benchmark, and decide whether to keep or discard the change. A single workload optimization cycle can take weeks of effort to complete and often results in optimizations that aren’t transferable to different workloads or model configurations. Beyond time, the bigger cost is coverage. A human engineer will explore the highest-confidence optimizations first and stop when they hit diminishing returns or due to time constraints.\n\nHyperloom addresses both of these problems, reducing the time to optimize a full end-to-end workload down from potentially weeks to hours, while systematically exploring the solution space to identify potential optimizations. This comprehensive search may identify obscure and unintuitive fixes, as well as cross-repo patches that an engineer would be unlikely to attempt, while running correctness checks on every candidate before acceptance.\n\n## Hyperloom, a fully autonomous inference optimization engine[#](#hyperloom-a-fully-autonomous-inference-optimization-engine)\n\nHyperloom is an autonomous AI workload optimization platform that eliminates the manual, time-intensive process of profiling, analyzing, and tuning models. It consists of a closed loop architecture, Profile → Analyze → Plan → Optimize → Validate, that iteratively improves the performance of your inference workloads.\n\nFigure 1: An overview of the Hyperloom architecture and optimization flow.\n\nThe system runs as a multi-agent architecture, completely automating the entire process. All you have to do is provide your workload and configuration files and let Hyperloom do the rest. Figure 1 provides an overview of the full end-to-end optimization workflow, breaking it down into distinct stages and highlighting the components that are critical in each stage. First, the TraceLens-Agent identifies bottlenecks and potential optimizations using TraceLens, which leverages Magpie and IntelliKit for trace collection and low-level GPU profiling respectively. Next, the self-evolving optimization engine employs GEAK and Arbor in parallel to improve the performance of individual kernels as well as the full end-to-end workload.\n\n### The component stack[#](#the-component-stack)\n\nHyperloom integrates and orchestrates five independent, purpose-built components to accomplish its goal. Each of these plays a crucial role in the optimization loop.\n\n#### TraceLens-Agent – Automated GPU Performance Analysis[#](#tracelens-agent-automated-gpu-performance-analysis)\n\n[TraceLens](https://github.com/AMD-AGI/TraceLens) is a Python SDK that automates performance analysis from GPU trace files, ingesting the outputs from Magpie to generate hierarchical performance breakdowns, roofline estimates, and a prioritized list of optimization opportunities. The TraceLens-Agent extends the library with an agentic analysis layer. Given a profiling artifact, the TraceLens-Agent identifies slow kernels, system bottlenecks, missing fusions; and generates a ranked bridge plan of proposed optimizations and validates that accepted fixes resolve the original bottleneck without introducing regressions.\n\n##### Magpie – GPU Kernel Evaluation and End-to-End Benchmarking[#](#magpie-gpu-kernel-evaluation-and-end-to-end-benchmarking)\n\n[Magpie](https://github.com/AMD-AGI/Magpie) is a lightweight GPU kernel evaluation framework that serves as the profiling and benchmarking backbone for Hyperloom, assessing kernel correctness, robustness, and performance across diverse execution environments. It runs the workload, generates traces, and produces structured JSON results that the rest of the pipeline consumes.\n\n##### IntelliKit – A Toolbox for Profiling and Validation[#](#intellikit-a-toolbox-for-profiling-and-validation)\n\n[IntelliKit](https://github.com/AMDResearch/intellikit) is a comprehensive suite of LLM-friendly GPU tooling that transforms traditional profiling workflows by providing conversational interfaces to GPU performance data, source mapping, and validation capabilities. Although not directly accessed by Hyperloom, IntelliKit serves Magpie and GEAK by providing low-level GPU profiling tools. The five specialized tools – Kerncap, Metrix, Linex, Nexus, and Accordo – decode complexity into human-readable insights, enable AI agent integration through clean Python APIs with MCP server support, and answer specific developer questions through conversational workflows.\n\n#### GEAK – Autonomous GPU Kernel Optimization[#](#geak-autonomous-gpu-kernel-optimization)\n\n[GEAK](https://github.com/AMD-AGI/GEAK) is an autonomous, agent-driven framework that orchestrates end-to-end GPU kernel optimization through metric-driven patch generation, multi-agent exploration, and iterative improvement cycles backed by profiling and testing. Given a kernel or a live model-serving stack such as SGLang or vLLM, GEAK searches for bottlenecks, generates and tunes implementations across backends such as Triton, FlyDSL, HIP, CK, and TileLang, and validates the result on the actual system. GEAK includes a hierarchical multi-agent architecture: Director → Architect → Expert, with dynamic JS workflow. It also has a knowledge system, as well as long-horizon optimization, self-evolution with knowledge accumulation and in-session and cross-session memory management.\n\n#### Arbor – Self-Evolving Optimization Search[#](#arbor-self-evolving-optimization-search)\n\n[Arbor](https://arxiv.org/abs/2606.12563) intelligently explores the search space following an iterative Think → Decide → Implement → Benchmark agentic loop. It uses a tree-based cognition layer with dynamic agents, long-horizon campaigns, and self-evolving optimization guided by a curated knowledge base of hardware learnings, pitfalls, and prior campaign artifacts.\n\n#### The Hyperloom Orchestrator – Pulling It All Together[#](#the-hyperloom-orchestrator-pulling-it-all-together)\n\nThe Hyperloom inference optimizer skill wires the stack into a single end-to-end pipeline. It translates a natural language workload description into CLI parameters, installs dependencies, launches the optimization loop, and monitors progress until the run completes or the time limit is hit. It scores each action within the optimization loop by expected gain and estimated cost, comparing results to real workloads.\n\n#### AgentKernelArena – Comparing AI Agents[#](#agentkernelarena-comparing-ai-agents)\n\n[AgentKernelArena](https://github.com/AMD-AGI/AgentKernelArena) is not part of Hyperloom or its optimization loop. It serves as a useful platform for A/B testing and comparing Hyperloom’s optimization agents on standardized tasks. The tool evaluates agents side-by-side in an isolated workspace, and scores them using objective, reproducible metrics that measure compilation, correctness, and performance.\n\n## Getting Started With Hyperloom[#](#getting-started-with-hyperloom)\n\nHyperloom is public and available now, allowing you to optimize your workloads on your own AMD GPU node.\n\n### Support Matrix[#](#support-matrix)\n\nHyperloom currently supports the following components:\n\nComponent |\nSupport |\n|---|---|\nGPU |\nMI300X, MI325X, MI355X |\nOperating System |\nUbuntu 22.04 and 24.04 |\nROCm version |\n7.2 |\nInference Frameworks |\nSGLang >= 0.5.12, vLLM >= 0.21.0 |\nKernel Languages |\nHIP, Triton, FlyDSL |\nPython |\n>= 3.10 |\n\n### Running your own Hyperloom session[#](#running-your-own-hyperloom-session)\n\nFollow along with these instructions to get started with Hyperloom. Prepare a dedicated clean directory first, then open that directory in Cursor, Claude Code, or Codex before running the install command.\n\n#### Step 1 – Installing Hyperloom[#](#step-1-installing-hyperloom)\n\nYou can install Hyperloom using pip:\n\n```\npython3 -m pip install \\\n  https://github.com/AMD-AGI/Hyperloom/releases/download/v1.0.0a1/hyperloom_inference_optimizer-1.0.0a1-py3-none-any.whl \\\n  --target .\n```\n\n#### Step 2 – Setting up Hyperloom[#](#step-2-setting-up-hyperloom)\n\nAfter installation is completed, set up Hyperloom by running the setup skill in the same workspace as installation:\n\n```\n/hyperloom-setup\n```\n\nThis will launch an interactive setup session where you will be prompted to set up Hyperloom for your environment and use case.\n\n#### Step 3 – Running Hyperloom[#](#step-3-running-hyperloom)\n\nOnce Hyperloom is fully set up, you can run your first optimization! Simply tell your agent to optimize your model using Hyperloom. For example:\n\n```\nOptimize Minimax M3 MXFP8 with Hyperloom\n```\n\nThis will start a session where you have the option to get regular updates on Hyperloom’s progress. Once the optimization run reaches the allotted time limit, a comprehensive report will be generated, detailing the optimizations and expected performance gain that Hyperloom was able to achieve.\n\nFor detailed documentation, installation instructions, and how-to guides, have a look at the [Hyperloom page on ROCm Docs](https://rocm.docs.amd.com/projects/hyperloom/en/latest/index.html), or follow along with the [Quick-start guide](https://github.com/AMD-AGI/Hyperloom/blob/main/examples/README.md).\n\n## Summary[#](#summary)\n\nIn this blog, we provided an overview of Hyperloom and its core components, as well as instructions on how to install and get started with Hyperloom. Hyperloom optimizes your full end-to-end inference workloads, automating the full optimization loop from profiling and analysis to kernel optimization and validation. This cuts the optimization time down to hours, a task that previously required weeks of specialized engineering effort, allowing you to allocate your most valuable resources to other critical tasks. For more in-depth information, take a look at the Hyperloom documentation on [GitHub](https://github.com/AMD-AGI/Hyperloom) or [ROCm Docs](https://rocm.docs.amd.com/projects/hyperloom/en/latest/index.html), or view one of the related blogs. Hyperloom is completely open-source and available today – try it out on your workload to get the most out of your Instinct GPU!\n\n## Additional Resources[#](#additional-resources)\n\nExplore other recent developments and releases by AMD in the [ROCm.ai: The AI-Native Developer Experience for Building on AMD](https://www.amd.com/en/blogs/2026/rocm-ai-the-ai-native-developer-experience-for-building.html) blog. Or if you would like to learn more about Hyperloom’s components, take a look at the recent [GEAK](https://www.amd.com/en/developer/resources/technical-articles/2026/geak-v4.html) and [TraceLens](https://rocm.blogs.amd.com/software-tools-optimization/tracelens/README.html) blogs, or take a deep dive into [Arbor](https://arxiv.org/abs/2606.12563) or [AgentKernelArena](https://arxiv.org/abs/2605.16819) by looking at their respective publications. Also, have a look at the recent [AgentKernelArena](https://rocm.blogs.amd.com/software-tools-optimization/agent-kernel-arena/README.html) blog to learn more about how you can compare various agents in a standardized environment.\n\nTo learn more about Hyperloom, have a look at the [GitHub page](https://github.com/AMD-AGI/Hyperloom) or peruse the [Hyperloom documentation](https://rocm.docs.amd.com/projects/hyperloom/en/latest/index.html).\n\n## Disclaimers[#](#disclaimers)\n\nThe information presented in this document is for informational purposes only and may contain technical inaccuracies, omissions, and typographical errors. The information contained herein is subject to change and may be rendered inaccurate for many reasons, including but not limited to product and roadmap changes, component and motherboard version changes, new model and/or product releases, product differences between differing manufacturers, software changes, BIOS flashes, firmware upgrades, or the like. Any computer system has risks of security vulnerabilities that cannot be completely prevented or mitigated. AMD assumes no obligation to update or otherwise correct or revise this information. However, AMD reserves the right to revise this information and to make changes from time to time to the content hereof without obligation of AMD to notify any person of such revisions or changes. THIS INFORMATION IS PROVIDED ‘AS IS.” AMD MAKES NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE CONTENTS HEREOF AND ASSUMES NO RESPONSIBILITY FOR ANY INACCURACIES, ERRORS, OR OMISSIONS THAT MAY APPEAR IN THIS INFORMATION. AMD SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT WILL AMD BE LIABLE TO ANY PERSON FOR ANY RELIANCE, DIRECT, INDIRECT, SPECIAL, OR OTHER CONSEQUENTIAL DAMAGES ARISING FROM THE USE OF ANY INFORMATION CONTAINED HEREIN, EVEN IF AMD IS EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. AMD, the AMD Arrow logo, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies. © 2026 Advanced Micro Devices, Inc. All rights reserved", "url": "https://wpnews.pro/news/hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus", "canonical_source": "https://rocm.blogs.amd.com/software-tools-optimization/hyperloom/README.html", "published_at": "2026-07-23 00:00:00+00:00", "updated_at": "2026-07-23 19:56:41.250639+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-infrastructure", "ai-tools", "ai-agents", "ai-products"], "entities": ["AMD", "ROCm Hyperloom", "AMD Instinct GPUs", "TraceLens", "TraceLens-Agent", "GEAK", "Arbor", "Magpie"], "alternates": {"html": "https://wpnews.pro/news/hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus", "markdown": "https://wpnews.pro/news/hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus.md", "text": "https://wpnews.pro/news/hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus.txt", "jsonld": "https://wpnews.pro/news/hyperloom-autonomous-agentic-inference-optimization-for-amd-gpus.jsonld"}}