We introduce AMDKernelVault, an open corpus and training framework for optimizing HIP and Triton kernels on recent AMD CDNA GPUs. Existing LLM-based kernel agents are predominantly designed for CUDA and NVIDIA hardware and often rely on repeated calls to frontier models for generation, reflection, and optimization. To address this gap, we develop HIPKernelGen and TritonKernelGen, agent-driven pipelines that translate PyTorch references into GPU kernels, compile and validate candidates under ROCm, and profile their latency on AMD hardware. AMDKernelVault contains 62,153 execution-verified HIP kernel samples, 2,377 production-grounded ROCm Libraries QA entries, and 39,893 Triton kernels. To demonstrate the corpus’s utility, we specialize Qwen3-8B through supervised fine-tuning and execution-aware reinforcement learning. Under fixed evaluation budgets and identical agent settings, the resulting model achieves the highest correctness among the evaluated models on PyTorch-to-HIP (34.0% Pass@1), TritonBench-G (33.2% Corr@3), and ROCmBench (41.94% Corr@3), while running locally on AMD hardware. These advantages are specific to the reported correctness metrics and do not extend uniformly to compilation accuracy or execution speed. The corpus and documentation are publicly available at https://huggingface.co/datasets/amd/AIG-Datasets.

Evolutionary agentic systems intensify the trade-off between computational efficiency and reasoning capability by repeatedly invoking large language models (LLMs) during inference. This setting raises a central question: how can an agent dynamically select an LLM that is sufficiently capable for the current generation step while remaining computationally efficient? While model cascades offer a practical mechanism for balancing this trade-off, existing routing strategies typically rely on static heuristics or external controllers and do not explicitly account for model uncertainty. We introduce AdaptEvolve: Adaptive LLM Selection for Multi-LLM Evolutionary Refinement within an evolutionary sequential refinement framework that leverages intrinsic generation confidence to estimate real-time solvability. Empirical results show that confidence-driven selection yields a favorable Pareto frontier, reducing total inference cost by an average of 37.9% across benchmarks while retaining 97.5% of the upper-bound accuracy of static large-model baselines.

Machine learning practitioners routinely rely on public code repositories accompanying research papers, libraries, and open-source projects to evaluate, baseline, or build upon prior work. Yet getting such repositories to run and reproduce results often involves non-trivial effort, and is especially challenging when the target software and hardware stack differs from the one the original code was developed on. A prominent instance is running repositories originally built for CUDA-enabled hardware on AMD GPUs supporting the ROCm software stack. Here, successful installation alone is not a sufficient signal: a range of subtler issues may cause the code to either fail outright or silently fall back to inefficient execution. We present Repo2ROCm, an agentic system that migrates CUDA-centric ML repositories to ROCm in an automated manner. Repo2ROCm reconstructs a ROCm-compatible environment, adapts hardware-specific assumptions, executes a real workload, and confirms GPU-backed execution emitting auditable artifacts at every step (environment specs, source patches, execution logs, and verification evidence). We evaluate on ResearchBench, 60 repositories belonging to recent papers from top AI conferences. While only 18/60 run out of the box, Repo2ROCm reaches verified functional reproduction for 59/60 (3.3× improvement). Against popular general-purpose coding agents on a curated ten-repository diagnostic set (with all agents using the same Claude Sonnet 4 backbone), Repo2ROCm achieves the highest Portability Fidelity Score (PFS), a measure of how faithfully a run preserves the accelerator-critical execution path, real workload, and verified environment, scoring 77.3 vs. 61.4 (Claude Code), 58.7 (Mini-SWE-Agent), and 40.3 (Cursor Agent).

The key-value (KV) cache in transformer models is a critical component for efficient decoding or inference, yet its memory demands scale poorly with sequence length, posing a major challenge for scalable deployment of large language models. Among several approaches to KV cache compression, quantization of key and value activations has been widely explored. Most KV cache quantization methods still need to manage sparse and noncontiguous outliers separately. To address this, we introduce TaDA, a training-free recipe for KV cache compression with quantization precision that adapts to error sensitivity across layers and a mean centering to eliminate separate outlier handling. Our approach yields substantial accuracy improvements for multiple models supporting various context lengths. Moreover, our approach does not need to separately manage outlier elements—a persistent hurdle in most traditional quantization methods. Experiments on standard benchmarks demonstrate that our technique reduces KV cache memory footprint to 27% of the original 16-bit baseline while achieving comparable accuracy. Our method paves the way for scalable and high-performance reasoning in language models by potentially enabling inference for longer context length models, reasoning models, and longer chain of thoughts.