### Clone repository and run quickstart setup Source: https://github.com/amd-agi/agentkernelarena/blob/main/README.md Clones the AgentKernelArena repository, verifies the container runtime and GPU with `make docker-smoke`, installs Claude Code via its native installer, authenticates it, selects a quickstart config for the physical GPU, and runs one task. The npm installation path requires Node.js 22+ and npm. Running `make docker-run` without `CONFIG` defaults to the MI300/MI300X Claude quickstart. ```bash git clone https://github.com/AMD-AGI/AgentKernelArena.git cd AgentKernelArena # Verify the container runtime, GPU, and Python environment. make docker-smoke # Install the primary quickstart agent with Claude Code's native installer. curl -fsSL https://claude.ai/install.sh | bash claude --version # Start Claude Code and complete login on the host, then exit. claude claude auth status # Select the quickstart config for the physical GPU. CONFIG_PATH=example_configs/quickstart_claude_mi300.yaml # For MI355X instead: # CONFIG_PATH=example_configs/quickstart_claude_mi355x.yaml # Verify the agent selected by the config, then run one task. make docker-check-agents CONFIG="$CONFIG_PATH" make docker-run CONFIG="$CONFIG_PATH" # Other options: # make install-cursor-agent # Install Codex using its official CLI instructions and ensure `codex` is in PATH. ``` -------------------------------- ### Set CONFIG_PATH for MI300 quickstart Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Selects the MI300/MI300X example configuration for the single-task Claude Code quickstart. Use example_configs/quickstart_claude_mi355x.yaml on MI355X. ```bash CONFIG_PATH=example_configs/quickstart_claude_mi300.yaml ``` -------------------------------- ### Run single-task quickstart with make docker-check-agents and docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Runs the single-task Claude Code quickstart on the physical GPU. Assumes the Docker runner is installed and the agent is authenticated. ```bash make docker-check-agents CONFIG="$CONFIG_PATH" make docker-run CONFIG="$CONFIG_PATH" ``` -------------------------------- ### Select quickstart config for GPU (CONFIG_PATH) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Choose the quickstart configuration matching the physical GPU before running an experiment. The MI300 example is active; the MI355X line is commented out as an alternative. ```bash CONFIG_PATH=example_configs/quickstart_claude_mi300.yaml # For MI355X instead: # CONFIG_PATH=example_configs/quickstart_claude_mi355x.yaml ``` -------------------------------- ### Run a task with the RDNA4 quickstart config Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/install/install.md Starts a task directly; its preflight prepares the same image. Requires installing and authenticating Claude Code first. Existing images are reused; explicit image overrides disable automatic builds. ```bash CONFIG_PATH=example_configs/quickstart_claude_rdna4.yaml make docker-check-agents CONFIG="$CONFIG_PATH" make docker-run CONFIG="$CONFIG_PATH" ``` -------------------------------- ### Copy example config to create custom experiment Source: https://github.com/amd-agi/agentkernelarena/blob/main/README.md Start from an example config matching your GPU and agent, then copy it to a local config_*.yaml file. The repository ignores the config_*.yaml pattern, so keep the copy untracked; commit reusable examples only after repository cleanliness checks. ```bash cp example_configs/quickstart_claude_mi300.yaml config_experiment.yaml ``` -------------------------------- ### Copy example configuration Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/use-evaluation-tools.md Starts from the disabled example by copying the MI355X run configuration to a new file. The copy has evaluation_tools.enabled: false, so no sidecar is built or started when AKA_EVAL_TOOLS is unset. ```bash cp example_configs/evaluation_tools_advisory_mi355x.yaml my_sanitized_run.yaml ``` -------------------------------- ### Run Configuration Example Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/reference/api-reference.md Defines a single experiment with agent template, tasks, GPU model, and directory settings. Use as a starting point from example_configs/. ```yaml agent: template: cursor tasks: - hip2hip/GELU - triton2triton/vllm/triton_rms_norm target_gpu_model: MI300 log_directory: logs workspace_directory_prefix: workspace ``` -------------------------------- ### Select a quickstart configuration (CONFIG_PATH) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/install/install.md Choose the configuration matching your GPU and agent. The default make docker-run uses the MI300/MI300X quickstart; on other GPUs pass the matching CONFIG. The commented line shows the MI355X alternative. ```bash # MI300/MI300X: CONFIG_PATH=example_configs/quickstart_claude_mi300.yaml # For MI355X instead: # CONFIG_PATH=example_configs/quickstart_claude_mi355x.yaml ``` -------------------------------- ### Copy example configuration for a new experiment Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/install/install.md Create another experiment by copying the nearest example and editing the copy rather than changing a shared example in place. ```bash cp "$CONFIG_PATH" my_experiment.yaml ``` -------------------------------- ### Development setup commands Source: https://github.com/amd-agi/agentkernelarena/blob/main/CONTRIBUTING.md Commands to verify the Docker container, check agent configurations, and install optional tools. Run inside the GPU runtime container. Optional steps include strict agent checks, Cursor Agent CLI installation, FlyDSL setup, and pre-commit hooks. ```bash # Verify the container can see Python, ROCm tools, and the GPU make docker-smoke # Select a run config and verify only its agent CONFIG_PATH=example_configs/quickstart_claude_mi300.yaml make docker-check-agents CONFIG="$CONFIG_PATH" # Optional strict check of Cursor, Claude Code, and Codex make docker-check-agents AGENTS=all # Optional: install the Cursor Agent CLI on the host (so it can be mounted) make install-cursor-agent # Optional: install FlyDSL when the image lacks it (for all three FlyDSL task types) make docker-setup-flydsl # Optional: install local commit hooks pre-commit install ``` -------------------------------- ### Copy and edit example config (cp, CONFIG_PATH) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Define a different experiment by copying the nearest example configuration and updating CONFIG_PATH to point to the new file. ```bash cp "$CONFIG_PATH" my_experiment.yaml CONFIG_PATH=my_experiment.yaml ``` -------------------------------- ### Start a parallel run on an 8-GPU server Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/parallel-run.md Example for an 8-GPU server, listing all GPU IDs. ```bash make docker-parallel-run CONFIG="$CONFIG_PATH" GPU_IDS=0,1,2,3,4,5,6,7 ``` -------------------------------- ### Run experiment with make docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Runs the experiment defined in config_triton.yaml. Each task gets its own workspace under the same run_/ directory, and post-processing aggregates them into a run report. ```bash make docker-run CONFIG=config_triton.yaml ``` -------------------------------- ### Build and serve the comparison dashboard Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Build the dashboard including workspace runs, then serve it locally on port 8080. Open http://127.0.0.1:8080 to compare scores side-by-side. ```bash python3 -m src.visualization build --include-workspace-runs python3 -m src.visualization serve --host 127.0.0.1 --port 8080 ``` -------------------------------- ### Install Forge extra and probe engine Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/forge/README.md Install the 'forge' extra in the GPU runtime environment, which also pulls agent SDK dependencies. Then run the engine probe to report what the installed engine accepts in the exact interpreter the campaign will use. Requires Python 3.10+, Click, PyYAML, Anthropic, Claude Agent SDK, and OpenAI Codex SDK; do not install an arbitrary PyPI Torch wheel over the ROCm image's torch. ```bash # HYPERLOOM_ROOT names the separately mounted/pinned checkout in the container. python3 -m pip install "${HYPERLOOM_ROOT}[forge]" python3 agents/forge/engine.py --arena-probe ``` -------------------------------- ### Set up FlyDSL in the container Source: https://github.com/amd-agi/agentkernelarena/blob/main/README.md Runs `make docker-setup-flydsl` to install FlyDSL in the container when the pinned image does not already provide it. FlyDSL tasks require FlyDSL to be present. ```bash make docker-setup-flydsl ``` -------------------------------- ### Resume most recent run with docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Resume the most recent run without repeating completed tasks using --resume-latest. ```bash # Resume the most recent run make docker-run CONFIG=example_configs/quickstart_claude_mi300.yaml RUN_ARGS="--resume-latest" ``` -------------------------------- ### Resume specific run directory with docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Resume a specific run directory using --resume-run with the run directory name. ```bash # Or resume a specific run directory make docker-run CONFIG=example_configs/quickstart_claude_mi300.yaml RUN_ARGS="--resume-run run_20260617_101500" ``` -------------------------------- ### Example task_result.yaml content Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md A successful task_result.yaml includes fields like task_name, pass_compilation, pass_correctness, execution times, speedup_ratio, and score. ```yaml task_name: hip2hip/GELU pass_compilation: true pass_correctness: true base_execution_time: 1.82 best_optimized_execution_time: 1.15 speedup_ratio: 1.58 score: 278.0 ``` -------------------------------- ### Start a Docker run with make docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Starts a Docker-based evaluation run using the config file specified by the CONFIG_PATH environment variable. The Docker runner preflights the selected config before starting the run. ```bash make docker-run CONFIG="$CONFIG_PATH" ``` -------------------------------- ### Run eight GPU workers in parallel Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Start one Docker worker per GPU using `make docker-parallel-run` with `GPU_IDS=0,1,2,3,4,5,6,7`. Each worker sees one logical GPU inside its container (`HIP_VISIBLE_DEVICES=0`, `CUDA_VISIBLE_DEVICES=0`) while `ROCR_VISIBLE_DEVICES` selects the host GPU. Post-processing runs once after all worker containers finish. ```bash make docker-parallel-run \ CONFIG=config_parallel_claude_mi355x.yaml \ GPU_IDS=0,1,2,3,4,5,6,7 \ RUN_ARGS="--run-suffix claude_parallel8" ``` -------------------------------- ### Build documentation locally with Sphinx Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/README.md Creates a virtual environment, installs documentation dependencies, and builds HTML output. Run from the repository root. The build succeeds locally but prints benign intersphinx warnings and a 'Current project not found' message until the project is registered. ```bash # From the repository root python3 -m venv .docvenv source .docvenv/bin/activate pip install -r docs/sphinx/requirements.txt python -m sphinx -T -b html docs docs/_build/html # Open docs/_build/html/index.html ``` -------------------------------- ### Cursor Agent run configuration (my_experiment.yaml) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Example YAML for a custom run using Cursor Agent. Install and authenticate Cursor before selecting it. The tasks list supports granular paths, with commented options for all tasks under a category or every available task. ```yaml agent: template: cursor # one agent template per run tasks: - hip2hip/GELU - triton2triton/vllm/triton_rms_norm # - hip2hip # all tasks under a category # - all # every available task target_gpu_model: MI300 log_directory: logs workspace_directory_prefix: workspace ``` -------------------------------- ### Run a quality loop campaign with Docker Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/quality-loop.md Starts a campaign using the specified config. Select example_configs/quality_loop_mi355x.yaml on an MI355X host. ```bash make docker-quality-loop \ CONFIG=example_configs/quality_loop_mi300.yaml ``` -------------------------------- ### Run across multiple GPUs with RUN_ARGS Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md RUN_ARGS works the same way as docker-run. This example runs on two GPUs with a run suffix. ```bash make docker-parallel-run \ CONFIG="$CONFIG_PATH" \ GPU_IDS=0,1 \ RUN_ARGS="--run-suffix parallel_smoke" ``` -------------------------------- ### Example Commands for PR Description Source: https://github.com/amd-agi/agentkernelarena/blob/main/CONTRIBUTING.md Include these commands in your PR description to show the task selector exercised and key commands. The first runs a Docker container with a specified config, the second compares run directories. ```bash make docker-run CONFIG=example_configs/quickstart_claude_mi300.yaml ``` ```bash python3 src/tools/compare_runs.py ``` -------------------------------- ### Inspect CLI versions and help Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/reference/agent-model-defaults.md Run version and help commands for codex, claude, and cursor-agent to inspect their interfaces. No installation, login state, task source, or GPU job is changed during these checks. ```bash codex --version codex exec --help claude --version claude --help cursor-agent --version cursor-agent --help cursor-agent models ``` -------------------------------- ### Example output format for final code Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/triton2triton/rocmbench/easy/test_add_kernel/README.md Shows the required format for submitting the optimized kernel code. The final code must be provided inside a Python code block. ```python ``` -------------------------------- ### Inspect result directory structure Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Shows the expected workspace layout after a successful run, with a task_result.yaml file at the deepest level. ```text workspace_MI300_claude_code/ └── run_/ └── hip2hip_gpumode_GELU_/ └── task_result.yaml ``` -------------------------------- ### Install and authenticate agent CLIs Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/install/install.md Install whichever agent you plan to run. Claude Code recommends its native installer; npm is also supported by the Docker runner. Authenticate on the host before an agent check or experiment. ```bash # Recommended native installation on Linux/macOS/WSL: curl -fsSL https://claude.ai/install.sh | bash claude --version # Alternative npm installation (requires Node.js 22+): # node --version # npm --version # npm install -g @anthropic-ai/claude-code # Authenticate on the host after either installation, then exit Claude Code. claude claude auth status # Alternatively, install Cursor Agent: # make install-cursor-agent # For Codex, follow its official CLI instructions and ensure `codex` is on PATH. ``` -------------------------------- ### Resume parallel run with docker-parallel-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Resume a parallel run using the same resume arguments with docker-parallel-run. Two commands are shown: one for --resume-latest and one for --resume-run. ```bash make docker-parallel-run CONFIG=config_parallel_claude_mi355x.yaml GPU_IDS=0,1,2,3 RUN_ARGS="--resume-latest" ``` ```bash make docker-parallel-run CONFIG=config_parallel_claude_mi355x.yaml GPU_IDS=0,1,2,3 RUN_ARGS="--resume-run run_20260617_101500_parallel8" ``` -------------------------------- ### Parallel run directory structure Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md The run directory contains normal per-task workspaces plus a scheduler queue with `pending/`, `running/`, `done/`, and `failed/` subdirectories. ```text workspace_MI355X_claude_code/ └── run__claude_parallel8/ ├── .parallel/ │ ├── pending/ │ ├── running/ │ ├── done/ │ └── failed/ ├── hip2hip_gpumode_GELU_/ │ └── task_result.yaml └── reports/ └── overall_report.txt ``` -------------------------------- ### Build all six local gfx950 images Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/use-evaluation-tools.md Builds all six local gfx950 evaluation tool images from the repository root. Requires Docker and network access to pinned package and source locations. Runtime sidecars start with networking disabled. ```bash src/scripts/docker_benchmark.sh build-eval-tool-images ``` -------------------------------- ### Run smoke test with Docker Source: https://github.com/amd-agi/agentkernelarena/blob/main/CONTRIBUTING.md Run a smoke test against at least one task before submitting a pull request. Uses the example configuration file 'example_configs/quickstart_claude_mi300.yaml'. ```bash make docker-run CONFIG=example_configs/quickstart_claude_mi300.yaml ``` -------------------------------- ### Run parallel validator with docker-parallel-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Command to launch the parallel validator using the configuration above. Uses GPU_IDS=0,1,2,3,4,5,6,7 and RUN_ARGS="--run-suffix validator_parallel8". ```bash make docker-parallel-run \ CONFIG=config_parallel_validator_mi355x.yaml \ GPU_IDS=0,1,2,3,4,5,6,7 \ RUN_ARGS="--run-suffix validator_parallel8" ``` -------------------------------- ### Start a parallel run with RUN_ARGS Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/parallel-run.md Use `RUN_ARGS` the same way as `docker-run` to pass additional arguments. ```bash make docker-parallel-run \ CONFIG="$CONFIG_PATH" \ GPU_IDS=0,1,2,3,4,5,6,7 \ RUN_ARGS="--run-suffix cursor_parallel8" ``` -------------------------------- ### Run the task validator Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Run the task_validator agent using the configuration saved as `config_validator.yaml`. The generated `validation_report.yaml` appears in the task workspace. ```bash make docker-run CONFIG=config_validator.yaml ``` -------------------------------- ### Prerequisites: verify Codex and GitHub CLI authentication Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/quality-loop.md Run these commands to confirm Codex and GitHub CLI are installed and authenticated, and that the GitHub identity has push permission to the repository. ```bash codex --version gh auth status -h github.com gh api repos/AMD-AGI/AgentKernelArena --jq '.permissions.push' ``` -------------------------------- ### Parallel worker configuration (config_parallel_claude_mi355x.yaml) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md Configuration for running eight GPU workers in parallel on an 8-GPU server. Save as `config_parallel_claude_mi355x.yaml`. Workers share the same task queue. ```yaml agent: template: claude_code tasks: - hip2hip target_gpu_model: MI355X log_directory: logs workspace_directory_prefix: workspace ``` -------------------------------- ### Verify agent inside runtime container (make docker-check-agents) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Install and authenticate the agent named by the selected config, then verify it inside the runtime container using the make target with the CONFIG_PATH variable. ```bash make docker-check-agents CONFIG="$CONFIG_PATH" ``` -------------------------------- ### hip2hip / torch2hip YAML example Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/held_out/README.md Defines a hip2hip task with 11 original shapes and init_constraints.features=4. Two injections replace the get_inputs function in separate files, with the second noted as identical to the modular version. ```yaml task_type: hip2hip num_original_shapes: 11 init_constraints: features: 4 injections: - file: pytorch_code_module/py_11754_layer_normalization.py find_marker: "def get_inputs" replacement_code: | def get_inputs(): ... - file: pytorch_code_functional/py_11754_layer_normalization_func.py find_marker: "def get_inputs" replacement_code: | def get_inputs(): ... # identical to modular ``` -------------------------------- ### Run GEAK focused CPU test suite Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/geak/README.md Executes the focused CPU fixture runners for schema and workflow tests. Requires a configured upstream checkout and Node binary via GEAK_TEST_NODE. Optional probe dependencies should be installed in the ignored agents/geak/.scratch-env environment, not a shared GEAK or global environment. ```bash GEAK_TEST_CHECKOUT="$GEAK_HOME" GEAK_TEST_NODE= \ python3 -m pytest -q tests/test_geak_schema_v2.py tests/test_geak_workflow_runner.py ``` -------------------------------- ### Example run-level evaluation_tools YAML configuration Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/reference/api-reference.md Defines the evaluation tools configuration with enabled tools, policy, positive control, timeout, and per-tool options. Unknown fields and unknown enabled tool IDs are rejected. If both runtime_ref and image_digest are supplied, they must be identical. ```yaml evaluation_tools: enabled: - gpu_asan policy: advisory positive_control: required timeout_s: 600 tools: gpu_asan: options: {} ``` -------------------------------- ### Manifest entry example for patches.json Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/e2e/qwen3_0_6b_sglang/README.md Each manifest entry names a runtime module, dotted symbol, candidate Python file relative to source/, and replacement callable. Use the model class names present in the pinned image. ```json {"version": 1, "patches": [{ "module": "sglang.srt.models.qwen3", "symbol": "Qwen3DecoderLayer.forward", "file": "fused_layer.py", "callable": "forward" }]} ``` -------------------------------- ### Use a non-default config file with make docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Sets CONFIG_PATH to a non-default config file (e.g., config_triton.yaml) to keep multiple task sets side-by-side, then starts the Docker run. ```bash CONFIG_PATH=config_triton.yaml make docker-run CONFIG="$CONFIG_PATH" ``` -------------------------------- ### Run with explicit MI355X image digest Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/install/install.md Selects the previous MI355X runtime image by digest via AKA_DOCKER_IMAGE_GFX950 and runs the Docker runner with a quickstart config. Use to reproduce a run on the previous MI355X runtime. ```bash AKA_DOCKER_IMAGE_GFX950=lmsysorg/sglang-rocm@sha256:b435b508b5aa696abb25c909341ce73e41574c4271cf716bed72418dcea86b78 \ make docker-run CONFIG=example_configs/quickstart_claude_mi355x.yaml ``` -------------------------------- ### Manually inspect FlyDSL in Docker shell Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/flydsl2flydsl/README.md Enter the supported runtime and check the installed FlyDSL version. Useful for manual inspection after setup. ```bash make docker-shell ``` ```python python3 -c "import flydsl; print(flydsl.__version__)" ``` -------------------------------- ### Smoke test all eight GPU workers Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/slurm-run.md Validates all eight GPU workers without starting an experiment. Use this to check the parallel setup before a full run. ```bash make slurm-parallel-smoke ``` -------------------------------- ### Build and launch interface for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n4096_k256_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n4096_k256/BUNDLE_README.md Defines the builder and launch signatures. The builder takes workload axes (m, n, k, sn, sk) as keyword arguments and returns a launch function. The runner calls launch with inputs in the order a, b, a_scale, b_scale. The builder should prepare compilation and reusable scratch; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n4096_k256_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Run core tests inside candidate image Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/reference/runtime-upgrade-qualification.md Executes the core test suite inside the new candidate image as the host UID with no GPU mounts. The command uses pytest with the cache provider disabled and targets four test files. Result: 492 passed, 21 skipped in 12.88 seconds; the skipped checks require kernelforge.rewrite_by_flydsl.protocol, which is not installed in the base image. ```bash python3 -m pytest -q -p no:cacheprovider \ tests/test_score.py tests/test_perf_helper_materialization.py \ tests/test_evaluator_stub_guard.py tests/test_sikl_tasks.py ``` -------------------------------- ### CMake configuration for hip_matrix_multiplication Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/hip2hip/matrix_multiplication/CMakeLists.txt Build configuration for the hip_matrix_multiplication example. Sets GPU_RUNTIME to HIP or CUDA, requires CMake 3.21, and compiles main.hip and source/kernel_launch.hip. Adds a ctest test and installs the executable. ```cmake # MIT License # # Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. set(example_name hip_matrix_multiplication) cmake_minimum_required(VERSION 3.21 FATAL_ERROR) project(${example_name} LANGUAGES CXX) set(GPU_RUNTIME "HIP" CACHE STRING "Switches between HIP and CUDA") set(GPU_RUNTIMES "HIP" "CUDA") set_property(CACHE GPU_RUNTIME PROPERTY STRINGS ${GPU_RUNTIMES}) if(NOT "${GPU_RUNTIME}" IN_LIST GPU_RUNTIMES) set(ERROR_MESSAGE "GPU_RUNTIME is set to \"${GPU_RUNTIME}\".\nGPU_RUNTIME must be either HIP or CUDA." ) message(FATAL_ERROR ${ERROR_MESSAGE}) endif() enable_language(${GPU_RUNTIME}) set(CMAKE_${GPU_RUNTIME}_STANDARD 17) set(CMAKE_${GPU_RUNTIME}_EXTENSIONS OFF) set(CMAKE_${GPU_RUNTIME}_STANDARD_REQUIRED ON) if(WIN32) set(ROCM_ROOT "$ENV{HIP_PATH}" CACHE PATH "Root directory of the ROCm installation" ) else() set(ROCM_ROOT "/opt/rocm" CACHE PATH "Root directory of the ROCm installation" ) endif() list(APPEND CMAKE_PREFIX_PATH "${ROCM_ROOT}") add_executable(${example_name} main.hip source/kernel_launch.hip) # Make example runnable using ctest add_test(NAME ${example_name} COMMAND ${example_name}) set(include_dirs "../../Common") if(GPU_RUNTIME STREQUAL "CUDA") list(APPEND include_dirs "${ROCM_ROOT}/include") endif() target_include_directories(${example_name} PRIVATE ${include_dirs}) set_source_files_properties(main.hip source/kernel_launch.hip PROPERTIES LANGUAGE ${GPU_RUNTIME}) install(TARGETS ${example_name}) ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n1024_k4096_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n1024_k4096/BUNDLE_README.md Defines the builder and launch function signatures. The builder receives workload axes as keyword arguments and returns launch, which the runner calls with inputs in the order a, b, a_scale, b_scale. Prepare compilation and reusable scratch in the builder; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n1024_k4096_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Start a parallel run with GPU_IDS Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/parallel-run.md Use `make docker-parallel-run` with `CONFIG` and `GPU_IDS` to run tasks across specified GPUs. Each GPU gets one worker container. ```bash CONFIG_PATH=example_configs/benchmark_cursor_mi355x.yaml make docker-parallel-run CONFIG="$CONFIG_PATH" GPU_IDS=0,1,2,3 ``` -------------------------------- ### Parallel task_validator configuration (config_parallel_validator_mi355x.yaml) Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/examples/examples.md YAML configuration for running task_validator in parallel on MI355X GPUs. Save as config_parallel_validator_mi355x.yaml. Each task workspace writes validation_report.yaml, and the run directory gets one final validation_summary.yaml after all workers complete. ```yaml agent: template: task_validator tasks: - hip2hip target_gpu_model: MI355X log_directory: logs workspace_directory_prefix: workspace ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n512_k4096_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n512_k4096/BUNDLE_README.md Defines the builder and launch call signatures. The builder takes m, n, k, sn, sk as keyword arguments and returns launch, which is called with a, b, a_scale, b_scale in that order. Prepare compilation and scratch in the builder; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n512_k4096_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k1024_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k1024/BUNDLE_README.md Shows the builder signature and the launch signature. The builder receives every declared axis (m, n, k, sn, sk) as keyword arguments and returns launch, which the runner calls with the definition's inputs as positional arguments in the order a, b, a_scale, b_scale. Prepare compilation, shape-dependent choices, and reusable scratch in the builder; launch must recompute outputs from current input values on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k1024_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Build and serve with one command Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/visualization.md Combines build and serve in a single invocation. The equivalent convenience target is make visualization-run. ```bash python3 -m src.visualization run \ --include-workspace-runs \ --host 127.0.0.1 \ --port 8080 ``` -------------------------------- ### Inspect task selection with --plan Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/quality_loop/README.md Runs the quality loop agent in plan mode to inspect task selection without credentials, GPU work, or mutations. Uses the MI300 configuration file. ```bash python3 -m agents.quality_loop \ --config example_configs/quality_loop_mi300.yaml \ --plan ``` -------------------------------- ### Builder and launch interface for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n1536_k4096_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n1536_k4096/BUNDLE_README.md Defines the module builder and launch function signatures. The builder takes workload axes (m, n, k, sn, sk) as keyword arguments and returns a launch callable. The runner invokes launch with inputs in the order a, b, a_scale, b_scale. Prepare compilation and reusable scratch in the builder; launch must recompute outputs from current inputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n1536_k4096_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Build and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k4096_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k4096/BUNDLE_README.md Defines the builder and launch function signatures. The builder takes workload axes (m, n, k, sn, sk) as keyword arguments and returns a launch function. The runner calls launch with the definition's inputs in the given order; launch must recompute outputs from current input values on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k4096_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Install and configure DeepSeek Harness CLI Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/deepseek_harness/README.md Install the pinned CLI version from agent_config.yaml and set the API key without exposing it in shell history. Requires a dedicated Linux Node.js 24 installation with node and npm's global dsh in the same prefix. ```bash DSH_VERSION=$(sed -n 's/^cli_version: //p' agents/deepseek_harness/agent_config.yaml) npm install --global --ignore-scripts "@deepseek-ai/dsh@$DSH_VERSION" dsh --version # Enter the key without putting its literal value in shell history. read -rsp 'DeepSeek API key: ' DEEPSEEK_API_KEY echo export DEEPSEEK_API_KEY ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k256_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k256/BUNDLE_README.md Defines the builder and launch call signatures. The builder receives workload axes as keyword arguments and returns launch, which the runner calls with inputs in the given order. Prepare compilation and scratch in the builder; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k256_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Register and launch an agent Source: https://github.com/amd-agi/agentkernelarena/blob/main/README.md Create agents/your_agent/launch_agent.py with this interface used by main.py. The function must be decorated with @register_agent("your_agent") and return the agent's output as a string. ```python from agents import register_agent @register_agent("your_agent") def launch_agent( eval_config: dict, task_config_dir: str, workspace: str, ) -> str: # Build the prompt, invoke the agent in `workspace`, and return its output. return result ``` -------------------------------- ### Start a parallel run without GPU_IDS Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/parallel-run.md If `GPU_IDS` is omitted, the runner discovers GPUs with `rocm-smi --showid` and starts one worker per discovered GPU. ```bash make docker-parallel-run CONFIG="$CONFIG_PATH" ``` -------------------------------- ### Run Forge tests with pytest Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/forge/README.md Runs the Forge test suite with pytest. The first command executes the core Forge tests. The second command, gated on AKA_FORGE_PROBE_PYTHON, exercises the real installed upstream orchestration without LLM/GPU, using the specified Python interpreter that has hyperloom-forge installed. ```bash python3 -m pytest -q tests/test_forge*.py ``` ```bash # Additionally exercise real installed upstream orchestration without LLM/GPU: AKA_FORGE_PROBE_PYTHON= \ python3 -m pytest -q tests/test_forge_v2.py tests/test_forge_initialization.py ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k512_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k512/BUNDLE_README.md Defines the builder function signature and the returned launch callable. The builder receives workload axis values (m, n, k, sn, sk) as keyword arguments and returns launch, which the runner calls with inputs a, b, a_scale, b_scale in that order. Prepare compilation and reusable scratch in the builder; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k512_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### GPU groups configuration for multi-GPU tasks Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/parallel-run.md Maps the scheduler-provided GPU pool onto workers using resources.gpu_groups, where entries are indices into that pool. With GPU_IDS=0,1,2,3,4,5,6,7 this starts two workers with four GPUs each. Overlapping groups, indices outside the pool, or mismatched group sizes fail before any container starts. ```yaml resources: gpu_groups: [[0, 1, 2, 3], [4, 5, 6, 7]] ``` -------------------------------- ### triton2triton YAML example Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/held_out/README.md Defines a held-out task for triton2triton with 5 original shapes and a single injection replacing the TEST_SHAPES marker in scripts/task_runner.py. ```yaml task_type: triton2triton num_original_shapes: 5 injections: - file: scripts/task_runner.py find_marker: "TEST_SHAPES" replacement_code: | TEST_SHAPES = [ (64, 256, 128, True, False, True), ... ] ``` -------------------------------- ### Build dashboard from workspace runs Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/visualization/README.md Builds a dashboard from normal workspace runs using the visualization module. ```bash python3 -m src.visualization build --include-workspace-runs ``` -------------------------------- ### Interactive shell with make slurm-shell Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/slurm-run.md Starts an interactive shell in the same GPU runtime. Requests one GPU by default. ```bash make slurm-shell ``` -------------------------------- ### timed_run.rerun_ms() Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/tools/perf/README.md Executes the timed unit once more through the reported sample path (preparation, start event, invocation, end event) and returns its device time, under both timing methods. ```APIDOC ## timed_run.rerun_ms() ### Description Executes the timed unit once more through the reported sample path (preparation, start event, invocation, end event) and returns its device time, under both timing methods. ### Returns - **device_time** (number) - The device time in milliseconds for the re-run. ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n4096_k512_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n4096_k512/BUNDLE_README.md Defines the builder function signature and the returned launch callable for the A8W8 blockwise scaled GEMM task. The builder receives workload axes (m, n, k, sn, sk) as keyword arguments and returns launch, which the runner calls with inputs a, b, a_scale, b_scale in that order. Prepare compilation and reusable scratch in the builder; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n4096_k512_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Make targets for visualization Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/visualization/README.md Equivalent Make targets for building, serving, and running the visualization from the repository root. ```bash make visualization-build make visualization-serve make visualization-run ``` -------------------------------- ### Builder and launch signatures for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k8192_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k8192/BUNDLE_README.md Defines the builder interface that receives workload axes as keyword arguments and returns a launch function. The launch function is called with the definition's inputs in the given order and must recompute outputs from current input values on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_asraw_n4096_k8192_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Builder and launch signature for build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n512_k4096_module Source: https://github.com/amd-agi/agentkernelarena/blob/main/tasks/Aiter-task/gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n512_k4096/BUNDLE_README.md Defines the builder function that takes workload axes as keyword arguments and returns a launch callable. The launch function receives the inputs in the order a, b, a_scale, b_scale and must return the output tensor. Prepare compilation and reusable scratch in the builder; launch must recompute outputs on every call. ```python build_gemm_a8w8_blockwise_scaled_blk128x128_nt_obfloat16_bshuf16x16_aslogical_n512_k4096_module(*, m, n, k, sn, sk) -> launch launch(a, b, a_scale, b_scale) -> out ``` -------------------------------- ### Serve built dashboard Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/visualization/README.md Serves an already-built dashboard on the specified host and port. ```bash python3 -m src.visualization serve --host 127.0.0.1 --port 8080 ``` -------------------------------- ### Check ROCm backend target Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/prompts/cheatsheet/triton_cheatsheet.md Confirm the ROCm backend is active by printing the current target. Example output shows HIPBackend with arch='gfx942' (MI300X). ```python import triton # Confirm ROCm backend is active print(triton.runtime.driver.active.get_current_target()) # → HIPBackend(arch='gfx942') (MI300X) ``` -------------------------------- ### timed_run.before_sample Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/tools/perf/README.md Set timed_run.before_sample to a callback accepting the number of logical calls in that sample's replay. The helper invokes it on the measurement stream, after prepare_fn (when present) and before the start event of each reported sample. ```APIDOC ## timed_run.before_sample ### Description Set `timed_run.before_sample` to a callback accepting the number of logical calls in that sample's replay. The helper invokes it on the measurement stream, after `prepare_fn` (when present) and before the start event of each reported sample. ### Parameters - **callback** (function) - Required - A callable that accepts the number of logical calls in the sample's replay. ### Behavior - Not called during warmup, capture, estimation, graph priming, or `rerun()`. - The task may retain a private copy of the last sample's starting state and use that state plus the replay count for an independent reference after timing. - The callback must only observe state; it must not reset inputs or run the reference. - It does not change graph batching. - Apply the same observation and state policy to baseline and candidate. - An observer exception rejects the measurement and leaves the collector unbound. ``` -------------------------------- ### Run GEAK Docker checks and execution with make Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/geak/README.md Use these make commands to run GPU experiments for the geak agent through Docker. Replace with your run configuration. Docker provisions Claude for geak and its v2 aliases, mounts the selected GEAK checkout read-only, and forwards GEAK_HOME. ```bash make docker-check-agents CONFIG= ``` ```bash make docker-run CONFIG= ``` -------------------------------- ### Smoke test all workers Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/use-evaluation-tools.md Checks that all workers start and report their pinned assets. Prints evidence and exits nonzero if a worker reports degraded, including a failed nested positive control. ```bash src/scripts/docker_benchmark.sh eval-tools-smoke ``` -------------------------------- ### Run quality loop via Docker Source: https://github.com/amd-agi/agentkernelarena/blob/main/agents/quality_loop/README.md Runs the quality loop through the supported Docker environment using the MI300 configuration. ```bash make docker-quality-loop CONFIG=example_configs/quality_loop_mi300.yaml ``` -------------------------------- ### Alignment hint with tl.multiple_of Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/prompts/cheatsheet/triton_cheatsheet.md Pass pointers with `tl.multiple_of(ptr, alignment)` to guarantee the compiler emits wider loads. The example uses a 16-element alignment hint. ```python X = tl.multiple_of(X, 16) # 16-element alignment hint ``` -------------------------------- ### Verify agent and run single task with make docker-check-agents and make docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/install/install.md After selecting CONFIG_PATH, verify the agent selected by that configuration, then run the single GELU task. Both commands use the same CONFIG variable. ```bash make docker-check-agents CONFIG="$CONFIG_PATH" make docker-run CONFIG="$CONFIG_PATH" ``` -------------------------------- ### triton2triton/rocmbench YAML example Source: https://github.com/amd-agi/agentkernelarena/blob/main/src/held_out/README.md Shows two raw_replace injections in test_add_kernel.py, each replacing a parametrize decorator with a smaller shape set. The first targets SIZE,BLOCK_SIZE and the second targets SIZE,BLOCK_SIZE_ARG. ```yaml task_type: triton2triton num_original_shapes: 2 injections: - file: test_add_kernel.py find_marker: "raw_replace" old_code: | @pytest.mark.parametrize('SIZE,BLOCK_SIZE,dtype_str', [(98432, 1024, dtype_str) for dtype_str in ['float16', 'float32']]) replacement_code: | @pytest.mark.parametrize('SIZE,BLOCK_SIZE,dtype_str', [(65536, 512, dtype_str) for dtype_str in ['float16', 'float32']]) - file: test_add_kernel.py find_marker: "raw_replace" old_code: | @pytest.mark.parametrize('SIZE,BLOCK_SIZE_ARG,dtype_str', [(98432, 1024, dtype_str) for dtype_str in ['float16', 'float32']] + [(1048576, 2048, dtype_str) for dtype_str in ['float16', 'float32']]) replacement_code: | @pytest.mark.parametrize('SIZE,BLOCK_SIZE_ARG,dtype_str', [(65536, 512, dtype_str) for dtype_str in ['float16', 'float32']]) ``` -------------------------------- ### Add a run suffix with make docker-run Source: https://github.com/amd-agi/agentkernelarena/blob/main/docs/how-to/run-evaluation.md Adds a suffix to label a run directory (useful for A/B testing). The example shows the resulting directory name: workspace_MI300_cursor/run_20260617_101500_cursor_with_mcp. ```bash make docker-run CONFIG="$CONFIG_PATH" RUN_ARGS="--run-suffix cursor_with_mcp" # → workspace_MI300_cursor/run_20260617_101500_cursor_with_mcp ```